subreddit stringclasses 7
values | author stringlengths 3 20 | id stringlengths 5 7 | content stringlengths 67 30.4k | score int64 0 140k |
|---|---|---|---|---|
programmingcirclejerk | _FedoraTipperBot_ | htzwke0 | <|sols|><|sot|>Java was released in 1996. It got generics in 2004, 8 years later. I don't remember anyone panicking and yelling from every corner that the world is ending.<|eot|><|sol|>https://news.ycombinator.com/item?id=30047299<|eol|><|sor|>I miss the days of casting everything to `(Object)` and back.<|eor|><|sor|>Under the hood I believe Java generics pretty much just do this automatically for you. I think this is sort of the reason why you can't do generics of non-boxed objects (e.g. ArrayList<int> will not compile but ArrayList<Integer> will).<|eor|><|sor|>[deleted]<|eor|><|sor|>Look over to C# to see how its done better.<|eor|><|sor|>Look over to C++ to see generic perfection (unironically)<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | ProfessorSexyTime | htz85e0 | <|sols|><|sot|>Java was released in 1996. It got generics in 2004, 8 years later. I don't remember anyone panicking and yelling from every corner that the world is ending.<|eot|><|sol|>https://news.ycombinator.com/item?id=30047299<|eol|><|sor|>Well in 1999 everyone was panicking that the world was going to end, and Java existed then and generics were proposed then. (No I did not actually check if they were, I just know I'm right. )<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | SelfDistinction | hu034i9 | <|sols|><|sot|>Java was released in 1996. It got generics in 2004, 8 years later. I don't remember anyone panicking and yelling from every corner that the world is ending.<|eot|><|sol|>https://news.ycombinator.com/item?id=30047299<|eol|><|soopr|>C has no sum types after 70 years so I dont think anyone will even think about panicking and yelling from every corner that the world is ending. Go 1.2097 will have it. It will be optional only<|eoopr|><|sor|>C standard is the holy scripture that nobody dare change. Thou shalt not corrupt its teachings. Thou shalt not change it excepting that thou clarify that which remained unsaid.
Heretics caught infringing upon these commandments shall be burned on the stake as overseen by the HolyC.<|eor|><|sor|>I truly wish this was simply a jerk.<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | Gearwatcher | htzyr0c | <|sols|><|sot|>Java was released in 1996. It got generics in 2004, 8 years later. I don't remember anyone panicking and yelling from every corner that the world is ending.<|eot|><|sol|>https://news.ycombinator.com/item?id=30047299<|eol|><|sor|>If you were writing Java in 2004 for a living you had many other reasons to breathe into a paper bag so this simply registered fairly low.<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | ____ben____ | rwclre | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|eols|><|endoftext|> | 135 |
programmingcirclejerk | zygohistomoronism | hrb8wzm | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>> :`jerk`: When you unironically expect people to follow your crazy emoji guidelines and it gets you featured on PCJ<|eor|><|eols|><|endoftext|> | 104 |
programmingcirclejerk | muntaxitome | hrbzem9 | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>And yet the unicode team keeps ignoring my proposal for the dumpster fire emoji that I keep sending all the committee members by mail to their home every week.<|eor|><|eols|><|endoftext|> | 45 |
programmingcirclejerk | closer_now | hrcfros | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>/uj This is basically just a minimal subset of [gitmoji](https://gitmoji.dev/) ([GitHub](https://github.com/carloscuesta/gitmoji)). It's fairly common; not sure what the fuss is here.<|eor|><|sor|>what the hell is gitmoji and how do I get it away from me<|eor|><|sor|>Gitmoji is simply a way to ensure Windows/Linux users (aka poor people) cannot render `git log` properly in their terminals. Simply put, I only want contributions from aluminum-poisoned Mac users and this ensures it stays that way.<|eor|><|eols|><|endoftext|> | 42 |
programmingcirclejerk | EternityForest | hrbz7wx | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>Fire should NOT be used for trash. It's way too ambiguous. People use it to mean "That was lit fam".
Look at all these emoji that have to do with negatives or destruction! A toilet would be more appropriate for the "Good riddance" feeling of replacing 1000 lines of algorithms with 50 lines of new stdlib calls.
<|eor|><|eols|><|endoftext|> | 37 |
programmingcirclejerk | Theon | hrc6wua | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>/uj This is basically just a minimal subset of [gitmoji](https://gitmoji.dev/) ([GitHub](https://github.com/carloscuesta/gitmoji)). It's fairly common; not sure what the fuss is here.<|eor|><|sor|>what the hell is gitmoji and how do I get it away from me<|eor|><|eols|><|endoftext|> | 36 |
programmingcirclejerk | ProgVal | hrc0hhn | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>It is missing the emojis for:
* rewriting it in Rust
* adding a feature that is not cool
* doing the daily 1k lines update to yarn.lock<|eor|><|eols|><|endoftext|> | 31 |
programmingcirclejerk | voidvector | hrcafyo | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>> :lipstick: When you worked on the UI of the preferences dialog.<|eor|><|sor|>Electron is just a over Vim<|eor|><|eols|><|endoftext|> | 26 |
programmingcirclejerk | closer_now | hrcrii1 | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>/uj This is basically just a minimal subset of [gitmoji](https://gitmoji.dev/) ([GitHub](https://github.com/carloscuesta/gitmoji)). It's fairly common; not sure what the fuss is here.<|eor|><|sor|>what the hell is gitmoji and how do I get it away from me<|eor|><|sor|>Gitmoji is simply a way to ensure Windows/Linux users (aka poor people) cannot render `git log` properly in their terminals. Simply put, I only want contributions from aluminum-poisoned Mac users and this ensures it stays that way.<|eor|><|sor|>Wait what? Windows and Linux have plenty of popular terminals that render emoji. It's literally the only way I can make my CLIs look less garbage<|eor|><|sor|><|eor|><|eols|><|endoftext|> | 25 |
programmingcirclejerk | DeBryceIsRight | hrbysyq | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>/uj This is basically just a minimal subset of [gitmoji](https://gitmoji.dev/) ([GitHub](https://github.com/carloscuesta/gitmoji)). It's fairly common; not sure what the fuss is here.<|eor|><|eols|><|endoftext|> | 23 |
programmingcirclejerk | maritocracy_lage | hrc0m0z | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>> :`jerk`: When you unironically expect people to follow your crazy emoji guidelines and it gets you featured on PCJ<|eor|><|sor|>comptime @unjerk (This is \_definitely\_ not unironically)<|eor|><|eols|><|endoftext|> | 22 |
programmingcirclejerk | maritocracy_lage | hrc0ifg | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>And yet the unicode team keeps ignoring my proposal for the dumpster fire emoji that I keep sending all the committee members by mail to their home every week.<|eor|><|sor|>PM me their addresses, I'll start sending letters too.<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | Poddster | hrcfwp6 | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>It is missing the emojis for:
* rewriting it in Rust
* adding a feature that is not cool
* doing the daily 1k lines update to yarn.lock<|eor|><|sor|>> rewriting it in Rust
It's a multipart: <|eor|><|eols|><|endoftext|> | 17 |
programmingcirclejerk | UnicornPrince4U | hrctxt0 | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>You should start it with an NFT to add value to your commit history.<|eor|><|eols|><|endoftext|> | 14 |
programmingcirclejerk | Poddster | hrcfyev | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>/uj This is basically just a minimal subset of [gitmoji](https://gitmoji.dev/) ([GitHub](https://github.com/carloscuesta/gitmoji)). It's fairly common; not sure what the fuss is here.<|eor|><|sor|>what the hell is gitmoji and how do I make it the standard content for all of my README's created by my various IDEs?<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | Fooking-Degenerate | hrbzw69 | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>This is incredibly based and I will die on that hill<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | crestedshriketit | hrcsftg | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>I'm annoyed they use `U+1FAB2 'BEETLE'` instead of `U+1F41B 'BUG'` for bugs.
I get that it's prettier (in most contexts), but also quite counterintuitive.<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | MorseCodeFan | hrcrfqx | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>/uj This is basically just a minimal subset of [gitmoji](https://gitmoji.dev/) ([GitHub](https://github.com/carloscuesta/gitmoji)). It's fairly common; not sure what the fuss is here.<|eor|><|sor|>what the hell is gitmoji and how do I get it away from me<|eor|><|sor|>Gitmoji is simply a way to ensure Windows/Linux users (aka poor people) cannot render `git log` properly in their terminals. Simply put, I only want contributions from aluminum-poisoned Mac users and this ensures it stays that way.<|eor|><|sor|>Wait what? Windows and Linux have plenty of popular terminals that render emoji. It's literally the only way I can make my CLIs look less garbage<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | HINDBRAIN | hrcp9ry | <|sols|><|sot|>Contribution Guidelines: "You should also start your commit message with one applicable emoji"<|eot|><|sol|>https://github.com/Schneegans/Burn-My-Windows/blob/main/README.md#octocat-i-want-to-contribute<|eol|><|sor|>UJ: I actually vaguely like this, helps parse a list of commits at a glance.<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | cmov | r9cour | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|eols|><|endoftext|> | 140 |
programmingcirclejerk | cmov | hnb52tw | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|soopr|>Security consultant here.
The fact that Golang has no built-in sort function is a huge thing. I've read countless amount of code that abused built-in sort functions (unfortunarely developers think they have to use built-in sort functions all the time if they are available) and is probably completely insecure for the simple reason that very few people manage to audit/understand the code. If built-in sort functions could only be used when necessary, yes, but there are no technical way to enforce this.
I feel like a lot of the negative perspectives are given from the writing point of view, but the reading perspective is clearly a huge win for Golang.<|eoopr|><|eols|><|endoftext|> | 102 |
programmingcirclejerk | RustEvangelist10xer | hnb6gdn | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>The key point here is our programmers are Gophers, theyre not 10xers. Theyre typically, fairly dumb, fresh out of bootcamp, probably learned .NET, maybe learned Vue or React, probably learned Node. Theyre not capable of understanding a brilliant `sort` function but we want to use them to build repetitive Go codebases. So, the language that we give them has to lack simple functionalities for them to understand and easy to adopt.<|eor|><|eols|><|endoftext|> | 83 |
programmingcirclejerk | sadclass08 | hnb5xlk | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>Actually its a good thing that go doesnt have a sort function. Its all about making things less confusing for Googles top talent <|eor|><|eols|><|endoftext|> | 55 |
programmingcirclejerk | RepresentativeNo6029 | hnbb6xk | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>Actually its a good thing that go doesnt have a sort function. Its all about making things less confusing for Googles top talent <|eor|><|sor|>I mean whats even the point of leetcode if you arent writing sorts 12 times a day<|eor|><|eols|><|endoftext|> | 49 |
programmingcirclejerk | cmov | hnbgs54 | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|soopr|>Security consultant here.
The fact that Golang has no built-in sort function is a huge thing. I've read countless amount of code that abused built-in sort functions (unfortunarely developers think they have to use built-in sort functions all the time if they are available) and is probably completely insecure for the simple reason that very few people manage to audit/understand the code. If built-in sort functions could only be used when necessary, yes, but there are no technical way to enforce this.
I feel like a lot of the negative perspectives are given from the writing point of view, but the reading perspective is clearly a huge win for Golang.<|eoopr|><|sor|>/uj Ill never get tired of this. Would love to see the source<|eor|><|soopr|>Security consultant here.
The fact that /u/RepresentativeNo6029 will not get tired of this is a huge thing. I've seen countless amount of Redditors that abused getting tired (unfortunarely Redditors think they have to get tired all the time if they can) and is probably completely insecure for the simple reason that very few people manage to audit/understand getting tired. If getting tired could only be used when necessary, yes, but there are no technical way to enforce this.
I feel like a lot of the negative perspectives are given from the writing point of view, but the reading perspective is clearly a huge win for /u/RepresentativeNo6029.<|eoopr|><|eols|><|endoftext|> | 49 |
programmingcirclejerk | RepresentativeNo6029 | hnbb48n | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|soopr|>Security consultant here.
The fact that Golang has no built-in sort function is a huge thing. I've read countless amount of code that abused built-in sort functions (unfortunarely developers think they have to use built-in sort functions all the time if they are available) and is probably completely insecure for the simple reason that very few people manage to audit/understand the code. If built-in sort functions could only be used when necessary, yes, but there are no technical way to enforce this.
I feel like a lot of the negative perspectives are given from the writing point of view, but the reading perspective is clearly a huge win for Golang.<|eoopr|><|sor|>/uj Ill never get tired of this. Would love to see the source<|eor|><|eols|><|endoftext|> | 42 |
programmingcirclejerk | hiptobecubic | hnbz7yc | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>The key point here is our programmers are Gophers, theyre not 10xers. Theyre typically, fairly dumb, fresh out of bootcamp, probably learned .NET, maybe learned Vue or React, probably learned Node. Theyre not capable of understanding a brilliant `sort` function but we want to use them to build repetitive Go codebases. So, the language that we give them has to lack simple functionalities for them to understand and easy to adopt.<|eor|><|sor|>You think you're jerking here but it's not possible to parody tech executives. It literally cannot be done.<|eor|><|eols|><|endoftext|> | 34 |
programmingcirclejerk | F54280 | hnbbryn | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>It is feared that the introduction of generics will open the possibility of a built-in sort function in go, quite an unfortunate outcome if you ask me, and the proof of the nastiness of generics.
This hard and cold reality has the risk of bursting the bubble (sort of) of all current goers, currently a go no-go.<|eor|><|eols|><|endoftext|> | 32 |
programmingcirclejerk | RustEvangelist10xer | hnc341m | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>The key point here is our programmers are Gophers, theyre not 10xers. Theyre typically, fairly dumb, fresh out of bootcamp, probably learned .NET, maybe learned Vue or React, probably learned Node. Theyre not capable of understanding a brilliant `sort` function but we want to use them to build repetitive Go codebases. So, the language that we give them has to lack simple functionalities for them to understand and easy to adopt.<|eor|><|sor|>You think you're jerking here but it's not possible to parody tech executives. It literally cannot be done.<|eor|><|sor|>Are you suggesting that the Commander is a mere tech executive and not the brilliant mind behind the most innovative ideas in PL design?<|eor|><|eols|><|endoftext|> | 28 |
programmingcirclejerk | cmov | hnb4txr | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|soopr|>> For me this has been my first systems level programming language and the lack of fluent API and explicit error handling makes me feel like I'm gaining a much better appreciation for simplicity, and also realize how much magic .NET hides behind linq and other fluent style expressions.<|eoopr|><|eols|><|endoftext|> | 26 |
programmingcirclejerk | Qesa | hnbdzct | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|soopr|>Security consultant here.
The fact that Golang has no built-in sort function is a huge thing. I've read countless amount of code that abused built-in sort functions (unfortunarely developers think they have to use built-in sort functions all the time if they are available) and is probably completely insecure for the simple reason that very few people manage to audit/understand the code. If built-in sort functions could only be used when necessary, yes, but there are no technical way to enforce this.
I feel like a lot of the negative perspectives are given from the writing point of view, but the reading perspective is clearly a huge win for Golang.<|eoopr|><|sor|>/uj Ill never get tired of this. Would love to see the source<|eor|><|sor|>https://www.reddit.com/r/programmingcirclejerk/comments/btobtu/security_consultant_here_the_fact_that_golang_has/<|eor|><|eols|><|endoftext|> | 25 |
programmingcirclejerk | irqlnotdispatchlevel | hnclvng | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>Bro I used sort countless times without knowing what it does. Like why does it output 1, 2, 3 if my array is 2, 1, 3? I tried to figure it out by looking at open source versions of the C++ library, but it was so messy, with a lot of generics and I just gave up. Once I needed a sorted array in Go and I copy pasted a solution from stack overflow 4 times (once for each thing I needed to sort) it all started to make sense. I actually know what sort does now. Go is the best CS teacher one could wish for.<|eor|><|eols|><|endoftext|> | 23 |
programmingcirclejerk | corona-info | hnblnl2 | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>Actually its a good thing that go doesnt have a sort function. Its all about making things less confusing for Googles top talent <|eor|><|sor|>They're busy trying to figure out how to pass function arguments in registers.<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | ws-ilazki | hnben6t | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>Tell me you're a Gopher without actually saying you're a Gopher<|eor|><|eols|><|endoftext|> | 16 |
programmingcirclejerk | SelfDistinction | hnc1gft | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>Therapist: Golang doesn't have a built in sort and it cannot hurt you.
[Golang's built in sort:](https://pkg.go.dev/sort)<|eor|><|eols|><|endoftext|> | 16 |
programmingcirclejerk | NonDairyYandere | hnc4of6 | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>> depending on a huge library
It's in stdlib, you re-used nonce<|eor|><|eols|><|endoftext|> | 14 |
programmingcirclejerk | Bodine12 | hnc04qo | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>People are finally recognizing what Go has known for some time: the real problem is that programmers have developed the habit of depending on things being sorted. If your code needs things sorted in order to work, can you even call yourself a programmer?<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | cmov | hnbhs2q | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>Tell me you're a Gopher without actually saying you're a Gopher<|eor|><|soopr|>> Tell me you're a Gopher without actually saying you're a Gopher
C > Rust > C++<|eoopr|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | voidvector | hnbli99 | <|sols|><|sot|>Example: no built in sort. Annoying yes. But refreshing to me that I need to write a few lines and to create a sorting instead of depending on a huge library of these things (like .net) without really understanding what they are doing.<|eot|><|sol|>https://old.reddit.com/r/golang/comments/r7uskf/is_go_that_verbose_or_am_i_missing_something/hn8q9e8/<|eol|><|sor|>You know you are a 10xer when you have copypaste sorting algorithm everyday.<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | rgdmarshall | r5sihz | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|eols|><|endoftext|> | 139 |
programmingcirclejerk | humandictionary | hmow2vd | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>This dude is literally jerking over Rust...
One of us!<|eor|><|eols|><|endoftext|> | 55 |
programmingcirclejerk | AcrobaticBroccoli | hmpgqgu | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>Confirming - keeping my wife happy since my switch to Rust.<|eor|><|sor|>I can confirm keeping his wife happy since his switch to Rust as well<|eor|><|eols|><|endoftext|> | 34 |
programmingcirclejerk | orc_shoulders | hmp9t0z | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>every time my compiler prints a formatting fix for me, i immediately get hard. not because im about to make my code cleaner but because i was enlightened enough to choose these specific tools.<|eor|><|eols|><|endoftext|> | 31 |
programmingcirclejerk | fp_weenie | hmp2jur | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>Plaudits to all involved for staying so enthusiastic about Rust!<|eor|><|eols|><|endoftext|> | 27 |
programmingcirclejerk | isthistechsupport | hmpbaty | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>Once again, we've been outjerked by the RESF<|eor|><|eols|><|endoftext|> | 20 |
programmingcirclejerk | roguas | hmpey6l | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>A diagonal monoapplicative in my pants goes >><|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | Ryoflux | hmrq0cj | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>Confirming - keeping my wife happy since my switch to Rust.<|eor|><|sor|>I can confirm keeping his wife happy since his switch to Rust as well<|eor|><|sor|>The long compile times means she can spend more time with her boyfriend<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | ProfessorSexyTime | hmqhy4l | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>Ironically, it would seem, the conference is named "Stockholm CPP."
So we're moving from Stockholm syndrome with Cdoubleplusgood, to Stockholm syndrome with Rust. To the point of erection.
Plaudits to all involved.<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | duckbill_principate | hmqeo42 | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>Wait till he learns about GC..<|eor|><|sor|>More GC, less socks.<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | fnordulicious | hmrhr57 | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>As for me, it is segmentation faults that keep me regular.<|eor|><|sor|>A nice daily core dump really cleans you out and leaves you feeling fresh, yknow?<|eor|><|eols|><|endoftext|> | 8 |
programmingcirclejerk | skulgnome | hmr3kxv | <|sols|><|sot|>Something in my pants goes wild when borrow checker catches a potential bug<|eot|><|sol|>https://np.reddit.com/r/rust/comments/r55hz5/mats_kindahl_a_c_programmers_view_on_rust/hmo5pfr/<|eol|><|sor|>As for me, it is segmentation faults that keep me regular.<|eor|><|eols|><|endoftext|> | 6 |
programmingcirclejerk | cmov | quglut | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|eols|><|endoftext|> | 139 |
programmingcirclejerk | lambda-male | hkpxymz | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>so called runtime type inference<|eor|><|eols|><|endoftext|> | 148 |
programmingcirclejerk | cmov | hkpv4vg | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>> Python is strongly typed, and dynamically typed. Strongly typed because the interpreter enforces types, and doesnt change them under the hood, ala JS.
>>> 1 == True
True
>>> True + True
2
>>> True * True
1
|S|T|R|O|N|G|L|Y||T|Y|P|E|D|
|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|
|T||||||||||||||
|R||||||||||||||
|O||||||||||||||
|N||||||||||||||
|G||||||||||||||
|L||||||||||||||
|Y||||||||||||||
|||||||||||||||
|T||||||||||||||
|Y||||||||||||||
|P||||||||||||||
|E||||||||||||||
|D||||||||||||||<|eoopr|><|eols|><|endoftext|> | 107 |
programmingcirclejerk | OctagonClock | hkpzs0s | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>> Python is strongly typed, and dynamically typed. Strongly typed because the interpreter enforces types, and doesnt change them under the hood, ala JS.
>>> 1 == True
True
>>> True + True
2
>>> True * True
1
|S|T|R|O|N|G|L|Y||T|Y|P|E|D|
|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|
|T||||||||||||||
|R||||||||||||||
|O||||||||||||||
|N||||||||||||||
|G||||||||||||||
|L||||||||||||||
|Y||||||||||||||
|||||||||||||||
|T||||||||||||||
|Y||||||||||||||
|P||||||||||||||
|E||||||||||||||
|D||||||||||||||<|eoopr|><|sor|>Booleans are ints, as G-d intended. Cope and seethe, immoral heathen.<|eor|><|eols|><|endoftext|> | 81 |
programmingcirclejerk | cmov | hkq78mk | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>Security consultant here.
The fact that Python has no booleans is a huge thing. I've read countless amount of code that abused booleans (unfortunarely developers think they have to use booleans all the time if they are available) and is probably completely insecure for the simple reason that very few people manage to audit/understand the code. If it booleans could only be used when necessary, yes, but there are no technical way to enforce this.
Pythonfmt is the second blessing. All codebases look the same because it is not customizable. This makes reading Python code and understanding it fast as hell.
The PYTHONPATH is also a huge win. You always know where everything is and it is really fast to figure out about dependencies or structure of the project.
What I'm saying is that in my years of security consulting, Python codebases have always been the clearest ones to read and have always been the most secure ones.
I feel like a lot of the negative perspectives are given from the writing point of view, but the reading perspective is clearly a huge win for Python.<|eoopr|><|eols|><|endoftext|> | 67 |
programmingcirclejerk | senj | hkrptu5 | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>while Haskell is famous for its implementation of Hindley-Milner type inference, Python implements Dunning-Kruger type inference<|eor|><|eols|><|endoftext|> | 57 |
programmingcirclejerk | tomwhoiscontrary | hkqtvx3 | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>> Python is strongly typed, and dynamically typed. Strongly typed because the interpreter enforces types, and doesnt change them under the hood, ala JS.
>>> 1 == True
True
>>> True + True
2
>>> True * True
1
|S|T|R|O|N|G|L|Y||T|Y|P|E|D|
|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|
|T||||||||||||||
|R||||||||||||||
|O||||||||||||||
|N||||||||||||||
|G||||||||||||||
|L||||||||||||||
|Y||||||||||||||
|||||||||||||||
|T||||||||||||||
|Y||||||||||||||
|P||||||||||||||
|E||||||||||||||
|D||||||||||||||<|eoopr|><|sor|>"My types are too strong for you, programmer."
-- Guido van Rossum<|eor|><|eols|><|endoftext|> | 57 |
programmingcirclejerk | RustEvangelist10xer | hkq1rwc | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>This is an unhelpful r/programming "well actually" comment that recurs in any Python thread.
Everyone knows what is meant when someone casually says Python is "untyped" vis-a-vis Rust. It adds nothing to the conversation to reply that "actually, what you're referring to as untyped is actually dynamic typing slash type inference". There are almost no strictly "untyped" languages of relevance for this to plausibly be preventing any confusion.
For normal people, "untyped language" means "program explodes at runtime instead of giving a compile error"[.](https://www.reddit.com/r/programming/comments/qsx9t7/comment/hkovnr2/?context=3)<|eor|><|eols|><|endoftext|> | 54 |
programmingcirclejerk | pareidolist | hkqjr0b | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>This is an unhelpful r/programming "well actually" comment that recurs in any Python thread.
Everyone knows what is meant when someone casually says Python is "untyped" vis-a-vis Rust. It adds nothing to the conversation to reply that "actually, what you're referring to as untyped is actually dynamic typing slash type inference". There are almost no strictly "untyped" languages of relevance for this to plausibly be preventing any confusion.
For normal people, "untyped language" means "program explodes at runtime instead of giving a compile error"[.](https://www.reddit.com/r/programming/comments/qsx9t7/comment/hkovnr2/?context=3)<|eor|><|sor|>Or as I call it, dynamic typing + type inference<|eor|><|eols|><|endoftext|> | 42 |
programmingcirclejerk | profmonocle | hkq2m3w | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>"Python is not untyped if you just ignore the common usage of that word."<|eor|><|eols|><|endoftext|> | 40 |
programmingcirclejerk | wildlyinaccurate | hkr9r1g | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>> Python is strongly typed, and dynamically typed. Strongly typed because the interpreter enforces types, and doesnt change them under the hood, ala JS.
>>> 1 == True
True
>>> True + True
2
>>> True * True
1
|S|T|R|O|N|G|L|Y||T|Y|P|E|D|
|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|
|T||||||||||||||
|R||||||||||||||
|O||||||||||||||
|N||||||||||||||
|G||||||||||||||
|L||||||||||||||
|Y||||||||||||||
|||||||||||||||
|T||||||||||||||
|Y||||||||||||||
|P||||||||||||||
|E||||||||||||||
|D||||||||||||||<|eoopr|><|sor|>"My types are too strong for you, programmer."
-- Guido van Rossum<|eor|><|sor|>Type seller, I'm telling you. I'm going to build enterprise-grade software and I need your strongest types!<|eor|><|eols|><|endoftext|> | 39 |
programmingcirclejerk | xmcqdpt2 | hkt47g1 | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>so called runtime type inference<|eor|><|sor|>just-in-time static analysis<|eor|><|eols|><|endoftext|> | 38 |
programmingcirclejerk | kkjdroid | hkqyhrh | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>> Python is strongly typed, and dynamically typed. Strongly typed because the interpreter enforces types, and doesnt change them under the hood, ala JS.
>>> 1 == True
True
>>> True + True
2
>>> True * True
1
|S|T|R|O|N|G|L|Y||T|Y|P|E|D|
|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|
|T||||||||||||||
|R||||||||||||||
|O||||||||||||||
|N||||||||||||||
|G||||||||||||||
|L||||||||||||||
|Y||||||||||||||
|||||||||||||||
|T||||||||||||||
|Y||||||||||||||
|P||||||||||||||
|E||||||||||||||
|D||||||||||||||<|eoopr|><|sor|>Booleans are ints, as G-d intended. Cope and seethe, immoral heathen.<|eor|><|sor|>If by "G-d" you mean Dennis Ritchie, then yes.<|eor|><|eols|><|endoftext|> | 32 |
programmingcirclejerk | PL_Design | hkq8nwj | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>scratch is the only untyped language<|eor|><|eols|><|endoftext|> | 31 |
programmingcirclejerk | billy_tables | hkqz86o | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>I use void* for everything because I love untyped C<|eor|><|eols|><|endoftext|> | 27 |
programmingcirclejerk | doomvox | hkrb21n | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>And you can't write python code without typing, right?<|eor|><|eols|><|endoftext|> | 18 |
programmingcirclejerk | IronCrouton | hkslwip | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>Security consultant here.
The fact that Python has no booleans is a huge thing. I've read countless amount of code that abused booleans (unfortunarely developers think they have to use booleans all the time if they are available) and is probably completely insecure for the simple reason that very few people manage to audit/understand the code. If it booleans could only be used when necessary, yes, but there are no technical way to enforce this.
Pythonfmt is the second blessing. All codebases look the same because it is not customizable. This makes reading Python code and understanding it fast as hell.
The PYTHONPATH is also a huge win. You always know where everything is and it is really fast to figure out about dependencies or structure of the project.
What I'm saying is that in my years of security consulting, Python codebases have always been the clearest ones to read and have always been the most secure ones.
I feel like a lot of the negative perspectives are given from the writing point of view, but the reading perspective is clearly a huge win for Python.<|eoopr|><|sor|>[deleted]<|eor|><|sor|>r/lostredditors<|eor|><|eols|><|endoftext|> | 17 |
programmingcirclejerk | jdauriemma | hks3i0m | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>> Python is strongly typed, and dynamically typed. Strongly typed because the interpreter enforces types, and doesnt change them under the hood, ala JS.
>>> 1 == True
True
>>> True + True
2
>>> True * True
1
|S|T|R|O|N|G|L|Y||T|Y|P|E|D|
|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|
|T||||||||||||||
|R||||||||||||||
|O||||||||||||||
|N||||||||||||||
|G||||||||||||||
|L||||||||||||||
|Y||||||||||||||
|||||||||||||||
|T||||||||||||||
|Y||||||||||||||
|P||||||||||||||
|E||||||||||||||
|D||||||||||||||<|eoopr|><|sor|>Booleans are ints, as G-d intended. Cope and seethe, immoral heathen.<|eor|><|sor|>If by "G-d" you mean Dennis Ritchie, then yes.<|eor|><|sor|>`D____s R_____e`<|eor|><|eols|><|endoftext|> | 15 |
programmingcirclejerk | MadCervantes | hkr6ey4 | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|sor|>This is an unhelpful r/programming "well actually" comment that recurs in any Python thread.
Everyone knows what is meant when someone casually says Python is "untyped" vis-a-vis Rust. It adds nothing to the conversation to reply that "actually, what you're referring to as untyped is actually dynamic typing slash type inference". There are almost no strictly "untyped" languages of relevance for this to plausibly be preventing any confusion.
For normal people, "untyped language" means "program explodes at runtime instead of giving a compile error"[.](https://www.reddit.com/r/programming/comments/qsx9t7/comment/hkovnr2/?context=3)<|eor|><|sor|>As someone coming from a self taught background I disagree that "everyone knows what untyped means" and the sloppy use of terminology made it needlessly difficult for me to actually understand how different languages approach typing.<|eor|><|eols|><|endoftext|> | 14 |
programmingcirclejerk | watcher202010 | hkrhiob | <|sols|><|sot|>Python is not untyped. You dont write types in the source code, but that doesnt mean its untyped. It is dynamically typed and uses type inference. Type inference is why you dont have to write types in the source code.<|eot|><|sol|>https://old.reddit.com/r/programming/comments/qsx9t7/why_asynchronous_rust_doesnt_work/hkgh43m/<|eol|><|soopr|>> Python is strongly typed, and dynamically typed. Strongly typed because the interpreter enforces types, and doesnt change them under the hood, ala JS.
>>> 1 == True
True
>>> True + True
2
>>> True * True
1
|S|T|R|O|N|G|L|Y||T|Y|P|E|D|
|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|:-|
|T||||||||||||||
|R||||||||||||||
|O||||||||||||||
|N||||||||||||||
|G||||||||||||||
|L||||||||||||||
|Y||||||||||||||
|||||||||||||||
|T||||||||||||||
|Y||||||||||||||
|P||||||||||||||
|E||||||||||||||
|D||||||||||||||<|eoopr|><|sor|> I don't believe that a stricter interpretation of "Booleanness" makes the language any clearer.
Booleans, integers, ... doesn't matter apparently.
Source: https://www.python.org/dev/peps/pep-0285/<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | lambda-male | oktrwi | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|eols|><|endoftext|> | 139 |
programmingcirclejerk | PaulExpendableTurtle | h5ahl09 | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Great programmers write code that everyone can read. In this example I would go with
`mAKAsource aAKAinput -> (aAKAinput -> mAKAsource bAKAresult) -> mAKAsource bAKAresult`<|eor|><|sor|>> bAKA result
What are you doing, monad-san<|eor|><|eols|><|endoftext|> | 149 |
programmingcirclejerk | Banamagrammer | h5aezva | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Great programmers write code that everyone can read. In this example I would go with
`mAKAsource aAKAinput -> (aAKAinput -> mAKAsource bAKAresult) -> mAKAsource bAKAresult`<|eor|><|eols|><|endoftext|> | 84 |
programmingcirclejerk | fp_weenie | h5a1rfu | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>lol ok wagie<|eor|><|eols|><|endoftext|> | 73 |
programmingcirclejerk | Infernio | h5avtx5 | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Pictured: Software "engineers" congratulating themselves for their excellent naming conventions before strolling off to pump out the next `AbstractBeanObserverFactoryFactoryBuilder`<|eor|><|eols|><|endoftext|> | 65 |
programmingcirclejerk | lambda-male | h5a0rlz | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|soopr|>I imagine these kind of le programmers start screeching something about "clean code" when they hear the phrase "go from point A to point B"<|eoopr|><|eols|><|endoftext|> | 64 |
programmingcirclejerk | kigaltan | h5acw0x | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>As yes, the podcast "My Brother, My Brother, And Me", or as big-brain haskalers like me call it, `m b -> ( m -> b a) -> m`<|eor|><|eols|><|endoftext|> | 57 |
programmingcirclejerk | McGlockenshire | h5aikjl | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>I just want to take a moment to say that your name is pretty good, OP.<|eor|><|eols|><|endoftext|> | 41 |
programmingcirclejerk | VitulusAureus | h5afcn6 | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|soopr|>I imagine these kind of le programmers start screeching something about "clean code" when they hear the phrase "go from point A to point B"<|eoopr|><|sor|>A/B testing? More like g_arrpszOldFeaturesList/g_arrpszNewFeaturesList testing.<|eor|><|eols|><|endoftext|> | 41 |
programmingcirclejerk | lambda-male | h5aku46 | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Great programmers write code that everyone can read. In this example I would go with
`mAKAsource aAKAinput -> (aAKAinput -> mAKAsource bAKAresult) -> mAKAsource bAKAresult`<|eor|><|soopr|>You can use type equalities, type constraints, and phantom type parameters containing structural type-level records to allow for both unabbreviated and expanded names in your code. Sadly, Haskal doesn't have these features and is bad at this kind of type-level programming, so I'll have to use OCaml. Beginners can follow all the equalities explaining step-by-step what's happening, while experts can just skim the abbreviated form.
module type ParameterizedSource = sig
type 'a source
end
module Make_bind_type (Ps : ParameterizedSource) = struct
type 'a m = 'a Ps.source
type 'type_parameters bind_t =
'a m -> ('a -> 'b m) -> 'b m
constraint 'type_parameters = < input : 'a; result : 'b >
end<|eoopr|><|eols|><|endoftext|> | 25 |
programmingcirclejerk | BufferUnderpants | h5b5kzr | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Where's the lie tho?<|eor|><|sor|>Im using a FP language so my code has to speak for itself. Documentation? Descriptive naming? These are for Neanderthals.<|eor|><|sor|>"I'm an agile enterprise wageslave and having code read like math is unthinkable, let's have a meeting coming up with different tortured analogies to use in place of the standard notation"<|eor|><|eols|><|endoftext|> | 23 |
programmingcirclejerk | csb06 | h5bawlm | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>I just want to take a moment to say that your name is pretty good, OP.<|eor|><|sor|>its a new variant<|eor|><|sor|>While sigma males are dark and twisted, lambda males are light and well-starched. Sigmas are jokerfied; lambdas are nootropic-pilled. Wario is a sigma; Paul Graham is a lambda.<|eor|><|eols|><|endoftext|> | 22 |
programmingcirclejerk | VeganVagiVore | h5cb5am | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Pictured: Software "engineers" congratulating themselves for their excellent naming conventions before strolling off to pump out the next `AbstractBeanObserverFactoryFactoryBuilder`<|eor|><|sor|>> AbstractBeanObserver
I think we have one of them doing monitoring and metrics on the coffee machine<|eor|><|eols|><|endoftext|> | 20 |
programmingcirclejerk | VeganVagiVore | h5cb3ig | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Great programmers write code that everyone can read. In this example I would go with
`mAKAsource aAKAinput -> (aAKAinput -> mAKAsource bAKAresult) -> mAKAsource bAKAresult`<|eor|><|soopr|>You can use type equalities, type constraints, and phantom type parameters containing structural type-level records to allow for both unabbreviated and expanded names in your code. Sadly, Haskal doesn't have these features and is bad at this kind of type-level programming, so I'll have to use OCaml. Beginners can follow all the equalities explaining step-by-step what's happening, while experts can just skim the abbreviated form.
module type ParameterizedSource = sig
type 'a source
end
module Make_bind_type (Ps : ParameterizedSource) = struct
type 'a m = 'a Ps.source
type 'type_parameters bind_t =
'a m -> ('a -> 'b m) -> 'b m
constraint 'type_parameters = < input : 'a; result : 'b >
end<|eoopr|><|sor|>why did they invent Rust when we already had this<|eor|><|eols|><|endoftext|> | 20 |
programmingcirclejerk | ws-ilazki | h5cdjgn | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>> What if we named it first_thing and second_thing? I cant handle the kind of mathematical obscurity we get with arcane letters like a or b. I imagine theyll even have a c next.
Okay either this guy is one of us or proggit's jerking better than PCJ on this one.<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | Mountain-Log9383 | h5az2s2 | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>I just want to take a moment to say that your name is pretty good, OP.<|eor|><|sor|>its a new variant<|eor|><|eols|><|endoftext|> | 18 |
programmingcirclejerk | zygohistomoronism | h5bnhsd | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>I don't know what a typeclass is and I can't read polymorphic function signatures without angle brackets, so I'll trust my objectively superior OOP brain when it tells me this code is shit.<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | BlatantMediocrity | h5azznx | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Where's the lie tho?<|eor|><|sor|>Im using a FP language so my code has to speak for itself. Documentation? Descriptive naming? These are for Neanderthals.<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | VeganVagiVore | h5cb1cl | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Great programmers write code that everyone can read. In this example I would go with
`mAKAsource aAKAinput -> (aAKAinput -> mAKAsource bAKAresult) -> mAKAsource bAKAresult`<|eor|><|sor|>> bAKA result
What are you doing, monad-san<|eor|><|sor|>monads are like burritoes, they ~envelop~ things<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | FascinatedBox | h5cffdm | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>This is the kind of person who goes into your code to refactor "x * y + z" into "AdditionWhichMayOverflow(GDMBigNumber.Multiply(x, y), z)" which is not only tediously wrong, but I also did the order of operations incorrectly. Or did I? See, I made you look. That's why it's bad.<|eor|><|eols|><|endoftext|> | 12 |
programmingcirclejerk | lkraider | h5cekiv | <|sols|><|sot|>`m a -> (a -> m b) -> m b` I mean jesus christ - if I saw my coworkers write this code I'd immediately tell them to rename those variables into something at least partially sensible like: `source input -> (input -> source result) -> source result`<|eot|><|sol|>https://www.reddit.com/r/programming/comments/o7rjg8/functors_and_monads_for_people_who_have_read_too/h31q9nd/<|eol|><|sor|>Great programmers write code that everyone can read. In this example I would go with
`mAKAsource aAKAinput -> (aAKAinput -> mAKAsource bAKAresult) -> mAKAsource bAKAresult`<|eor|><|soopr|>You can use type equalities, type constraints, and phantom type parameters containing structural type-level records to allow for both unabbreviated and expanded names in your code. Sadly, Haskal doesn't have these features and is bad at this kind of type-level programming, so I'll have to use OCaml. Beginners can follow all the equalities explaining step-by-step what's happening, while experts can just skim the abbreviated form.
module type ParameterizedSource = sig
type 'a source
end
module Make_bind_type (Ps : ParameterizedSource) = struct
type 'a m = 'a Ps.source
type 'type_parameters bind_t =
'a m -> ('a -> 'b m) -> 'b m
constraint 'type_parameters = < input : 'a; result : 'b >
end<|eoopr|><|sor|>why did they invent Rust when we already had this<|eor|><|sor|>OCaml is only for the holy of holiest, it shall not be defiled by touching bare metal hardware.<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | icholy | l2g839 | <|sols|><|sot|>Is rust becoming the defacto standard for Windows programming?<|eot|><|sol|>https://www.reddit.com/r/programming/comments/l25lz2/microsoft_unifies_all_windows_apis_under_a_single/gk3v4l8<|eol|><|eols|><|endoftext|> | 139 |
programmingcirclejerk | oeed | gk58hza | <|sols|><|sot|>Is rust becoming the defacto standard for Windows programming?<|eot|><|sol|>https://www.reddit.com/r/programming/comments/l25lz2/microsoft_unifies_all_windows_apis_under_a_single/gk3v4l8<|eol|><|sor|>in b4 Rust#<|eor|><|eols|><|endoftext|> | 106 |
programmingcirclejerk | ws-ilazki | gk5s20w | <|sols|><|sot|>Is rust becoming the defacto standard for Windows programming?<|eot|><|sol|>https://www.reddit.com/r/programming/comments/l25lz2/microsoft_unifies_all_windows_apis_under_a_single/gk3v4l8<|eol|><|sor|>since when windows have any standard ?!?<|eor|><|sor|>Since forever. Windows is so advanced that it typically has at least three standards for any version, sometimes more. You can see this in the Windows 10 design language, for example, where depending on what OS-provided application you open it may look like Windows 10, 8, 7, or even XP.
Linux applications, on the other hand, typically look like either GNOME or KDE: only two standards, not nearly enough. That's why businesses choose Windows, because it's the most standard option.<|eor|><|eols|><|endoftext|> | 70 |
programmingcirclejerk | joppatza | gk5kx5x | <|sols|><|sot|>Is rust becoming the defacto standard for Windows programming?<|eot|><|sol|>https://www.reddit.com/r/programming/comments/l25lz2/microsoft_unifies_all_windows_apis_under_a_single/gk3v4l8<|eol|><|sor|>>Is rust becoming the defacto standard for ~~Windows~~ programming?
FTFY<|eor|><|eols|><|endoftext|> | 61 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.