.

>>105591346 (OP)
LMAO

>>105591346 (OP)
>shipping software
>with go
kek

Haskell sisters? Our response??

You are joking, but Go is actually just so good for shipping software

FP saars have been real quiet ever since this dropped ...

>>105591346 (OP)
why is Haskell a worm?

>>105591416
Because FP is used by worms

>>105591346 (OP)
I hate that stupid fucking gopher so goddamn much. No other mascot makes me so irrationally angry. I want to kick his little teal fatbody down a flight of stairs and stomp on it until the eyes bug out and it makes squeaky noises like a dog toy.

>>105591468
>I hate that stupid fucking gopher so goddamn much. No other mascot makes me so irrationally angry
Based. Stay mad

>>105591346 (OP)
my fellow gochads we won so hard with this

>>105591357
It's technically the most servers running code after C
Thanks, docker

>>105591346 (OP)
OCaml does both.

>>105591346 (OP)
>>105591354
>>105591360
>>105591376
>>105591656
samefag

this causes the gopher to go into an uncontrollable rage

>>105592018
for i := 1; i < 10; i += 2 {
fmt.Println(i)
}

>>105592058
Ewww

>>105592018
Why does 0..1 = a step size of 2?

>>105592018
Wait, why does it not print 0? min...max is not inclusive of min? What kind of garbage is that?

>>105592104
Even fucking rust does better than this shit.

>>105591346 (OP)
Subhuman AI pajeet

>>105592131
It's my own function nigga not the std calm down

>>105592149
Why did you make min non-inclusive you subhuman

>>105592131
That virtual text looks distracting

>>105592149
You have rustled my jimmies and I refuse to calm down until you explain yourself.

>>105592161
I don't program in Rust and I'm not going to set up vim to work with it so this is just whatever the VSCode + Rust plugin defaults to.

>>105592058
Based looper

>>105592153
step by 2 means step by 2. if i didn't skip the first element then it wouldn't be stepping by 2 now would it?

>>105592225
It should be 0, 2, 4, 6, 8
fucking retard

>>105592233
should be 1, 3, 5, 7, 9. since you are stepping by 2 you need to skip the first element which is 0.

>>105592266
>since you are stepping by 2 you need to skip the first element
what!

for (int i = 0; i <= 10; ++i){
printf("%d\n", i);
}


I only use C, Go, and Hare and retain strict adherence to style(9).
Yes, I am a white man.. are you?

>>105592273
0,1,2,3,4,5,6,7,8,9,10
skip, print, skip, print, skip, print ....

it's a matter of whether you start counting after the first element or before the first element. it doesn't really matter though since both ways are piss easy to implement. also you are a vanta black gorilla nigger

>>105592280
>I only use C, Go, and Hare
Holy based

>>105592280
>I only use C, Go, and Hare
Wow, an actual white man on /g/ ...

>>105592280
QRD on Hare?

>>105591346 (OP)
What if I want to ship type theory and masturbate to software?

>>105592339

>>105591346 (OP)
trvke, after trying go i realized that its the working man's language, go let's you do work, functional garbage let's you join cyber-orgies full of nerds that haven't left their room in weeks.

>>105592371
>vibrant community
Dropped

>>105592381

>>105592058
Ok, now do a group by

>>105592388
The person on the right is a jew and he works for microsoft. Retard

>>105592407
>muh kikes
go back to pol

>>105592388
she CUTE

>>105592339
Small, concise, sane, rigorous, maintained by white men.
Website: troon free
Mascot: cute af

Let me guess.. you need more..

>>105592416
Hare is the white man's language, shalomovich

nice language LMAO

>>105592131
>in 17s
holy fuck I knew rust was bad but that's embarrassing. but hey, at least they have a code of conduct and are inclusive lmao

>>105592403
you mean like a basic struct

>>105592480
>0.17s = 17s
smartest cnile

>>105591346 (OP)

>>105592492
why would you count the leading zeroes?

