← Home ← Back to /g/

Thread 105591346

187 posts 56 images /g/
Anonymous No.105591346 [Report] >>105591354 >>105591357 >>105591416 >>105591468 >>105591656 >>105591811 >>105591843 >>105592143 >>105592365 >>105592376 >>105592493 >>105593525 >>105594054 >>105595110 >>105595168 >>105595794 >>105596862 >>105597899 >>105600025 >>105600162
.
Anonymous No.105591354 [Report] >>105591843
>>105591346 (OP)
LMAO
Anonymous No.105591357 [Report] >>105591767 >>105597905
>>105591346 (OP)
>shipping software
>with go
kek
Anonymous No.105591360 [Report] >>105591843 >>105606599
Haskell sisters? Our response??
Anonymous No.105591366 [Report]
You are joking, but Go is actually just so good for shipping software
Anonymous No.105591376 [Report] >>105591843
FP saars have been real quiet ever since this dropped ...
Anonymous No.105591416 [Report] >>105591450
>>105591346 (OP)
why is Haskell a worm?
Anonymous No.105591450 [Report]
>>105591416
Because FP is used by worms
Anonymous No.105591468 [Report] >>105591485 >>105595186
>>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.
Anonymous No.105591485 [Report]
>>105591468
>I hate that stupid fucking gopher so goddamn much. No other mascot makes me so irrationally angry
Based. Stay mad
Anonymous No.105591656 [Report] >>105591843
>>105591346 (OP)
my fellow gochads we won so hard with this
Anonymous No.105591767 [Report]
>>105591357
It's technically the most servers running code after C
Thanks, docker
Anonymous No.105591811 [Report]
>>105591346 (OP)
OCaml does both.
Anonymous No.105591843 [Report]
>>105591346 (OP)
>>105591354
>>105591360
>>105591376
>>105591656
samefag
Anonymous No.105592018 [Report] >>105592058 >>105592097 >>105592104 >>105595807 >>105608219
this causes the gopher to go into an uncontrollable rage
Anonymous No.105592058 [Report] >>105592080 >>105592222 >>105592403
>>105592018
for i := 1; i < 10; i += 2 {
fmt.Println(i)
}
Anonymous No.105592080 [Report]
>>105592058
Ewww
Anonymous No.105592097 [Report]
>>105592018
Why does 0..1 = a step size of 2?
Anonymous No.105592104 [Report] >>105592131
>>105592018
Wait, why does it not print 0? min...max is not inclusive of min? What kind of garbage is that?
Anonymous No.105592131 [Report] >>105592149 >>105592161 >>105592480 >>105608219
>>105592104
Even fucking rust does better than this shit.
Anonymous No.105592143 [Report]
>>105591346 (OP)
Subhuman AI pajeet
Anonymous No.105592149 [Report] >>105592153 >>105592179
>>105592131
It's my own function nigga not the std calm down
Anonymous No.105592153 [Report] >>105592225
>>105592149
Why did you make min non-inclusive you subhuman
Anonymous No.105592161 [Report] >>105592179
>>105592131
That virtual text looks distracting
Anonymous No.105592179 [Report]
>>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.
Anonymous No.105592222 [Report]
>>105592058
Based looper
Anonymous No.105592225 [Report] >>105592233
>>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?
Anonymous No.105592233 [Report] >>105592266
>>105592225
It should be 0, 2, 4, 6, 8
fucking retard
Anonymous No.105592266 [Report] >>105592273
>>105592233
should be 1, 3, 5, 7, 9. since you are stepping by 2 you need to skip the first element which is 0.
Anonymous No.105592273 [Report] >>105592317
>>105592266
>since you are stepping by 2 you need to skip the first element
what!
Anonymous No.105592280 [Report] >>105592318 >>105592328 >>105592339
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?
Anonymous No.105592317 [Report]
>>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
Anonymous No.105592318 [Report]
>>105592280
>I only use C, Go, and Hare
Holy based
Anonymous No.105592328 [Report]
>>105592280
>I only use C, Go, and Hare
Wow, an actual white man on /g/ ...
Anonymous No.105592339 [Report] >>105592371 >>105592431
>>105592280
QRD on Hare?
Anonymous No.105592365 [Report]
>>105591346 (OP)
What if I want to ship type theory and masturbate to software?
Anonymous No.105592371 [Report] >>105592381
>>105592339
Anonymous No.105592376 [Report]
>>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.
Anonymous No.105592381 [Report] >>105592388
>>105592371
>vibrant community
Dropped
Anonymous No.105592388 [Report] >>105592407 >>105592421
>>105592381
Anonymous No.105592403 [Report] >>105592486 >>105593191 >>105593452 >>105604162
>>105592058
Ok, now do a group by
Anonymous No.105592407 [Report] >>105592416
>>105592388
The person on the right is a jew and he works for microsoft. Retard
Anonymous No.105592416 [Report] >>105592439
>>105592407
>muh kikes
go back to pol
Anonymous No.105592421 [Report]
>>105592388
she CUTE
Anonymous No.105592431 [Report]
>>105592339
Small, concise, sane, rigorous, maintained by white men.
Website: troon free
Mascot: cute af

