subreddit stringclasses 7
values | author stringlengths 3 20 | id stringlengths 5 7 | content stringlengths 67 30.4k | score int64 0 140k |
|---|---|---|---|---|
programmingcirclejerk | brogus_amogus | j8ikxx9 | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>jerk where<|eor|><|sor|>Yeah, no one has responded with "linked lists are worthless because ~~Rust is bad at them~~ something something cache," so I can't jerk to this at all.<|eor|><|sor|>linked lists are an overrated data structure that somehow has become a prime target of computer science curriculums, not only are linked lists bad for caching but they're also terribly inefficient, by using huge numbers of indirection it hurts locality and is O(n).
vectors should be used for 99% of the time as it's as efficient as a simple array having O(1), being great for caching and having a much simpler implementation with barely any pointer-foo involved.<|eor|><|sor|>They're a good way to introduce students to pointers though, and I distinctly remember my professor saying you probably won't ever need a real linked list in practice<|eor|><|eols|><|endoftext|> | 37 |
programmingcirclejerk | anon25783 | j8j80d8 | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>[deleted]<|eor|><|sor|>[There is actually a real-world use of linked lists and it might be the jerkingest thing you'll read all day](https://stackoverflow.com/q/13865420/10942736)<|eor|><|eols|><|endoftext|> | 30 |
programmingcirclejerk | Orbidorpdorp | j8imbay | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>jerk where<|eor|><|sor|>Yeah, no one has responded with "linked lists are worthless because ~~Rust is bad at them~~ something something cache," so I can't jerk to this at all.<|eor|><|sor|>linked lists are an overrated data structure that somehow has become a prime target of computer science curriculums, not only are linked lists bad for caching but they're also terribly inefficient, by using huge numbers of indirection it hurts locality and is O(n).
vectors should be used for 99% of the time as it's as efficient as a simple array having O(1), being great for caching and having a much simpler implementation with barely any pointer-foo involved.<|eor|><|sor|>They're a good way to introduce students to pointers though, and I distinctly remember my professor saying you probably won't ever need a real linked list in practice<|eor|><|sor|>Also a plain linked list is probably not commonly used (outside of weird lisp purist contexts), but the next lesson where you build on it to make doubly linked lists, trees, etc. teaches you how build data structures that do have practical applications.
Skipping over a simple linked list would honestly be kind of tricky because it is conceptually foundational.<|eor|><|eols|><|endoftext|> | 28 |
programmingcirclejerk | aikii | j8ik7ek | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>Just restart the process. Can I have my PhD now.<|eor|><|sor|>[As a micro services expert, I know the fix for that: did you try sticking it into a systemd daemon that restarts it automatically when it crashes?](https://www.reddit.com/r/programmingcirclejerk/comments/zqltsy/as_a_micro_services_expert_i_know_the_fix_for/)<|eor|><|sor|>See, cloud native solutions are mostly about exposing an API to the on/off switch in a reboot-oriented architecture<|eor|><|eols|><|endoftext|> | 22 |
programmingcirclejerk | 1LargeAdult | j8k44hb | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>Oh, yeah I had a friend who got a PhD on linked lists. His dissertation was on how to reverse them.<|eor|><|sor|>Still has to endure 72hrs of whiteboard interviews for a junior gig at faang<|eor|><|eols|><|endoftext|> | 16 |
programmingcirclejerk | kebaabe | j8hybck | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>jerk where<|eor|><|eols|><|endoftext|> | 12 |
programmingcirclejerk | KaranasToll | j8imsoh | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>Just restart the process. Can I have my PhD now.<|eor|><|sor|>[As a micro services expert, I know the fix for that: did you try sticking it into a systemd daemon that restarts it automatically when it crashes?](https://www.reddit.com/r/programmingcirclejerk/comments/zqltsy/as_a_micro_services_expert_i_know_the_fix_for/)<|eor|><|sor|>Systemd? I assume you mean kubernetes.<|eor|><|eols|><|endoftext|> | 12 |
programmingcirclejerk | chuch1234 | j8lal79 | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>I'm sorry, I don't understand the use case for a linked list, especially when most modern languages offer a `List` type or something to that effect that does the same thing. Clearly a `List` is a thing that just exists with no underlying implementation, so why would anyone need to make one themselves?<|eor|><|sor|>[deleted]<|eor|><|sor|>Jerkable material in the comments?<|eor|><|sor|>Aww, you scared it away!<|eor|><|eols|><|endoftext|> | 12 |
programmingcirclejerk | OctagonClock | j8isw2g | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>jerk where<|eor|><|sor|>Yeah, no one has responded with "linked lists are worthless because ~~Rust is bad at them~~ something something cache," so I can't jerk to this at all.<|eor|><|sor|>linked lists are an overrated data structure that somehow has become a prime target of computer science curriculums, not only are linked lists bad for caching but they're also terribly inefficient, by using huge numbers of indirection it hurts locality and is O(n).
vectors should be used for 99% of the time as it's as efficient as a simple array having O(1), being great for caching and having a much simpler implementation with barely any pointer-foo involved.<|eor|><|sor|>lol no concurrency
lol no infinite deques<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | sammymammy2 | j8kd4zv | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>jerk where<|eor|><|sor|>Yeah, no one has responded with "linked lists are worthless because ~~Rust is bad at them~~ something something cache," so I can't jerk to this at all.<|eor|><|sor|>linked lists are an overrated data structure that somehow has become a prime target of computer science curriculums, not only are linked lists bad for caching but they're also terribly inefficient, by using huge numbers of indirection it hurts locality and is O(n).
vectors should be used for 99% of the time as it's as efficient as a simple array having O(1), being great for caching and having a much simpler implementation with barely any pointer-foo involved.<|eor|><|sor|>They're a good way to introduce students to pointers though, and I distinctly remember my professor saying you probably won't ever need a real linked list in practice<|eor|><|sor|>Also a plain linked list is probably not commonly used (outside of weird lisp purist contexts), but the next lesson where you build on it to make doubly linked lists, trees, etc. teaches you how build data structures that do have practical applications.
Skipping over a simple linked list would honestly be kind of tricky because it is conceptually foundational.<|eor|><|sor|>You get intrusive linked lists all of the time in C and C++. But also, yes. I think learning recursion from linked lists and peano nats are great, because it exposes structural recursion.<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | ikatono | j8k8w6p | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>I'm sorry, I don't understand the use case for a linked list, especially when most modern languages offer a `List` type or something to that effect that does the same thing. Clearly a `List` is a thing that just exists with no underlying implementation, so why would anyone need to make one themselves?<|eor|><|sor|>[deleted]<|eor|><|sor|>Jerkable material in the comments?<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | Infernio | j8jaste | <|sols|><|sot|>Linked lists are complicated. You can get something that compiles easily with C++, but to be sure it doesn't leak memory might require you to get that PhD after all.<|eot|><|sol|>https://news.ycombinator.com/item?id=34788322<|eol|><|sor|>jerk where<|eor|><|sor|>Yeah, no one has responded with "linked lists are worthless because ~~Rust is bad at them~~ something something cache," so I can't jerk to this at all.<|eor|><|sor|>linked lists are an overrated data structure that somehow has become a prime target of computer science curriculums, not only are linked lists bad for caching but they're also terribly inefficient, by using huge numbers of indirection it hurts locality and is O(n).
vectors should be used for 99% of the time as it's as efficient as a simple array having O(1), being great for caching and having a much simpler implementation with barely any pointer-foo involved.<|eor|><|sor|>2/10, it's got the cache stuff but I'm missing the blatant Rust shilling.<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | Rocketsx12 | xz1sq2 | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|eols|><|endoftext|> | 141 |
programmingcirclejerk | Volt | irkc983 | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>> Programming is not about having fun.
Holy based<|eor|><|eols|><|endoftext|> | 104 |
programmingcirclejerk | mach_kernel | irl34gw | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>> Programming is not about having fun.
Holy based<|eor|><|sor|>Its about making sure nobody has fun<|eor|><|eols|><|endoftext|> | 43 |
programmingcirclejerk | CarolineLovesArt | irkit84 | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>If all you have is a moral hammer<|eor|><|eols|><|endoftext|> | 31 |
programmingcirclejerk | xbmarx | irleu3c | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>Why do other programming languages keep existing? Rust already exists.<|eor|><|eols|><|endoftext|> | 27 |
programmingcirclejerk | icebarf | irl1r5j | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>> wagie wagie get in the cagie
the jerk is with this one<|eor|><|eols|><|endoftext|> | 25 |
programmingcirclejerk | small_kimono | irjyz7l | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>Where's the jerk?
/uj
This is kinda a jerk, in context? The poster's follow up comment is a Jerk Supreme with pickles.<|eor|><|eols|><|endoftext|> | 15 |
programmingcirclejerk | anon25783 | irmx1cm | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>when will we design chips that directly execute Rust source code without having to compile it to unsafe, immoral "machine code" first? I want blazingly fast zero-cost abstractions right down to the bare metal.<|eor|><|eols|><|endoftext|> | 12 |
programmingcirclejerk | cheater00 | irki4pc | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>The quote's not too hard to agree with<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | m50d | irlc1gx | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>Lol no HKT.<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | CarolineLovesArt | irobwrh | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>> When you want to have fun, use C.
>
> When you want to despise your life, hate everything, use rust
What did the borrow checker say to hurt you so bad?<|eor|><|eols|><|endoftext|> | 8 |
programmingcirclejerk | E-Aeolian | irnydyf | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>sorry, Rust is obsolete, replaced by the Lisp masterrace<|eor|><|eols|><|endoftext|> | 7 |
programmingcirclejerk | SelfDistinction | irlsi8n | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>> I'd rather just use C++ when performance matters. The new features make it easy to write safe code, and it has a far better ecosystem and library support.
In a strange turn of events I do _not_ want whatever this guy is having.
(Also obligatory lol no orthogonal metaclasses support.)<|eor|><|eols|><|endoftext|> | 6 |
programmingcirclejerk | Languorous-Owl | irlbtjr | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>Life is too short not to code in Rust.<|eor|><|eols|><|endoftext|> | 5 |
programmingcirclejerk | Karyo_Ten | irlbjtp | <|sols|><|sot|>when performance matters, use rust. when performance doesn't matter, also use rust, cause why would you not.<|eot|><|sol|>https://www.reddit.com/r/programming/comments/xywxda/-/irjdcwe<|eol|><|sor|>> Programming is not about having fun.
Holy based<|eor|><|sor|>Its about making sure nobody has fun<|eor|><|sor|>That's called PEBKAC<|eor|><|eols|><|endoftext|> | 5 |
programmingcirclejerk | ComfortablyBalanced | x7pink | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|eols|><|endoftext|> | 141 |
programmingcirclejerk | pareidolist | indtz5b | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>I love when fundamental properties of a language like `0 == 0.0` are implementation-specific<|eor|><|eols|><|endoftext|> | 135 |
programmingcirclejerk | eric987235 | inen6r7 | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Is google still trying to make Dart be a thing?<|eor|><|eols|><|endoftext|> | 64 |
programmingcirclejerk | Pheasn | inf3n13 | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Is google still trying to make Dart be a thing?<|eor|><|sor|>Yeah, and quite successfully, as the basis of the Flutter framework. I developed some mobile apps with that at work and it's actually pretty great. The language has some neat features that seem specifically geared towards making Flutter nice to work with.
The Javascript stuff is only relevant if you use Flutter Web, and I don't believe a lot of people use that. Flutter Desktop ist pretty good too, though.
I also dicked around with Dart for some small personal projects. It's quite nice as a language, but unfortunately, it has generics.<|eor|><|eols|><|endoftext|> | 53 |
programmingcirclejerk | sfhtsxgtsvg | ineypo3 | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>compilation-target-based type system<|eor|><|eols|><|endoftext|> | 51 |
programmingcirclejerk | F54280 | inf7cji | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Is google still trying to make Dart be a thing?<|eor|><|sor|>Yeah, and quite successfully, as the basis of the Flutter framework. I developed some mobile apps with that at work and it's actually pretty great. The language has some neat features that seem specifically geared towards making Flutter nice to work with.
The Javascript stuff is only relevant if you use Flutter Web, and I don't believe a lot of people use that. Flutter Desktop ist pretty good too, though.
I also dicked around with Dart for some small personal projects. It's quite nice as a language, but unfortunately, it has generics.<|eor|><|sor|>No jerk. Disgusting. ``sed -e /flutter/slutter/`` to make this half appropriate for this sub.<|eor|><|eols|><|endoftext|> | 43 |
programmingcirclejerk | irqlnotdispatchlevel | inf17mj | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>This reminds me of C's integer. Truly a bare metal language.<|eor|><|eols|><|endoftext|> | 42 |
programmingcirclejerk | HorstKugel | infjy7p | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>I love when fundamental properties of a language like `0 == 0.0` are implementation-specific<|eor|><|sor|>i genuinely don't understand why they need an "implementation" at all and not just resolve this at compile time.
Either way, there are switches for all the other platforms (MacOs, Windows, Android, Fuchsia....) but they are inside the IO package, which is not available on the web.
So you have to do a conditional import of the IO package and then mush kIsWeb together with the other constants, if you want to know on which platform your on lol<|eor|><|eols|><|endoftext|> | 32 |
programmingcirclejerk | chayleaf | inf6kmx | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>compilation-target-based type system<|eor|><|sor|>ftfy: based type system<|eor|><|eols|><|endoftext|> | 30 |
programmingcirclejerk | TheGhostOfInky | infjokm | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Does an electron app count as on the web is the question.
I like the hack though. Reminds me of the nextjs check for typeof(window)===undefined to know if your code is running on client or server<|eor|><|sor|>Running flutter inside electron has to be the most brain hurting thing I've imagined today.<|eor|><|eols|><|endoftext|> | 29 |
programmingcirclejerk | pareidolist | ingm5en | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>I love when fundamental properties of a language like `0 == 0.0` are implementation-specific<|eor|><|sor|>I believe other languages handle it by promoting the int to a double right? Same goes for 3 == 3.0, 4.3 < 5, etc.<|eor|><|sor|>```
can't compare `{float}` with `{integer}`
the trait `std::cmp::PartialEq<{integer}>` is not implemented for `{float}`
```<|eor|><|sor|>I believe other languages used outside Mozilla handle it by promoting the int to a double right? Same goes for 3 == 3.0, 4.3 < 5, etc.<|eor|><|sor|>```
* Couldn't match expected type `Integer' with actual type `Double'
* In the second argument of `(==)', namely `(0.0 :: Double)'
In the expression: (0 :: Integer) == (0.0 :: Double)
```
I wouldn't know anything about languages that commit such sins as implicit casting.<|eor|><|eols|><|endoftext|> | 28 |
programmingcirclejerk | MrCreeper1008 | inff7iq | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Is google still trying to make Dart be a thing?<|eor|><|sor|>Yeah, and quite successfully, as the basis of the Flutter framework. I developed some mobile apps with that at work and it's actually pretty great. The language has some neat features that seem specifically geared towards making Flutter nice to work with.
The Javascript stuff is only relevant if you use Flutter Web, and I don't believe a lot of people use that. Flutter Desktop ist pretty good too, though.
I also dicked around with Dart for some small personal projects. It's quite nice as a language, but unfortunately, it has generics.<|eor|><|sor|>No jerk. Disgusting. ``sed -e /flutter/slutter/`` to make this half appropriate for this sub.<|eor|><|sor|>Did you read the last sentence?<|eor|><|sor|>I dont get paid to read, I get paid to write code and accept merge requests.<|eor|><|sor|>10x grindset, accept PRs without reading them<|eor|><|eols|><|endoftext|> | 26 |
programmingcirclejerk | MagmaticKobaian | ingl6p1 | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Clearly, if one wants granularity in expression evaluation, one should use `0 ========= 0.0`. Such strictness guarantees that it will maybe probably resolve to true half the time depending on the day of the week.<|eor|><|eols|><|endoftext|> | 25 |
programmingcirclejerk | pareidolist | ingdcgx | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>I love when fundamental properties of a language like `0 == 0.0` are implementation-specific<|eor|><|sor|>I believe other languages handle it by promoting the int to a double right? Same goes for 3 == 3.0, 4.3 < 5, etc.<|eor|><|sor|>```
can't compare `{float}` with `{integer}`
the trait `std::cmp::PartialEq<{integer}>` is not implemented for `{float}`
```<|eor|><|eols|><|endoftext|> | 24 |
programmingcirclejerk | Pheasn | inf8k2r | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Is google still trying to make Dart be a thing?<|eor|><|sor|>Yeah, and quite successfully, as the basis of the Flutter framework. I developed some mobile apps with that at work and it's actually pretty great. The language has some neat features that seem specifically geared towards making Flutter nice to work with.
The Javascript stuff is only relevant if you use Flutter Web, and I don't believe a lot of people use that. Flutter Desktop ist pretty good too, though.
I also dicked around with Dart for some small personal projects. It's quite nice as a language, but unfortunately, it has generics.<|eor|><|sor|>No jerk. Disgusting. ``sed -e /flutter/slutter/`` to make this half appropriate for this sub.<|eor|><|sor|>Did you read the last sentence?<|eor|><|eols|><|endoftext|> | 23 |
programmingcirclejerk | TheZipCreator | infazcl | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>This reminds me of C's integer. Truly a bare metal language.<|eor|><|sor|>this is why holy C is the better language<|eor|><|eols|><|endoftext|> | 20 |
programmingcirclejerk | zetaconvex | ing6xdp | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>A programming language that does not support integers. Imagine that. Fortunately you don't have to because there's JavaScript<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | F54280 | infqse4 | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Is google still trying to make Dart be a thing?<|eor|><|sor|>Yeah, and quite successfully, as the basis of the Flutter framework. I developed some mobile apps with that at work and it's actually pretty great. The language has some neat features that seem specifically geared towards making Flutter nice to work with.
The Javascript stuff is only relevant if you use Flutter Web, and I don't believe a lot of people use that. Flutter Desktop ist pretty good too, though.
I also dicked around with Dart for some small personal projects. It's quite nice as a language, but unfortunately, it has generics.<|eor|><|sor|>No jerk. Disgusting. ``sed -e /flutter/slutter/`` to make this half appropriate for this sub.<|eor|><|sor|>Did you read the last sentence?<|eor|><|sor|>8 sentences, one jerk. 12.5%. I want my jerks to be stronger than my glass of wine...<|eor|><|eols|><|endoftext|> | 17 |
programmingcirclejerk | ComfortablyBalanced | ingljdw | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Clearly, if one wants granularity in expression evaluation, one should use `0 ========= 0.0`. Such strictness guarantees that it will maybe probably resolve to true half the time depending on the day of the week.<|eor|><|soopr|>You should use ============ to CRC check errors caused by cosmic rays.<|eoopr|><|eols|><|endoftext|> | 16 |
programmingcirclejerk | etaionshrd | ingoho8 | <|sols|><|sot|>This implementation takes advantage of the fact that JavaScript does not support integers. In this environment, Dart's doubles and ints are backed by the same kind of object. Thus a double 0.0 is identical to an integer 0. This is not true for Dart code running in AOT or on the VM.<|eot|><|sol|>https://api.flutter.dev/flutter/foundation/kIsWeb-constant.html<|eol|><|sor|>Is google still trying to make Dart be a thing?<|eor|><|sor|>Yeah, and quite successfully, as the basis of the Flutter framework. I developed some mobile apps with that at work and it's actually pretty great. The language has some neat features that seem specifically geared towards making Flutter nice to work with.
The Javascript stuff is only relevant if you use Flutter Web, and I don't believe a lot of people use that. Flutter Desktop ist pretty good too, though.
I also dicked around with Dart for some small personal projects. It's quite nice as a language, but unfortunately, it has generics.<|eor|><|sor|>lol no accessibility<|eor|><|sor|>is that accurate? They made a big deal about it being accessible when they first hype trained it<|eor|><|sor|>/uj they made a big deal about it because the accessibility people called it inaccessible and awful and put a bit of effort into it but not nearly enough to actually fix anything<|eor|><|eols|><|endoftext|> | 15 |
programmingcirclejerk | moon-chilled | w7j0y9 | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|eols|><|endoftext|> | 142 |
programmingcirclejerk | tomwhoiscontrary | ihk99fd | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>Just run `cargo doc` on rustc and call it a day.
Quote of the day:
> it's just writing, what's so hard about that?<|eor|><|sor|>For the Rust community, the challenge is not getting the word count up, it's keeping the emoji count down.<|eor|><|eols|><|endoftext|> | 93 |
programmingcirclejerk | SickMoonDoe | ihjyb6i | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|eols|><|endoftext|> | 76 |
programmingcirclejerk | xmcqdpt2 | ihk56ym | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|sor|>it's a crab eat crab world.<|eor|><|eols|><|endoftext|> | 66 |
programmingcirclejerk | irqlnotdispatchlevel | ihk8ys1 | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>Just run `cargo doc` on rustc and call it a day.
Quote of the day:
> it's just writing, what's so hard about that?<|eor|><|eols|><|endoftext|> | 62 |
programmingcirclejerk | senj | ihm3n9u | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|sor|>> rustc refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time
If GCC can't write a Rust frontend without a standard they've apparently gotten a lot fuckin dumber than they used to be, 'cause they managed to write one for C 2 years before it had a standard and C++ 12 years before it had one.
There were *dozens* of C compilers by the time people starting writing a standard for it shit'd been out (and outdated lol) for 17 years. Same fucking story with Common Lisp being the joint effort of a bunch of divergent Lisps, same fucking story with C++.
Standards are the product of a bunch of different assholes coming together and negotiating on how to balance all their divergent crap only complete Ctards who are too young to even know how the standard came about think that a standard is something one group writes in a vaccuum, or that it comes before implementations and dictates *to* compilers. You want Algol 68? 'Cause that's how you fuckin' get Algol 68.
I'm jerkin' but also not jerkin'<|eor|><|eols|><|endoftext|> | 38 |
programmingcirclejerk | F54280 | ihkjndw | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>That's the law of the conservation of mutability: the more you control mutability in the language, the less you control it in the spec.<|eor|><|eols|><|endoftext|> | 37 |
programmingcirclejerk | zSync1 | ihmycfb | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>I don't understand half of the comments :(.
What spec, why would someone need it IRL?
What is GCC frontend?<|eor|><|sor|>I can't tell if you're serious or not, but this is a subreddit for taking the piss out of programming, with jargon out the wazoo.
To explain in brief - Rust is a relatively new programming language, which doesn't really have a formal specification yet. Said formal specification effectively defines the entire language and what it can do, which aids in development of alternate compilers (programs that take Rust code and turn it into executables that your OS/CPU will understand).
There are two mainstream compiler architectures, LLVM and GCC. Both have some tradeoffs, but Rust uses the former. In order to build code for the linux kernel, only GCC can be used reliably as of right now, and since Rust is a desirable language, a compiler that works on the GCC architecture has to be created. This kind of support for a language is called a frontend (as opposed to backend, which handles creating executable output).
This is, however, hampered by the fact that the language is slightly unstable and may have very subtle things added or removed where it is not clear what the intended behaviour is.
tl;dr: it's all fancy nonsense to make flashy lights blink.<|eor|><|eols|><|endoftext|> | 31 |
programmingcirclejerk | SickMoonDoe | ihmzw2l | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|sor|>> rustc refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time
If GCC can't write a Rust frontend without a standard they've apparently gotten a lot fuckin dumber than they used to be, 'cause they managed to write one for C 2 years before it had a standard and C++ 12 years before it had one.
There were *dozens* of C compilers by the time people starting writing a standard for it shit'd been out (and outdated lol) for 17 years. Same fucking story with Common Lisp being the joint effort of a bunch of divergent Lisps, same fucking story with C++.
Standards are the product of a bunch of different assholes coming together and negotiating on how to balance all their divergent crap only complete Ctards who are too young to even know how the standard came about think that a standard is something one group writes in a vaccuum, or that it comes before implementations and dictates *to* compilers. You want Algol 68? 'Cause that's how you fuckin' get Algol 68.
I'm jerkin' but also not jerkin'<|eor|><|sor|>The reference specs and pseudo standards for C weren't changing every other week.
The Rust compiler devs change their mind about core rules more often than they change clothes.<|eor|><|eols|><|endoftext|> | 31 |
programmingcirclejerk | ohforth | ihku0cc | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>Yeah! look what happened to lisp. They blew all their money on a spec and then the language died<|eor|><|eols|><|endoftext|> | 29 |
programmingcirclejerk | UnShame | ihkxuxn | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|sor|>it's a crab eat crab world.<|eor|><|sor|>You mean a crabby crab world.<|eor|><|eols|><|endoftext|> | 25 |
programmingcirclejerk | senj | ihluy8p | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>/uj ok say what you will but this man's guide got me through uni OS networking, I would follow him to hell<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | CocktailPerson | ihm912j | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|sor|>it's a crab eat crab world.<|eor|><|sor|>I mean crabs irl will happily eat each other<|eor|><|sor|>It's a world.<|eor|><|eols|><|endoftext|> | 18 |
programmingcirclejerk | feral_brick | ihls6bv | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|sor|>it's a crab eat crab world.<|eor|><|sor|>I mean crabs irl will happily eat each other<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | zSync1 | iho1aj3 | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>I don't understand half of the comments :(.
What spec, why would someone need it IRL?
What is GCC frontend?<|eor|><|sor|>I can't tell if you're serious or not, but this is a subreddit for taking the piss out of programming, with jargon out the wazoo.
To explain in brief - Rust is a relatively new programming language, which doesn't really have a formal specification yet. Said formal specification effectively defines the entire language and what it can do, which aids in development of alternate compilers (programs that take Rust code and turn it into executables that your OS/CPU will understand).
There are two mainstream compiler architectures, LLVM and GCC. Both have some tradeoffs, but Rust uses the former. In order to build code for the linux kernel, only GCC can be used reliably as of right now, and since Rust is a desirable language, a compiler that works on the GCC architecture has to be created. This kind of support for a language is called a frontend (as opposed to backend, which handles creating executable output).
This is, however, hampered by the fact that the language is slightly unstable and may have very subtle things added or removed where it is not clear what the intended behaviour is.
tl;dr: it's all fancy nonsense to make flashy lights blink.<|eor|><|sor|>/uj click through angeal98's posts and you'll see that they are absolutely 100% joking.<|eor|><|sor|>I see. Well, it was fun to write.<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | winepath | ihlw28c | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>They're nothing that GNUers love more than compiler dependent code. Think about it, they can't break the spec if there is no spec<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | angeal98 | ihmvsp0 | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>I don't understand half of the comments :(.
What spec, why would someone need it IRL?
What is GCC frontend?<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | senj | ihmwoqv | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|sor|>> rustc refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time
If GCC can't write a Rust frontend without a standard they've apparently gotten a lot fuckin dumber than they used to be, 'cause they managed to write one for C 2 years before it had a standard and C++ 12 years before it had one.
There were *dozens* of C compilers by the time people starting writing a standard for it shit'd been out (and outdated lol) for 17 years. Same fucking story with Common Lisp being the joint effort of a bunch of divergent Lisps, same fucking story with C++.
Standards are the product of a bunch of different assholes coming together and negotiating on how to balance all their divergent crap only complete Ctards who are too young to even know how the standard came about think that a standard is something one group writes in a vaccuum, or that it comes before implementations and dictates *to* compilers. You want Algol 68? 'Cause that's how you fuckin' get Algol 68.
I'm jerkin' but also not jerkin'<|eor|><|sor|>I dont think this is an official GNU project.<|eor|><|sor|>it is (https://gcc.gnu.org/pipermail/gcc/2022-July/239057.html) but so's gnu herd so maybe that just means it's extra doomed idk<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | feral_brick | ihne4b5 | <|sols|><|sot|>This is why we shouldn't adhere to a spec now: if the rustc compiler changes its implementation, the spec becomes outdated and will need to be updated.<|eot|><|sol|>https://www.reddit.com/r/rust/comments/vx7ng0/why_doesnt_the_rust_team_write_the_spec/ifv3o1r/<|eol|><|sor|>The GCC mailing list hates this man.
I swear over the last few weeks I've seen avid crustaceans turn on their own kind because `rustc` refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time.<|eor|><|sor|>> rustc refuses to spec and they are realizing blowing all this time on the GCC frontend was a giant waste of time
If GCC can't write a Rust frontend without a standard they've apparently gotten a lot fuckin dumber than they used to be, 'cause they managed to write one for C 2 years before it had a standard and C++ 12 years before it had one.
There were *dozens* of C compilers by the time people starting writing a standard for it shit'd been out (and outdated lol) for 17 years. Same fucking story with Common Lisp being the joint effort of a bunch of divergent Lisps, same fucking story with C++.
Standards are the product of a bunch of different assholes coming together and negotiating on how to balance all their divergent crap only complete Ctards who are too young to even know how the standard came about think that a standard is something one group writes in a vaccuum, or that it comes before implementations and dictates *to* compilers. You want Algol 68? 'Cause that's how you fuckin' get Algol 68.
I'm jerkin' but also not jerkin'<|eor|><|sor|>I dont think this is an official GNU project.<|eor|><|sor|>it is (https://gcc.gnu.org/pipermail/gcc/2022-July/239057.html) but so's gnu herd so maybe that just means it's extra doomed idk<|eor|><|sor|>Oh no (Oh yay(Oh no)), I agree, I dont know how to feel, neither C, C++, GCC or GNU are what they used to be, for better or for worse.<|eor|><|sor|>The spaghetti complexity of this project is O(no)<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | ProfessionalTheory8 | udtq25 | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|eols|><|endoftext|> | 141 |
programmingcirclejerk | Konju376 | i6j9rt5 | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>> Haskell is statistically typed
Ah yes, it just determines your variable types based on chance and, obviously, it's name.<|eor|><|eols|><|endoftext|> | 136 |
programmingcirclejerk | pareidolist | i6j9xd5 | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>> Haskell is statistically typed
Ah yes, it just determines your variable types based on chance and, obviously, it's name.<|eor|><|sor|>Stochastic typing<|eor|><|eols|><|endoftext|> | 61 |
programmingcirclejerk | Goheeca | i6iyu4l | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>Lisp 1 0 Haskal<|eor|><|eols|><|endoftext|> | 58 |
programmingcirclejerk | Konju376 | i6ja3p2 | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>> Haskell is statistically typed
Ah yes, it just determines your variable types based on chance and, obviously, it's name.<|eor|><|sor|>Stochastic typing<|eor|><|sor|>You just have to hit recompile until it stops producing errors<|eor|><|eols|><|endoftext|> | 44 |
programmingcirclejerk | loics2 | i6javs8 | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>
def comment(:unjerk), do: "Elixir is actually pretty cool to use"
def comment(:rejerk), do: "Python is my favorite functional programming language"<|eor|><|eols|><|endoftext|> | 43 |
programmingcirclejerk | fp_weenie | i6jb0bf | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>Lisp 1 0 Haskal<|eor|><|sor|>One of the big projects of Haskell is GHC lol
Also:
>Haskell is considered the mother of all functional programming languages.
https://preview.redd.it/mfk3iz4rbs451.jpg?width=640&crop=smart&auto=webp&s=9153ad94d53e03965c7b2fe386e30582f5863f44<|eor|><|sor|>> Haskell is considered the mother
Haskell is that girl.<|eor|><|eols|><|endoftext|> | 38 |
programmingcirclejerk | VariationDistinct330 | i6iz3gu | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>Lisp 1 0 Haskal<|eor|><|sor|>One of the big projects of Haskell is GHC lol
Also:
>Haskell is considered the mother of all functional programming languages.
https://preview.redd.it/mfk3iz4rbs451.jpg?width=640&crop=smart&auto=webp&s=9153ad94d53e03965c7b2fe386e30582f5863f44<|eor|><|eols|><|endoftext|> | 37 |
programmingcirclejerk | life-is-a-loop | i6jrkpz | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>> Advantages Of Functional Programming:
>
> Easy debugging
lmao<|eor|><|eols|><|endoftext|> | 35 |
programmingcirclejerk | muntaxitome | i6jvf9o | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>Calling Python a popular language is like calling influenza a popular disease. You can only say 'popular' about languages that people like. By definition this makes Elixir the most popular language in the world.<|eor|><|eols|><|endoftext|> | 28 |
programmingcirclejerk | VariationDistinct330 | i6iy8xh | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>>no exceptions for error handling,
Laughs in sml
> Python
> Kotlin
Oi wtf<|eor|><|eols|><|endoftext|> | 24 |
programmingcirclejerk | exploooooosions | i6jn7l6 | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>>no exceptions for error handling,
Laughs in sml
> Python
> Kotlin
Oi wtf<|eor|><|sor|>You can write functions in those. Isn't that what functional programming is?<|eor|><|eols|><|endoftext|> | 24 |
programmingcirclejerk | VariationDistinct330 | i6jdgzj | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>
def comment(:unjerk), do: "Elixir is actually pretty cool to use"
def comment(:rejerk), do: "Python is my favorite functional programming language"<|eor|><|sor|>Elixir: the movie/documentary is hot garbage compared to Erlang The Movie.
As such I cannot respect a successor which doesn't carry on the spirit of it's predecessor.
Call me when it has:
Hot number
Warm number
Short number
Diversion
Diversion on busy
Delayed diversion
911 Emergency
Black list incoming numbers
Transfer
Conference
Directed call pickup
Call waiting on busy
Call waiting on no answer
Intrusion
And then a cracking movie too
In the meantime I'll be doing Declarative Real Time Programming NOW<|eor|><|eols|><|endoftext|> | 23 |
programmingcirclejerk | Karyo_Ten | i6kxf2w | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>> Advantages Of Functional Programming:
>
> Easy debugging
lmao<|eor|><|sor|>If you write no code there is no bug.<|eor|><|eols|><|endoftext|> | 22 |
programmingcirclejerk | Konju376 | i6jrpjc | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>> Haskell is statistically typed
Ah yes, it just determines your variable types based on chance and, obviously, it's name.<|eor|><|sor|>It just has to guess that the type is `IO ()` and it will be right 90% of the time.<|eor|><|sor|>Noooo but my side-effect-safe programming<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | VariationDistinct330 | i6k277r | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>>no exceptions for error handling,
Laughs in sml
> Python
> Kotlin
Oi wtf<|eor|><|sor|>You can write functions in those. Isn't that what functional programming is?<|eor|><|sor|>Actually functions need not be functional. Functional is a synonym of brutally pragmatic.
As such, Go is the only true functional language.<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | BillyIII | i6j0tb9 | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>> cl
> python
> functional<|eor|><|eols|><|endoftext|> | 17 |
programmingcirclejerk | CocktailPerson | i6kkfz2 | <|sols|><|sot|>Elixir is the most popular programming language in the world.<|eot|><|sol|>https://www.spec-india.com/blog/functional-programming-languages<|eol|><|sor|>>no exceptions for error handling,
Laughs in sml
> Python
> Kotlin
Oi wtf<|eor|><|sor|>You can write functions in those. Isn't that what functional programming is?<|eor|><|sor|>Actually functions need not be functional. Functional is a synonym of brutally pragmatic.
As such, Go is the only true functional language.<|eor|><|sor|>I thought functional just means it works.<|eor|><|sor|>Haven't you heard? When programmers use a word, it usually means something entirely different.<|eor|><|eols|><|endoftext|> | 15 |
programmingcirclejerk | jeremyjh | qdhokb | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|eols|><|endoftext|> | 139 |
programmingcirclejerk | RustEvangelist10xer | hhmtm9n | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>To be fair, you have to have a very high IQ to use Git. The distribution model is extremely subtle, and without a solid grasp of Graph Theory, most of the branch workflow concepts will go over a typical brogrammer's head. There's also Linus's nihilistic outlook, which is deftly woven into the his implementation of the Plumbing commands - his personal philosophy draws heavily from the creator of Linux, for instance. The early users understand this stuff; they have the programming capacity to truly appreciate the depths of these features, to realize that they're not just efficient - they say something deep about Version Control. As a consequence, people who dislike Git truly ARE idiots - of course they wouldn't appreciate, for instance, the insight in Linus's existencial catchphrase "You should've been retroactively aborted," which itself is a cryptic reference to Git's own `git reset --hard`. I'm smirking right now just imagining one of these .5xer brogrammers scratching their heads in confusion as Torvald's genius unfolds itself on their terminals. What fools... how I pity them. And yes by the way, I DO have a clone of the early Git repo. And no, you cannot see it. It's for the early git users' eyes only - And even they have to demonstrate that they're within 5 GitHub user ID points of my own (preferably lower) beforehand.<|eor|><|eols|><|endoftext|> | 118 |
programmingcirclejerk | Teemperor | hhmqamw | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>I did start using programming circlejerk the weekend the mods ascended from hell, and my IQ is in the low 50s<|eor|><|eols|><|endoftext|> | 105 |
programmingcirclejerk | jeremyjh | hhmfmmq | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|soopr|>Also I use Arch, AMA!<|eoopr|><|eols|><|endoftext|> | 64 |
programmingcirclejerk | jeremyjh | hhmvtwz | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|soopr|>Also I use Arch, AMA!<|eoopr|><|sor|>How does it feel to be superior?<|eor|><|soopr|>I would tell you, but there isn't any chance you would understand.<|eoopr|><|eols|><|endoftext|> | 50 |
programmingcirclejerk | MrCreeper1008 | hhmn2xj | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|soopr|>Also I use Arch, AMA!<|eoopr|><|sor|>How does it feel to be superior?<|eor|><|eols|><|endoftext|> | 36 |
programmingcirclejerk | SirNuke | hhmn84b | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>Yeah, but how many digits is your Slashdot user ID?<|eor|><|eols|><|endoftext|> | 28 |
programmingcirclejerk | doomvox | hhnwd28 | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>To be fair, you have to have a very high IQ to use Git. The distribution model is extremely subtle, and without a solid grasp of Graph Theory, most of the branch workflow concepts will go over a typical brogrammer's head. There's also Linus's nihilistic outlook, which is deftly woven into the his implementation of the Plumbing commands - his personal philosophy draws heavily from the creator of Linux, for instance. The early users understand this stuff; they have the programming capacity to truly appreciate the depths of these features, to realize that they're not just efficient - they say something deep about Version Control. As a consequence, people who dislike Git truly ARE idiots - of course they wouldn't appreciate, for instance, the insight in Linus's existencial catchphrase "You should've been retroactively aborted," which itself is a cryptic reference to Git's own `git reset --hard`. I'm smirking right now just imagining one of these .5xer brogrammers scratching their heads in confusion as Torvald's genius unfolds itself on their terminals. What fools... how I pity them. And yes by the way, I DO have a clone of the early Git repo. And no, you cannot see it. It's for the early git users' eyes only - And even they have to demonstrate that they're within 5 GitHub user ID points of my own (preferably lower) beforehand.<|eor|><|sor|>I honestly dont know why I still laugh at this garbage.<|eor|><|sor|>That's because you're stupid, dad.<|eor|><|eols|><|endoftext|> | 27 |
programmingcirclejerk | MrCreeper1008 | hhnav3s | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|soopr|>Also I use Arch, AMA!<|eoopr|><|sor|>How does it feel to be superior?<|eor|><|soopr|>I would tell you, but there isn't any chance you would understand.<|eoopr|><|sor|>my .1xer ass using windws can relate<|eor|><|eols|><|endoftext|> | 20 |
programmingcirclejerk | Ohrenfreund | hhnrf48 | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>Your Github id is inversely proportional to your worth as a human being.<|eor|><|eols|><|endoftext|> | 17 |
programmingcirclejerk | BarefootUnicorn | hhmrara | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>Wow! This guy should win the Turing Award.<|eor|><|eols|><|endoftext|> | 15 |
programmingcirclejerk | GOPHERS_GONE_WILD | hhmu9ku | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>I hope we get a black market for GH ids just like how you can buy 4 or 5 digit Steam ids. The gamerfication of programming is unstoppable<|eor|><|eols|><|endoftext|> | 15 |
programmingcirclejerk | doomvox | hhnwv02 | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>To be fair, you have to have a very high IQ to use Git. The distribution model is extremely subtle, and without a solid grasp of Graph Theory, most of the branch workflow concepts will go over a typical brogrammer's head. There's also Linus's nihilistic outlook, which is deftly woven into the his implementation of the Plumbing commands - his personal philosophy draws heavily from the creator of Linux, for instance. The early users understand this stuff; they have the programming capacity to truly appreciate the depths of these features, to realize that they're not just efficient - they say something deep about Version Control. As a consequence, people who dislike Git truly ARE idiots - of course they wouldn't appreciate, for instance, the insight in Linus's existencial catchphrase "You should've been retroactively aborted," which itself is a cryptic reference to Git's own `git reset --hard`. I'm smirking right now just imagining one of these .5xer brogrammers scratching their heads in confusion as Torvald's genius unfolds itself on their terminals. What fools... how I pity them. And yes by the way, I DO have a clone of the early Git repo. And no, you cannot see it. It's for the early git users' eyes only - And even they have to demonstrate that they're within 5 GitHub user ID points of my own (preferably lower) beforehand.<|eor|><|sor|>My personal favorite is:
git reset --hard HEAD
If only it were so easy.<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | xmcqdpt2 | hhoi44k | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>low github ids as NFTs<|eor|><|eols|><|endoftext|> | 12 |
programmingcirclejerk | doomvox | hhnwhyo | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>Yeah, but how many digits is your Slashdot user ID?<|eor|><|sor|>Never trust anyone with a slash id less than 5 digits-- they probably bought it on ebay and will stoop to anything.<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | muntoo | hhpvm6c | <|sols|><|sot|>I did start using Git the weekend it came out, and my Github user ID is in the low 2000s<|eot|><|sol|>https://news.ycombinator.com/item?id=28956873<|eol|><|sor|>To be fair, you have to have a very high IQ to use Git. The distribution model is extremely subtle, and without a solid grasp of Graph Theory, most of the branch workflow concepts will go over a typical brogrammer's head. There's also Linus's nihilistic outlook, which is deftly woven into the his implementation of the Plumbing commands - his personal philosophy draws heavily from the creator of Linux, for instance. The early users understand this stuff; they have the programming capacity to truly appreciate the depths of these features, to realize that they're not just efficient - they say something deep about Version Control. As a consequence, people who dislike Git truly ARE idiots - of course they wouldn't appreciate, for instance, the insight in Linus's existencial catchphrase "You should've been retroactively aborted," which itself is a cryptic reference to Git's own `git reset --hard`. I'm smirking right now just imagining one of these .5xer brogrammers scratching their heads in confusion as Torvald's genius unfolds itself on their terminals. What fools... how I pity them. And yes by the way, I DO have a clone of the early Git repo. And no, you cannot see it. It's for the early git users' eyes only - And even they have to demonstrate that they're within 5 GitHub user ID points of my own (preferably lower) beforehand.<|eor|><|sor|>> (preferably lower)
(preferably higher)<|eor|><|eols|><|endoftext|> | 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.