>>105592449
using a non-mainstream language is fucking retarded. you are begging to have to deal with compiler bugs and non-existent tooling. the only languages you should even consider: C C++ C# Java python js, go, rust

>>105592510
I think you mean C Go and Hare.
By white men, for white men.

>>105592533

>>105592533
It's a sexy combination to be sure. But what if I need something more application specific?

>>105592569
Under such circumstances you are permitted to use Python or JS, and if absolutely needed Lua, but white men don't speak of this in public, it's a private matter for only private conversations.

>>105592403
Seems like a good fit for soa rather than an array of structs.
typedef struct {
std::vector<std::string> Name;
std::vector<std::string> Class;
} Students;

>>105593191
yikes forever

students := []Student{
{Name: "Alice", Class: "Math"},
{Name: "Bob", Class: "Science"},
{Name: "Charlie", Class: "Math"},
{Name: "David", Class: "Science"},
{Name: "Eve", Class: "History"},
}

groups := make(map[string][]Student)

for _, s := range students {
groups[s.Class] = append(groups[s.Class], s)
}

wow so hard

>>105593446
meant for >>105592403

>>105591346 (OP)
>>105592493
follow the author for more original content like this
https://x.com/kai_fall

>>105591346 (OP)
OCaml fits perfectly between these opposites

>>105594054
But Ocaml is sloowwww

>>105594156
Performance really depends on a task. As an anecdote, I had a program in OCaml that did a ton of AST manipulation (for genetic programming), and after a C++ rewrite (reviewed by a much more experienced C++ dev, so there probably weren't any major fuckups), it was actually slower (~1.5 times IIRC). Why? Mostly cuz we had to use std::shared_ptr since lifetimes are unknown, and they suck balls compared to a proper GC. Also, tagged sums are faster than virtual functions, AFAIK. We've still replaced the OCaml version with the C++ one for maintainability's sake (I was the only one in the team who knew OCaml, and I used it to prototype - writing this program in C++ from the start would've made me insane), but I was actually surprised.

If you're talking about shit like HTTP servers, their performance bounds are mostly determined by whether they use modern IO APIs like io_uring. Or so I think, I'm not an expert here.

OCaml supports native compilation and its compiler is mature. All low-hanging fruits are already plucked, and if you're calling it "slowwww" I'd like to hear what languages you consider "fast".

>>105594418
Odin, Zig, Rust, C++, C fuck even Go makes Ocaml look very slow as you introduce a decent bit of mutable state into the equation (in my small usage of the language anyway). Even for something as simple as the game of life Ocaml is like 1/4 the speed of the listed languages. If I had to pull reason out my ass it would either be a skill issue or Ocaml's compiler sucks and copies the large arrays instead of mutating them in place. I didn't care enough about the language to find out.

>>105592510
python tooling sucks and while there are lots of libs, quality is through the floor.
C and C++ is mostly abhorrently bad except gdb, which is only good in the sense that it is a miracle it was able to patch over so many flaws in such shit languages. Actually tooling for C ans C++ has gotten significantly worse over time as old.faithfuls got nuked in favor of dogshit, buggy, configmazeware that change interface every sub-sub-point version. Modern C++ versions are also pure tranny garbage. Lisp has infinitely better tooling than C, C++ or Python by many miles, despite being niche. Also sbcl has a better C/C++ debugging experience than gdb.

>>105592510
rust and go are non-mainstream languages thoughbeit

>>105594577
Ocaml is faster than go in nearly all cases, typically not exceeding half C speed. It is indeed very highly optimized for functional patterns but you most definitely used it wrong (not your fault, easy to do). For example maybe you uses the stdlib that comes.with the language, whwn actually it's a stublike lib only meant to be used for the bootstrap compiler.

>>105594957
>He is still stuck in 2015

>>105594418
You don't need virtual functions or shared pointers for this. Your 'more experienced' dev wouldn't make it to junior level in my world. This is baby stuff. At least have the decency to use arenas and devirtualize if you want to pajeet it.