Let me guess.. you need more..
Anonymous No.105592439 [Report]
>>105592416
Hare is the white man's language, shalomovich
Anonymous No.105592449 [Report] >>105592510
nice language LMAO
Anonymous No.105592480 [Report] >>105592492 >>105595277 >>105598077 >>105598087
>>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
Anonymous No.105592486 [Report]
>>105592403
you mean like a basic struct
Anonymous No.105592492 [Report] >>105592505
>>105592480
>0.17s = 17s
smartest cnile
Anonymous No.105592493 [Report] >>105593525
>>105591346 (OP)
Anonymous No.105592505 [Report]
>>105592492
why would you count the leading zeroes?
Anonymous No.105592510 [Report] >>105592533 >>105594953 >>105594957 >>105595189 >>105595836
>>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
Anonymous No.105592533 [Report] >>105592540 >>105592569
>>105592510
I think you mean C Go and Hare.
By white men, for white men.
Anonymous No.105592540 [Report]
>>105592533
Anonymous No.105592569 [Report] >>105592620
>>105592533
It's a sexy combination to be sure. But what if I need something more application specific?
Anonymous No.105592620 [Report]
>>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.
Anonymous No.105593191 [Report] >>105593247
>>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;
Anonymous No.105593247 [Report]
>>105593191
yikes forever
Anonymous No.105593446 [Report] >>105593452
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
Anonymous No.105593452 [Report]
>>105593446
meant for >>105592403
Anonymous No.105593525 [Report] >>105597037 >>105599872 >>105599935 >>105603596
>>105591346 (OP)
>>105592493
follow the author for more original content like this
https://x.com/kai_fall
Anonymous No.105594054 [Report] >>105594156
>>105591346 (OP)
OCaml fits perfectly between these opposites
Anonymous No.105594156 [Report] >>105594418
>>105594054
But Ocaml is sloowwww
Anonymous No.105594418 [Report] >>105594577 >>105595032
>>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".
Anonymous No.105594577 [Report] >>105594982
>>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.
Anonymous No.105594953 [Report] >>105595149
>>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.
Anonymous No.105594957 [Report] >>105595015
>>105592510
rust and go are non-mainstream languages thoughbeit
Anonymous No.105594982 [Report] >>105595259
>>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.
Anonymous No.105595015 [Report] >>105595040
>>105594957
>He is still stuck in 2015
Anonymous No.105595032 [Report] >>105595516
>>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.
Anonymous No.105595040 [Report] >>105595096
>>105595015
Cope and seethe tranny. Look it up yourself and cry yourself to sleep
Anonymous No.105595096 [Report]
>>105595040
>THIS mad
Anonymous No.105595110 [Report] >>105595125 >>105595132 >>105595227 >>105596337
>>105591346 (OP)
Anonymous No.105595125 [Report]
>>105595110
based
Anonymous No.105595132 [Report] >>105595516
>>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.
Anonymous No.105595149 [Report] >>105595237
>>105594953
>source: my ass
Anonymous No.105595150 [Report] >>105595271 >>105595306
Rust's approach to handling mutability is perfect.
Anonymous No.105595168 [Report]
>>105591346 (OP)
Kek
Real
Anonymous No.105595186 [Report]
>>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
Anonymous No.105595189 [Report]
>>105592510
>the only languages you should even consider: C C++ C# Java python js, go, rust
cries in Perl
Anonymous No.105595227 [Report]
>>105595110
Make her wear a fundoshi.
Anonymous No.105595237 [Report] >>105595357
>>105595149
>>the sky is blue
>>source: my ass
Well done reddit
Anonymous No.105595259 [Report] >>105598561
>>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.
Anonymous No.105595271 [Report]
>>105595150
lol
Anonymous No.105595277 [Report]
>>105592480
>redbox
Forgot those things existed
I remember picking out movies from those when I went to the store with my mom
Anonymous No.105595306 [Report]
>>105595150
Immutability is gaaayyyyyyyyyy
Anonymous No.105595343 [Report] >>105595374
Go is procedural shit, reminds me of Java 1.6
literally unusable
Anonymous No.105595357 [Report] >>105595375 >>105595941 >>105598110 >>105598566
>>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.
Anonymous No.105595374 [Report] >>105595382 >>105595387 >>105595763 >>105599399
>>105595343
Show us all the software made in non procedural languages.
Anonymous No.105595375 [Report] >>105595381 >>105595692
>>105595357
Emac
Anonymous No.105595381 [Report] >>105595516
>>105595375
Emacs
>Commonly used
>No viable alternatives
LOL
Anonymous No.105595382 [Report]
>>105595374
GuptaSQL Windows is written in VB, which is a mix of functional and OOP
Anonymous No.105595387 [Report] >>105595397 >>105598571
>>105595374
I will start with all the gaming industry
Anonymous No.105595397 [Report]
>>105595387
>C++
>Not procedural
Nice bait.
Anonymous No.105595516 [Report] >>105595782 >>105598574
>>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.
Anonymous No.105595692 [Report] >>105595941 >>105598578
>>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.
Anonymous No.105595763 [Report]
>>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
Anonymous No.105595782 [Report]
>>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)
Anonymous No.105595794 [Report]
>>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.
Anonymous No.105595807 [Report]
>>105592018
>Not using Lisp for this
Peasant.
Anonymous No.105595836 [Report] >>105598586
>>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.
Anonymous No.105595941 [Report] >>105596183 >>105596754 >>105596758
>>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.
Anonymous No.105596183 [Report] >>105596946
>>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.
Anonymous No.105596337 [Report]
>>105595110
lazy neet
Anonymous No.105596754 [Report] >>105597768
>>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.
Anonymous No.105596758 [Report] >>105598594 >>105600581
>>105595941
>Not many 60 year old languages can still be considered as useful today.
C?
53 years old.
Anonymous No.105596862 [Report]
>>105591346 (OP)
Literally kill yourself.
Anonymous No.105596946 [Report] >>105597764 >>105598609 >>105598618
>>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).
Anonymous No.105597037 [Report]
>>105593525
He's fucking based, kek
Anonymous No.105597764 [Report]
>>105596946
Clojure is great precisely because maps of sequences DSL fits 90% of programming tasks.
Anonymous No.105597768 [Report]
>>105596754
no such program in any language
Anonymous No.105597792 [Report] >>105597863
I like how this neo cnile thread turned into lisp-bashing
worse is better still going strong
Anonymous No.105597863 [Report] >>105598140
>>105597792
Lisp was the original worse is better. Garbage collection, dynamic typing, pattern matching etc etc. Asm is all that's sneeded.
Anonymous No.105597899 [Report] >>105598182
>>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.
Anonymous No.105597905 [Report]
>>105591357
NEET detected kek
Anonymous No.105598077 [Report]
>>105592480
Rustards aren't even done extending the language. They're just getting started.
Wait until TATA Consulting Services gets a hold of it.
Anonymous No.105598087 [Report]
>>105592480
>17s
cnile reading comprehension lower than a monkey
Anonymous No.105598110 [Report] >>105599134
>>105595357
Checkpoint FW-1 rules
Autocad (Autolisp)
Anonymous No.105598140 [Report]
>>105597863
>Asm is all that's sneeded.
Lisp practically was ASM...
CAR - Contents of Address Register
CDR - Contents of Decrement Register
Anonymous No.105598182 [Report] >>105598314 >>105598596 >>105599551
>>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.
Anonymous No.105598314 [Report]
>>105598182
>Generics
You don't need those
Anonymous No.105598561 [Report]
>>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.
Anonymous No.105598566 [Report]
>>105595357
did you even read the post before getting mad at ghosts?
You're literally proving my point
Anonymous No.105598571 [Report] >>105599399
>>105595387
jak and daxter was fully lisp
Anonymous No.105598574 [Report] >>105599068
>>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.
Anonymous No.105598578 [Report]
>>105595692
Then that defeats the argument about using languages because of maturity and tooling don't it cletus
Anonymous No.105598586 [Report]
>>105595836
Forth is so powerful it doesn't need macros and is still more powerful than lisp.
Anonymous No.105598594 [Report]
>>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
Anonymous No.105598596 [Report]
>>105598182
> battered wife syndrome from dynamic typing
There is a lot if us.
Anonymous No.105598609 [Report]
>>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.
Anonymous No.105598618 [Report] >>105598702 >>105600672
>>105596946
neither clojure nor racket are lisps
Anonymous No.105598702 [Report] >>105598785
>>105598618
stfu conscel
clojure perfected lisp
Anonymous No.105598785 [Report] >>105600672
>>105598702
the opposite. it nuked all the advantages of lisp while keeping the worst parts.
Anonymous No.105599068 [Report] >>105599073
>>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?).
Anonymous No.105599073 [Report]
>>105599068
pearls before swine.
Anonymous No.105599134 [Report]
>>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.
Anonymous No.105599399 [Report] >>105600706
>>105595374
>>105598571
this was a dumb question, Lisp is also procedural sometimes
the point is, Go is procedural-only
Anonymous No.105599551 [Report]
>>105598182
Generics were a mistake.
Anonymous No.105599872 [Report]
>>105593525
lmao
Anonymous No.105599935 [Report]
>>105593525
this moron is ITT, isn't he?
Anonymous No.105600025 [Report] >>105600435
>>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.
Anonymous No.105600162 [Report] >>105600550
>>105591346 (OP)
>we have reached the point where 4chan discourse is downstream from twitter
It's over. Cultural defeat.
Anonymous No.105600435 [Report]
>>105600025
what in the absolute fuck are you shitposting about. That's almost the exact opposite of the truth.
Anonymous No.105600550 [Report]
>>105600162
Has been like that since 2013. Other boards succumbed even earlier, like 2007.
Anonymous No.105600581 [Report]
>>105596758
As I said, not many. There's only C and Lisp. That's pretty much it, and C only survived because of Unix.
Anonymous No.105600672 [Report] >>105601025
>>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.
Anonymous No.105600706 [Report] >>105600809 >>105600853
>>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.
Anonymous No.105600809 [Report]
>>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.
Anonymous No.105600853 [Report] >>105600861
>>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.
Anonymous No.105600861 [Report]
>>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.
Anonymous No.105600889 [Report] >>105600971 >>105603351
Anonymous No.105600971 [Report] >>105600984 >>105601215 >>105605499
>>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++.
Anonymous No.105600984 [Report] >>105601066
>>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...
Anonymous No.105601025 [Report] >>105601112
>>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.
Anonymous No.105601066 [Report]
>>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.
Anonymous No.105601112 [Report] >>105601384
>>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
Anonymous No.105601215 [Report] >>105601391
>>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).
Anonymous No.105601384 [Report]
>>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.
Anonymous No.105601391 [Report] >>105601474
>>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.
Anonymous No.105601474 [Report]
>>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.
Anonymous No.105603351 [Report]
>>105600889
The gopher doesn't actually want to be there, unfortunately his left arm is fused with the chair.
Anonymous No.105603596 [Report] >>105603645 >>105604357 >>105604370 >>105604818 >>105604861
>>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.
Anonymous No.105603645 [Report] >>105603904
>>105603596
>nobody cares
>erlang/elixir
>matlab (???)
>powershell
>swift
based larping retard
Anonymous No.105603904 [Report]
>>105603645
Nobody cares about matlab in 2025 and hasn’t for years when R exists. Nobody cares about powershell outside of windows shops.
Anonymous No.105604162 [Report] >>105604368
>>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?
Anonymous No.105604357 [Report]
>>105603596
Back in my days, trolling meant something.
Anonymous No.105604368 [Report]
>>105604162
Maybe the data is not tabular and you wouldn't want to build 999 tables with a bazillion consistency clauses to model it.
Anonymous No.105604370 [Report] >>105604540
>>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.
Anonymous No.105604540 [Report] >>105604666
>>105604370
ada uses a gc
Anonymous No.105604666 [Report] >>105607975
>>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.
Anonymous No.105604818 [Report] >>105604852 >>105604965 >>105604970
>>105603596
OCaml is very close to Haskell, get your shit together poser
Anonymous No.105604852 [Report]
>>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"
Anonymous No.105604861 [Report]
>>105603596
It's a crime Odin isn't used more and that Zig and Rust won out of the Nulangs.
Anonymous No.105604965 [Report]
>>105604818
Maybe in retard land
Anonymous No.105604970 [Report]
>>105604818
Ocaml has a camel. Where is Haskell's?
Anonymous No.105605499 [Report] >>105605592
>>105600971
>>Having to deal with explicit lifetimes
just call to_owned(). in GC'd languages you were constantly paying the cost of cloning anyway
Anonymous No.105605592 [Report] >>105606284
>>105605499
>Rust: A systems language as slow as a GC'd language
Magnificent!
Anonymous No.105606284 [Report] >>105607983
>>105605592
You'll never get through to them. Rustfags still think reference counting isn't garbage collection.
Anonymous No.105606599 [Report] >>105606809
>>105591360
Most shipped software is crap. Ours isn't.
Anonymous No.105606809 [Report] >>105607250
>>105606599
Proof?
Anonymous No.105607250 [Report]
>>105606809
I have a Bluetooth anal buttplug powered by haskell and rust
Anonymous No.105607975 [Report] >>105608125
>>105604666
the literal opposite
Anonymous No.105607983 [Report] >>105608041
>>105606284
Because it isn't. GC is much better than RC in many cases.
Anonymous No.105608041 [Report]
>>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.
Anonymous No.105608125 [Report]
>>105607975
No. The implementation everyone uses, GNAT, doesn't even have a garbage collector. Most implementations don't.
Anonymous No.105608219 [Report]
>>105592131
>>105592018
ugly af languages