>>105595015
Cope and seethe tranny. Look it up yourself and cry yourself to sleep

>>105595040
>THIS mad

>>105591346 (OP)

>>105595110
based

>>105595110
Ah yes, that is why the only useful software in Haskell ever written was a conversion software, a program that has input, output and is essentially one giant pure function, has no state modification, etc.

>>105594953
>source: my ass

Rust's approach to handling mutability is perfect.

>>105591346 (OP)
Kek
Real

>>105591468
They should change the logo to a Perl style logo with a realistic illustration of a gopher that you might find in a 19th c encyclopedia and Go written in a serif font

>>105592510
>the only languages you should even consider: C C++ C# Java python js, go, rust
cries in Perl

>>105595110
Make her wear a fundoshi.

>>105595149
>>the sky is blue
>>source: my ass
Well done reddit

>>105594982
Sorry if sounds cunt like but 50% as fast a C is V8 javascript speeds. That puts Ocaml behind all JVM and CLR langs and comfortably behind compiled GC'd langs like Swift and Go.

>>105595150
lol

>>105592480
>redbox
Forgot those things existed
I remember picking out movies from those when I went to the store with my mom

>>105595150
Immutability is gaaayyyyyyyyyy

Go is procedural shit, reminds me of Java 1.6
literally unusable

>>105595237
>disagrees with the message
>"the messenger has to be reddit"
Name two Lisp programs that are commonly used. Bonus points for examples that have no viable alternative.

>>105595343
Show us all the software made in non procedural languages.

>>105595357
Emac

>>105595375
Emacs
>Commonly used
>No viable alternatives
LOL

>>105595374
GuptaSQL Windows is written in VB, which is a mix of functional and OOP

>>105595374
I will start with all the gaming industry

>>105595387
>C++
>Not procedural
Nice bait.

>>105595032
Okay, grant me the knowledge. What do you mean by devirtualization? I've just rechecked what it is to avoid needlessly embarrassing myself and yeah - it's an optimization that relies on _statically_ inferring that some instance of an abstract class is an instance of some particular subclass. We don't have this info at compile time if we represent AST via class hierarchy and generate the trees in runtime.

If you just messed up the terminology and meant something like "use enums with tags and cases inside function", then it would be very painful to write (and compared to OCaml, there would be a lot of manual plumbing, and the compiler wouldn't catch some dumb errors like non-exhaustive pattern-matching). Oh, std::variant? It is borderline impossible to use with recursive sum types (and nontrivial ASTs are always recursively defined) and std::visit is ugly as sin.

Re: arena allocators. Yeah, that might've improved things, but we haven't tried since we got the acceptable perf and decided not to bother further. Personally, I thought that hash consing might've been really game-changing, but again, lack of time and different priorities. Maybe I'll revisit it one day.

Also, I think it's important to compare _idiomatic_ code in different languages (although I admit that the ability to optimize the shit out of a piece of code matters as well).

>>105595132
Hey, don't forget about XMonad! AFAIK they use zippers to represent window configurations. Cool stuff.

>>105595381
>Emacs
>>Commonly used
>>No viable alternatives
>LOL
He is correct though. But IMO Emacs is a bit cheating since it's a tooling for itself.

>>105595375
The "shit tooling" language, on the other hand, gave us: yt-dlp, Calibre, HomeAssistant, Ansible, thefuck, certbot, ...
The few examples above probably contain more lines of Python code than all the Lisp code ever written.

>>105595374
Kafka, rabbitMQ, datomic, discord was running on erlang but it was rewritten in rust afaik. A lot of cell phone operators run on erlang vm

>>105595516
Yeah, it seems like while there are things like XMonad and some toy game console emulators or Tetris programs, most Haskell software is for stuff like compilers or not-quite-compilers but compiler-adjacent (e.g. Shake, Pandoc)

>>105591346 (OP)
>Ignoring the fact that Go keeps adding more complex features every year
I'd agree with this image before generics and iterators were added. With how it's going now the gopher will be masturbating to type theory in a few years too.

>>105592018
>Not using Lisp for this
Peasant.

>>105592510
The only language you should ever consider is Lisp. There's no need for any other language to exist when Lisp macros can do anything you'd want.

>>105595357
>>105595692
>Seething about Lisp
The fact that we're even talking about it as a potential alternative after 60 years shows how powerful and useful it can be. Not many 60 year old languages can still be considered as useful today.

>>105595941
>shows how powerful and useful it can be
Actually, that's 60 years of proof that Lisp is a meme language.
It was designed specifically for AI research. The AI fever is at an all-time high yet Lisp popularity is at an all-time low.
Fortran is even older, yet more popular.
And all this in spite of Lisp's allegedly excellent tooling.

>>105595110
lazy neet

>>105595941
>The fact that we're even talking about it as a potential alternative after 60 years shows how powerful and useful it can be.
But you can't name two lisp programs that are both commonly used and have no alternatives.

>>105595941
>Not many 60 year old languages can still be considered as useful today.
C?
53 years old.

>>105591346 (OP)
Literally kill yourself.

>>105596183
There isn't a single lisp with good tooling. In terms of editior support you have emacs or nothing. Emacs itself is slow, bloated mess. It is packed with useless shit and when it comes to editing code it's lacking stuff that even a online repl has (like auto complete, code suggestions, lsps out of the box), so you're forced to layer more shit on top of an already massive pile of shit, which in turns slows the editor down even more. On this system (11900k, 32gb ram) it take EIGHT FUCKING SECONDS for spacemacs to fully load. In comparison Neovim with about 100 plugins = 0.3s to load.

Onto lisps itself, the two I've invested a good chunk of time in (Clojure and Racket) are fucking garbage to develop in. If you have a bug in your program the error messages are as bad as C++. There are 2 modes of error message. 2 words (Class Exception bullshit) or fucking C++ style template errors. Good luck debugging anything remotely complicated (the shitty error messages are probably why the community around these langs are in love with TDD, either build tests as large as your program or get no fucking help what so ever, just hope your tests don't have a bug in them!). Repls for both Clojure and Racket are unstable. There are no safety guards when developing and you can easily bring down your entire developer environment if you send some bad code to the repl (which is the point of it, so you can iterate and find out what works). I hope you like waiting for emacs to loads because you're going to be doing that alot.

The reason lispfags say lisp is good because the only ones left using the language are mathfags and all they do is send some equations to the repl and that's enough. They aren't building shit (case and point the guy who spams his shitty clojure code in random threads on /g/ like it's some kind of flex when all he is doing is putting stuff into hash maps and doing basic transformations, that is who is telling you lisp is good).

>>105593525
He's fucking based, kek

>>105596946
Clojure is great precisely because maps of sequences DSL fits 90% of programming tasks.

>>105596754
no such program in any language

I like how this neo cnile thread turned into lisp-bashing
worse is better still going strong

>>105597792
Lisp was the original worse is better. Garbage collection, dynamic typing, pattern matching etc etc. Asm is all that's sneeded.

>>105591346 (OP)
TIL go keeps stdlib backwards compatable which means they cant use generics kek.
Initially delaying then capitulating on generics just goes to show its designed by NIH retards and whatever principles they had, they're willing to give up on now.
Rick Hickey mogs Rob Pike.

>>105591357
NEET detected kek

>>105592480
Rustards aren't even done extending the language. They're just getting started.
Wait until TATA Consulting Services gets a hold of it.

>>105592480
>17s
cnile reading comprehension lower than a monkey

>>105595357
Checkpoint FW-1 rules
Autocad (Autolisp)

>>105597863
>Asm is all that's sneeded.
Lisp practically was ASM...
CAR - Contents of Address Register
CDR - Contents of Decrement Register

>>105597899
Go adding generics just ended up making it obvious how fucking bad the language is. They have significant runtime overhead and are so limited in functionality that they're practically worthless.
The only people who still care about Go from my experience are webshits and people with battered wife syndrome from dynamic typing.

>>105598182
>Generics
You don't need those

>>105595259
No. v8 is quite a lot slower than that. Ocaml is usually in the range of java/c# (typically the fastest languages on their VMs, with others often as slow as 10x worse), which are faster than go and swift. In singlethreaded tasks ocaml is often fastee.

>>105595357
did you even read the post before getting mad at ghosts?
You're literally proving my point

>>105595387
jak and daxter was fully lisp

>>105595516
you're amazingly pajeety. I can't fathom how fucked up your code most be for you to make these claims. I'm glad I don't work anywhere near people as incompetent as you and your 'very experienced' friend.

>>105595692
Then that defeats the argument about using languages because of maturity and tooling don't it cletus

>>105595836
Forth is so powerful it doesn't need macros and is still more powerful than lisp.

>>105596758
that's like pointing to js and claiming it's the best web language becsuse no alternative.
But in fact people bitch about c and do everything in their power not to use it (same with js outside webshitters), the opposite of lisp

>>105598182
> battered wife syndrome from dynamic typing
There is a lot if us.

>>105596946
Thr lisp debugger alone is so good it is objectively superior in debufging compiled binaries in c libraries than any tools in cland. The repl is a millenium ahead of c debugging experience. The ability to attach. The native thread debugging contructs are unheard of anywhere else. Thr signal restart system is second to none.
Lisp workfloe often use live updates to dynamic, graphical programs, allowing realtime interactions while fully maintaining states, for the best debugging experience in existence. Lisp tooling is so good that engineers live-debugged a lisp program on a space rover in flight and saved it this way.
As for editors there are dozens of great ones and yes, vim is better than emacs for liso programming.

>>105596946
neither clojure nor racket are lisps

>>105598618
stfu conscel
clojure perfected lisp

>>105598702
the opposite. it nuked all the advantages of lisp while keeping the worst parts.

>>105598574
Oh, I was hoping you would tell me where I'm wrong so I'll be less dumb in the future, but apparently you don't want to increase average level of competence on this board (or you're just spewing nonsense and don't admit it when called out: again, WDYM by devirtualization?).

>>105599068
pearls before swine.

>>105598110
Neither of those is a Lisp program, so... thanks for proving the point, I guess?

Tons of things embed Python, even more things embed Lua.

>>105595374
>>105598571
this was a dumb question, Lisp is also procedural sometimes
the point is, Go is procedural-only

>>105598182
Generics were a mistake.

>>105593525
lmao

>>105593525
this moron is ITT, isn't he?

>>105591346 (OP)
The screwed-up way we approach software development is because of what we have done with programming languages. With some exceptions, we have opted for optimizing the description of programs for compilers, computers, and casual human readers over providing programming media. Early on, computers were insanely slow, and so performance was the key characteristic of a system, and performance was easiest to achieve when the language required you to "pin down decisions early on." Because of this, much work was poured into defining such languages and producing excellent compilers for them. Eventually, some of these languages won out over ones more suitable for drafting and exploration both in the commercial world and in academia, and as a result it is politically difficult if not impossible to use these so-called "very dynamic" languages for serious programming and system building.

>>105591346 (OP)
>we have reached the point where 4chan discourse is downstream from twitter
It's over. Cultural defeat.

>>105600025
what in the absolute fuck are you shitposting about. That's almost the exact opposite of the truth.

>>105600162
Has been like that since 2013. Other boards succumbed even earlier, like 2007.

>>105596758
As I said, not many. There's only C and Lisp. That's pretty much it, and C only survived because of Unix.

>>105598618
>>105598785
>Common Lisp retards gatekeeping the definition of Lisp
It's hilarious. If a Lisp doesn't work exactly like CL they'll claim that it's not a Lisp. Scheme is a better Lisp than CL will ever be.

>>105599399
Ok but it still doesn't change the fact that the vast majority of software is procedural. C and C like languages won that war a long time ago. The only non trivial program anyone listed on here as 'functional' is a 20 year old playstation 2 game (although by your admission that could still be made in a procedural style using lisp), the rest are basically wrappers around C code. If non procedural languages are so good then show me all the important software made in it. It's been 70 years, you can't keep saying it's a good paradigm when functional programming has effectively produced nothing of value and then skirt around that point by saying just wait 2 more weeks, trust the plan, it's coming any day now. It's been 70 years, there is no wave of functional programmers coming around the corner who are going to revolutionize programming with a bunch of type masturbation etc etc. The test has been done and it's beyond math fags (who swear by this shit) to produce anything useful as a group of programmers, unless you class pretentious books about how clever they are because their solution to hello world is the most elegant ever as something useful, if that's your stance then good for you I guess.

>>105600706
Functional language adoption is sadly virtually non-existent, but functional style has become mainstream. Interviewing for most of the languages that are popular in the industry (Javascript/Typescript, Python, Ruby, Java/C#) you will be asked about benefits of using pure functions. Functional style is simply a saner default and modern software is often written this way.

>>105600706
>Ok but it still doesn't change the fact that the vast majority of software is procedural
Most of it is object oriented, a paradigm for which C is not suitable. The industry switched from C to C++ and then Java some time ago, and then from there to dynamically-typed, object-oriented programming languages like Ruby, Python, and JavaScript. And only now is there somewhat of a type renaissance with e.g. TypeScript and type annotations of Python.
>functional programming has effectively produced nothing of value
I mean, there's tons of functional JavaScript online. Jane Street uses OCaml extensively. OCaml is also used for proof assistant languages, which have produced things of value, like verified kernels and compilers. Haskell has been used for Alcatel-Lucent's narrow band radio software. Facebook uses it for a spam-fighting rule engine. And I bring up these languages because you brought up the functional paradigm specifically and Lisp code is usually not purely functional, just object oriented or procedural. The functional paradigm is just more niche, but it's not like it's completely unused; these things just don't get a lot of attention.

>>105600853
>Lisp code is usually not purely functional, just object oriented or procedural
Oh whoops, this was unnecessary. For some reason I thought Lisp being a functional language was a topic discussion, but it's not.

>>105600889
>Having to deal with explicit lifetimes
In theory Rust's model had some pretty good advantages, but in practice it makes the code 10x more complex and you end up having to explicitly manage lifetimes for anything more complicated than a simple array.
We don't see people complaining about it yet because nobody is being forced to write Rust code at their jobs or in college. Soon enough it'll turn into yet another Java/C++.

>>105600971
And in practice rust codebases extensively use a mix of boxing and unsafe to avoid having to write lifetime annotations. If people who've been using rust from the start feel they're forced to resort to that...

>>105600672
Lisp is usually just 'cl', otherwise you say 'a lisp', but that is a nonsense because they're all totally different languages. Haskell is closer to clojure than lisp is. Chicken and racket have effectively nothing in common, not even the module system or library ecosystem, etc.
I agree that r5rs is better designed than lisp, but that is non sequitur. The topic was that non-mainstream languages don't have as good tooling as languages like js, python or c. Lisp has infitely better tooling than anything still alive at all. I don't know another lisp with anywhere near as good tooling, but racket has better tooling than python and js, and clojure has the same tooling as java, all of which totally defeats the argument.

>>105600984
>avoid having to write lifetime annotations
Right, I've seen a lot of code written in a certain way just to avoid lifetime annotations and borrow checker annoyances. If you're allocating a linked list in an array and using indices as pointers, then you've just defeated all the advantages of Rust. You can do the same in any other language, with the same safety problems that come with that style of code.

>>105601025
If they conform to r6rs or r7rs it's possible to write portable libraries (either with cond-expand or by loading *.chicken.sls/*.racket.sls) but I've only seen a handful of libraries do it in practice

>>105600971
I agree with you. In theory explicit lifetimes sounds good but in practice they increase complexity/noise/hacks to get around them. They are dogshit for iteration or exploratory work (which is probably why the majority of notable rust programs are rewrites of C programs where the domain has been solved).

>>105601112
Yes, because that is sadly only true in theory due to too many tiny bolts and screws being unserspecified or not specified. Also the r7rs small/large shit isn't helping.

>>105601215
Yeah, I see Rust's system of ownership, borrow-checking, and lifetimes and their annotations as a form of lightweight proofs, kind of like strong type systems. And there's a reason most people don't use proof-assistant languages to write programs: the more you're trying to prove, the more laborious it is to prove it. Rust just brought it down from insanely tedious and laborious to prove memory safety to manageably tedious.

>>105601391
>manageably tedious
Not even that, people often write code that avoids using lifetime annotations.
It's so tedious and slow that a good portion of Rust developers actively avoid using it.

It's the same story as C++ developers only choosing a subset of the language.

>>105600889
The gopher doesn't actually want to be there, unfortunately his left arm is fused with the chair.

>>105593525
I’m pretty close to full agreement with his tier list, the only differences are I’d put Erlang and elixir in the second tier and I’d move TS up to necessary evil alongside JS, because JS is still a necessary evil and TS makes it moderately less retarded to use.

>>105603596
>nobody cares
>erlang/elixir
>matlab (???)
>powershell
>swift
based larping retard

>>105603645
Nobody cares about matlab in 2025 and hasn’t for years when R exists. Nobody cares about powershell outside of windows shops.

>>105592403
honest question but when do you use this? If you ever have data lying around thats neat like this why not shove into a db?

>>105603596
Back in my days, trolling meant something.

>>105604162
Maybe the data is not tabular and you wouldn't want to build 999 tables with a bazillion consistency clauses to model it.

>>105603596
>nobody cares
>Ada: superior memory safe systems language than Rust. still used in avionics software
>Erlang/Elixir: supports safer / easier concurrency than any language on the list
>Lisp/Clojure: supports features that are impossible in most C-like languages
The author is clearly somebody who has only ever written in C derived languages. These three are in this category only because they're too different from C, not from any technical reason.

>>105604370
ada uses a gc

>>105604540
>ada uses a gc
Ada's GC is an optional feature. In practice nobody uses it, instead SPARK has ownership tracking like Rust does.

>>105603596
OCaml is very close to Haskell, get your shit together poser

>>105604818
I prefer ocaml to haskell, less brain masturbation more pragamatism.
there is a reason why ocaml is used a lot for proof software even if less "pure"

>>105603596
It's a crime Odin isn't used more and that Zig and Rust won out of the Nulangs.

>>105604818
Maybe in retard land

>>105604818
Ocaml has a camel. Where is Haskell's?

>>105600971
>>Having to deal with explicit lifetimes
just call to_owned(). in GC'd languages you were constantly paying the cost of cloning anyway

>>105605499
>Rust: A systems language as slow as a GC'd language
Magnificent!

>>105605592
You'll never get through to them. Rustfags still think reference counting isn't garbage collection.

>>105591360
Most shipped software is crap. Ours isn't.

>>105606599
Proof?

>>105606809
I have a Bluetooth anal buttplug powered by haskell and rust

>>105604666
the literal opposite

>>105606284
Because it isn't. GC is much better than RC in many cases.

>>105607983
More than that, there is only one case rc is better and that is when you meed more predictable latency. However, GCs can implement manual gc ops with gc pass pausing which result in the same thing.

>>105607975
No. The implementation everyone uses, GNAT, doesn't even have a garbage collector. Most implementations don't.

>>105592131
>>105592018
ugly af languages