subreddit stringclasses 7
values | author stringlengths 3 20 | id stringlengths 5 7 | content stringlengths 67 30.4k | score int64 0 140k |
|---|---|---|---|---|
programmingcirclejerk | Serialk | gjn4c9l | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|> #include <unjerk>
int main() {
Eh, why not?
}<|eor|><|sor|>\#+BEGIN unjerk
People really underestimate teenagers.
\#+END unjerk<|eor|><|eols|><|endoftext|> | 46 |
programmingcirclejerk | Serialk | gjnpmg6 | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|> #include <unjerk>
int main() {
Eh, why not?
}<|eor|><|sor|>\#+BEGIN unjerk
People really underestimate teenagers.
\#+END unjerk<|eor|><|sor|>`#+BEGIN unjerk`
People also really overestimate teenagers, too.
See any teenager on Reddit, Twitter, etc.
`#+END unjerk`<|eor|><|sor|>I think people underestimate the intelligence of teenagers and overestimate their maturity/emotional intelligence.<|eor|><|eols|><|endoftext|> | 33 |
programmingcirclejerk | VitulusAureus | gjmqhga | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|> #include <unjerk>
int main() {
Eh, why not?
}<|eor|><|sor|>I think the jerk is in the implied assumption that c++ is something you can only learn starting from some specific age, unlike some other tools that are suitable for newborns.<|eor|><|eols|><|endoftext|> | 28 |
programmingcirclejerk | andiconda | gjn61g8 | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|>No, C++ must be strictly conformed to the age of 18 and above, any less is akin to loosing one's virginity at a lesser age.<|eor|><|sor|>This. I waited until I was 18 to learn programming. I dabbled in visual basic when I was younger. Much like how young kids used to enjoy eating lead paint chips.<|eor|><|eols|><|endoftext|> | 24 |
programmingcirclejerk | ProfessorSexyTime | gjnpdf6 | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|> #include <unjerk>
int main() {
Eh, why not?
}<|eor|><|sor|>\#+BEGIN unjerk
People really underestimate teenagers.
\#+END unjerk<|eor|><|sor|>`#+BEGIN unjerk`
People also really overestimate teenagers, too.
See any teenager on Reddit, Twitter, etc.
`#+END unjerk`<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | etaionshrd | gjojn20 | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|>No, C++ must be strictly conformed to the age of 18 and above, any less is akin to loosing one's virginity at a lesser age.<|eor|><|soopr|>your kids are coding in C++, you just don't know yet<|eoopr|><|sor|>You should teach your kids about memory safety; everyone knows abstinence-based education is largely ineffective<|eor|><|eols|><|endoftext|> | 14 |
programmingcirclejerk | UsingYourWifi | gjnaomj | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|>I'm 30 and I'm definitely not old enough to learn C++.<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | vytah | gjnik6p | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|>I mean, if she starts now, maybe she'll learn it before retiring.<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | SphericalMicrowave | gjpck14 | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|> #include <unjerk>
int main() {
Eh, why not?
}<|eor|><|sor|>Geneva Conventions.<|eor|><|sor|>More like Geneva Suggestions.<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | voidvector | gjnlvnp | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|>This is why Rust and abstinence are the moral choice.<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | Schmittfried | gjp54m6 | <|sols|><|sot|>Dude, she's 14. She's old enough to learn C++.<|eot|><|sol|>https://www.reddit.com/r/linux/comments/kz9f0o/linuxing_with_a_14_year_old/gjm6lni/<|eol|><|sor|> #include <unjerk>
int main() {
Eh, why not?
}<|eor|><|sor|>/uj
Eh, I learned C++ when I was 14 myself. Then again, I only learned that I didnt actually learn C++ with 24.<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | cutety | kwml3m | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|eols|><|endoftext|> | 139 |
programmingcirclejerk | cutety | gj563wc | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|eols|><|endoftext|> | 111 |
programmingcirclejerk | cutety | gj5bya7 | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>Mucho texto<|eor|><|soopr|>> Mucho texto
My bad, I didnt realize there were 1xers in the crowd that arent taking a shitload of adderall everyday and dont know how to appreciate a nice 12 ~~hour~~ paragraph jerk.<|eoopr|><|eols|><|endoftext|> | 60 |
programmingcirclejerk | diegovsky_pvp | gj57233 | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>That ain't a jerk, it's a foursome<|eor|><|eols|><|endoftext|> | 52 |
programmingcirclejerk | fp_weenie | gj58hvz | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>I hate modern systems. Why can't they just accept mediocrity?
Making me learn is hubris. You are like Icarus.<|eor|><|eols|><|endoftext|> | 49 |
programmingcirclejerk | numpyburner | gj5j79e | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>plaudits to all involved in this comment<|eor|><|eols|><|endoftext|> | 37 |
programmingcirclejerk | r2d2_21 | gj59zeg | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>Mucho texto<|eor|><|eols|><|endoftext|> | 34 |
programmingcirclejerk | nmarshall23 | gj5b6kc | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>My startup is working on developer pinning.
This is where we pin a dependent on a developer. Early testing shows developer are at best mediocre parents.<|eor|><|eols|><|endoftext|> | 32 |
programmingcirclejerk | fp_weenie | gj5t9bm | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>plaudits to all involved in this comment<|eor|><|sor|>Thank you (I wasn't involved but I'm part of the community).<|eor|><|eols|><|endoftext|> | 30 |
programmingcirclejerk | BufferUnderpants | gj5al7o | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>Lazy good-for-nothing Kubernetes developers, how can they not have the professionalism to have a development workflow that's compatible with Debian's 20 year old model of package management? The fucking nerve.<|eor|><|eols|><|endoftext|> | 27 |
programmingcirclejerk | axalon900 | gj5qltj | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>I dont understand why anyone would need to do anything beyond my use cases. I dont see why CMake has to be so complicated when Makefiles work just as well for my personal projects on my Arch Linux system.<|eor|><|eols|><|endoftext|> | 24 |
programmingcirclejerk | Poddster | gj5q7r8 | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>Mucho texto<|eor|><|soopr|>> Mucho texto
My bad, I didnt realize there were 1xers in the crowd that arent taking a shitload of adderall everyday and dont know how to appreciate a nice 12 ~~hour~~ paragraph jerk.<|eoopr|><|sor|>Only 1xers have time to read this lengthy crap.
I'm a 10xer, which means I'm constantly busy ALL THE TIME fixing the crap you 1xers call 'code'.<|eor|><|eols|><|endoftext|> | 24 |
programmingcirclejerk | painya | gj5pqk6 | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>Excuse me do you think I came here to _learn something_?<|eor|><|eols|><|endoftext|> | 22 |
programmingcirclejerk | qqwy | gj5gs22 | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>I need "basically the current method but just shittier" as new flair<|eor|><|eols|><|endoftext|> | 21 |
programmingcirclejerk | yawkat | gj612hs | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>20 min read<|eor|><|eols|><|endoftext|> | 20 |
programmingcirclejerk | xmcqdpt2 | gj6sly4 | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|soopr|>Today in another exciting installment of I think package management/dependency resolution is actually a really easy problem, and the current popular solutions are awful and completely wrong. Why cant these idiots just do it like how I (a very smart and well educated individual on this subject) would: *[description of a solution that not only doesnt solve the problem, it either is orders of magnitude worse than the current method, or is basically the same as the current method just shittier]*
This scholar is fed up with this outdated idea that a simple number that corresponds to basically a static snapshot of that dependency that will not change if the number does not change, and when all dependencies are like this, they can be composed into a single static acyclic graph that can not only be quickly resolved, but easily deduped as well, prevents the problem of circular dependencies, and most importantly this graph represents a static reproducible and easy to understand way validating, and resolving packages/dependencies. A package update fucked your whole project? Dont want to deal with that bullshit right now? No problem, the solution is to change the number on the package that changed back! Bada-bing bada-boom your shitty react project is working again.
Their solution to this inelegant, insecure, meaningless version numbers? Its so simple, you just count on the developers to maintain a public interface that can be used to validate any package that may ever depend on that specific version will work with that version, previous versions, and possibly future versions, as this public interface should be implemented in a way that if changes may break a dependee that uses certain features but not on another that doesnt, it can figure that out with some update script, because the developers that I just told you cant be arsed to handle adding 1 to a version number correctly will most definitely not fuck this up in any way. This gives you the benefit when there is a dependency that updates and fucks your shit up, you get to review all your dependencies public interfaces to find the specific functions that broke your (or a peers!) code and then try rolling those back (and then repeat...). This makes way more sense, as now instead of a static snapshot of shit you depend on that will always be the same, you can just dynamically generate which versions of the deps that will work at that moment! Oh, and to keep track of these updates, well assign them a number, which we can then use to rollback to an old version (but version pinning is stupid!!!)
> 1. Mark behaviour changes in the code. On release, a program can update the public functions file automatically. This would also work great with other identifiers, for example to mark functions as deprecated or experimental.
> 2. On release, every function that had code changes compared to the last release will be suggested as breaking behaviour. Each case has to be examined by hand.
> Imagine I have library A version X with public function F. Now I release X+1 and later X+2, where F changes behaviour. If a program B states that at the time of writing, library A with version X was usex, I know that I can use version X and X+1 (and potentially earlier versions), if I use F. Of course, if I don't use F, then version X+2 might work as well.
> Dynamic dependencies instead of version pinning. That is the real ~~solution to~~ dependency hell.<|eoopr|><|sor|>plaudits to all involved in this comment<|eor|><|sor|>Thank you (I wasn't involved but I'm part of the community).<|eor|><|sor|>How welcoming! How welcoming!<|eor|><|eols|><|endoftext|> | 18 |
programmingcirclejerk | officerthegeek | gj5ba5h | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>I hate modern systems. Why can't they just accept mediocrity?
Making me learn is hubris. You are like Icarus.<|eor|><|sor|>If I was like Icarus, I would care about you. But I don't. When you finally fall to your death, there will be one less bad coder in the world. And I can only hope that happens sooner rather than later.<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | csb06 | gj5xv2s | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>I dont understand why anyone would need to do anything beyond my use cases. I dont see why CMake has to be so complicated when Makefiles work just as well for my personal projects on my Arch Linux system.<|eor|><|sor|>Windows doesnt have `make` installed by default? 95% of people use a non-Unix system? Well, they should switch to Linux, and if they do not, they do not deserve to be able to build my software.<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | marmakoide | gj7bw65 | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>My startup is working on developer pinning.
This is where we pin a dependent on a developer. Early testing shows developer are at best mediocre parents.<|eor|><|sor|>*worried looks at the pile of abadonned side projects*<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | tgbugs | gj5atfe | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>Ah, if only everyone would have just listened to Rich, they've had 4 whole years to bask in the knowledge, surely that is enough time? https://youtu.be/oyLBGkS5ICk?t=618.<|eor|><|eols|><|endoftext|> | 8 |
programmingcirclejerk | Poddster | gj5qy28 | <|sols|><|sot|>I hate modern dependency systems. Why would Go or Rust go with that old style npm system? Why don't they simply create a file with all public functions, and then generate the diffs for every version. [..] modern language[s] need a package manager [..] version pinning is the most stupid thing ever.<|eot|><|sol|>https://old.reddit.com/r/linux/comments/kwef3r/_/gj4n4sk/?context=1<|eol|><|sor|>Ah, if only everyone would have just listened to Rich, they've had 4 whole years to bask in the knowledge, surely that is enough time? https://youtu.be/oyLBGkS5ICk?t=618.<|eor|><|sor|>tl;dw<|eor|><|eols|><|endoftext|> | 8 |
programmingcirclejerk | silentconfessor | k4pkz6 | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|eols|><|endoftext|> | 137 |
programmingcirclejerk | muntaxitome | geacus3 | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>> vim/emacs
This is like saying Jesus/Hitler. Or Coffee/Ebola.<|eor|><|eols|><|endoftext|> | 95 |
programmingcirclejerk | NynaevetialMeara | geagl1q | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>> vim/emacs
This is like saying Jesus/Hitler. Or Coffee/Ebola.<|eor|><|sor|>This is like saying Jesus/Hitler. Or Coffee/Ebola.
Seems like "causing suffering on Africa" is the common denominator.<|eor|><|eols|><|endoftext|> | 76 |
programmingcirclejerk | officerthegeek | gea6k5w | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>I can't think of anything you'd do in C# on a daily basis that Rust wouldn't be better for.<|eor|><|eols|><|endoftext|> | 69 |
programmingcirclejerk | irqlnotdispatchlevel | geamq3f | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>
> I use excel every once in a while for simple graph making.
Lol no gnuplot<|eor|><|eols|><|endoftext|> | 34 |
programmingcirclejerk | tgbugs | geb37q2 | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>> vim/emacs
This is like saying Jesus/Hitler. Or Coffee/Ebola.<|eor|><|sor|>This is like saying Jesus/Hitler. Or Coffee/Ebola.
Seems like "causing suffering on Africa" is the common denominator.<|eor|><|sor|>> Visits the vim homepage
Yep. This is the most meta jerk I've read all week.<|eor|><|eols|><|endoftext|> | 28 |
programmingcirclejerk | VeganVagiVore | gebd9s4 | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>I can't think of anything you'd do in C# on a daily basis that Rust wouldn't be better for.<|eor|><|sor|>[deleted]<|eor|><|sor|>> reimplementing
Please, all I write in Rust is glue code.
I have a dependency for the async runtime, one for an HTTP client, one for an HTTP server, 3 for tracing and logging, 2 for hashing, 2 versions of the Base64 crate, the futures crate (which is a dependency of the async runtime but I also need it for some stupid reason), the HTTP crate (which is a dependency of the HTTP server, but I also need it for some stupid reason), the crate that makes serialization easy, the crate that makes serialization easy for JSON, the crate that makes serialization easy for MessagePack, the HTML templating crate, the TOML parsing crate, 2 different error handling crates, some kinda concurrent hashmap, a crate for printing the current UTC time in RFC3339 format, and...<|eor|><|eols|><|endoftext|> | 22 |
programmingcirclejerk | rafgro | gearvif | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>True 10xer writes in 1s and 0s, hence the name<|eor|><|eols|><|endoftext|> | 21 |
programmingcirclejerk | monstersgetcreative | geb2gd3 | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>> I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for.
Yes I can't imagine why using a GUI application in which you easily visually represent your data in columns and rows, that you can more easily query and operate on, would be better than not having that, and having to iterate through large data collections yourself with a library for a programming language.<|eor|><|sor|>Why would you use excel when you can just badly reimplement pieces of it every time you need them<|eor|><|eols|><|endoftext|> | 21 |
programmingcirclejerk | tetroxid | geafxtg | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>He had me until emacs, not gonna lie<|eor|><|eols|><|endoftext|> | 20 |
programmingcirclejerk | ProfessorSexyTime | geb09hi | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>> I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for.
Yes I can't imagine why using a GUI application in which you easily visually represent your data in columns and rows, that you can more easily query and operate on, would be better than not having that, and having to iterate through large data collections yourself with a library for a programming language.<|eor|><|eols|><|endoftext|> | 17 |
programmingcirclejerk | NynaevetialMeara | geb0mw9 | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>> vim/emacs
This is like saying Jesus/Hitler. Or Coffee/Ebola.<|eor|><|sor|>This is like saying Jesus/Hitler. Or Coffee/Ebola.
Seems like "causing suffering on Africa" is the common denominator.<|eor|><|sor|>> implying coffee hasn't caused suffering in Africa
Also, emacs is Good actually<|eor|><|sor|>Read again.<|eor|><|eols|><|endoftext|> | 15 |
programmingcirclejerk | silentconfessor | gebezv1 | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>I can't think of anything you'd do in C# on a daily basis that Rust wouldn't be better for.<|eor|><|sor|>[deleted]<|eor|><|sor|>> reimplementing
Please, all I write in Rust is glue code.
I have a dependency for the async runtime, one for an HTTP client, one for an HTTP server, 3 for tracing and logging, 2 for hashing, 2 versions of the Base64 crate, the futures crate (which is a dependency of the async runtime but I also need it for some stupid reason), the HTTP crate (which is a dependency of the HTTP server, but I also need it for some stupid reason), the crate that makes serialization easy, the crate that makes serialization easy for JSON, the crate that makes serialization easy for MessagePack, the HTML templating crate, the TOML parsing crate, 2 different error handling crates, some kinda concurrent hashmap, a crate for printing the current UTC time in RFC3339 format, and...<|eor|><|soopr|>By the way, the version of the HTTP crate used by the server is different from the one you're depending on, which you only realize after spending half an hour trying to fix `expecting http::Thing, got http::Thing`<|eoopr|><|eols|><|endoftext|> | 15 |
programmingcirclejerk | officerthegeek | geatkb8 | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>/uj not much jerk here<|eor|><|sor|>lol lying about uj<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | VeganVagiVore | gebdamg | <|sols|><|sot|>A windows computer is basically a toy... I can't think of anything anybody would do in excel on a daily basis that pandas wouldn't be better for. I can't think of anything you'd do in word on a daily basis that vim/emacs + LaTeX wouldn't be better for.<|eot|><|sol|>https://reddit.com/r/programming/comments/k4ehad/_/ge9g8tg/?context=4<|eol|><|sor|>
> I use excel every once in a while for simple graph making.
Lol no gnuplot<|eor|><|sor|>lol no LibreOffice<|eor|><|eols|><|endoftext|> | 12 |
programmingcirclejerk | ezluckyfreeeeee | izas2n | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|eols|><|endoftext|> | 137 |
programmingcirclejerk | andiconda | g6i40jg | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|eols|><|endoftext|> | 71 |
programmingcirclejerk | BertyLohan | g6ijqae | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|sor|>Fun fact: the plural of octopus actual shouldn't be octopi because it is a greek word not a latin one!
Conversely though, using whatever word is more likely to be understood is almost always the correct thing to do and pedants like me should just stay in the woodwork but I became a programmer to feel better than people so that's what I'm gonna do damnit.<|eor|><|eols|><|endoftext|> | 36 |
programmingcirclejerk | etaionshrd | g6ildjd | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|sor|>Fun fact: the plural of octopus actual shouldn't be octopi because it is a greek word not a latin one!
Conversely though, using whatever word is more likely to be understood is almost always the correct thing to do and pedants like me should just stay in the woodwork but I became a programmer to feel better than people so that's what I'm gonna do damnit.<|eor|><|sor|>Octopussies it is<|eor|><|eols|><|endoftext|> | 35 |
programmingcirclejerk | zetaconvex | g6ijjs8 | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>A computer once beat me at chess. But it was no match for me at kickboxing.<|eor|><|eols|><|endoftext|> | 30 |
programmingcirclejerk | axalon900 | g6i3wbk | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>Good call, octopuses naturally eat rustaceans<|eor|><|eols|><|endoftext|> | 30 |
programmingcirclejerk | muntaxitome | g6ixoa8 | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|sor|>Fun fact: the plural of octopus actual shouldn't be octopi because it is a greek word not a latin one!
Conversely though, using whatever word is more likely to be understood is almost always the correct thing to do and pedants like me should just stay in the woodwork but I became a programmer to feel better than people so that's what I'm gonna do damnit.<|eor|><|sor|>Octopus means 8 feet. If you mean to describe two of those the correct word is dekaxipus (16-feet).
Saying '2 octopusses' is like saying '2 8 feets'. It's ridiculous.<|eor|><|eols|><|endoftext|> | 24 |
programmingcirclejerk | silentconfessor | g6io7h1 | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|sor|>Fun fact: the plural of octopus actual shouldn't be octopi because it is a greek word not a latin one!
Conversely though, using whatever word is more likely to be understood is almost always the correct thing to do and pedants like me should just stay in the woodwork but I became a programmer to feel better than people so that's what I'm gonna do damnit.<|eor|><|sor|>No, octopus is an English word. In English, the plural of "i" is "us", not the other way around.<|eor|><|eols|><|endoftext|> | 23 |
programmingcirclejerk | JameslsaacNeutron | g6ii50g | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>Octopi have about a 3 year turnover rate, making them perfect for startups<|eor|><|eols|><|endoftext|> | 21 |
programmingcirclejerk | officerthegeek | g6i80jh | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>I mean, it thinks with his brainS not his brain. So it would make a shitty programmer<|eor|><|sor|>It's been known for a few years now that we shouldn't write multithreaded applications because of how slow communication between CPU cores is. It's no different with octopi.<|eor|><|eols|><|endoftext|> | 14 |
programmingcirclejerk | Shorttail0 | g6in9ur | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>I mean, it thinks with his brainS not his brain. So it would make a shitty programmer<|eor|><|sor|>It's been known for a few years now that we shouldn't write multithreaded applications because of how slow communication between CPU cores is. It's no different with octopi.<|eor|><|sor|>Octopussies run Erlang so please take that back.<|eor|><|eols|><|endoftext|> | 13 |
programmingcirclejerk | OctagonClock | g6ipgk6 | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|sor|>Fun fact: the plural of octopus actual shouldn't be octopi because it is a greek word not a latin one!
Conversely though, using whatever word is more likely to be understood is almost always the correct thing to do and pedants like me should just stay in the woodwork but I became a programmer to feel better than people so that's what I'm gonna do damnit.<|eor|><|sor|>The plural of octopi is squid.<|eor|><|eols|><|endoftext|> | 12 |
programmingcirclejerk | mizzu704 | g6ipalx | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|sor|>[They're already trying.](https://i.imgur.com/pznqq35.jpg)<|eor|><|eols|><|endoftext|> | 11 |
programmingcirclejerk | etaionshrd | g6ilfmi | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>[His VC](https://imgflip.com/s/meme/Unsettled-Tom.jpg)<|eor|><|sor|>I mean, non-humans have no minimum wage. Some of them will stay if you give them free food and nothing else<|eor|><|eols|><|endoftext|> | 10 |
programmingcirclejerk | camelCaseIsWebScale | g6i2qwl | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>[His VC](https://imgflip.com/s/meme/Unsettled-Tom.jpg)<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | AprilSpektra | g6irkc5 | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>Octopi have about a 3 year turnover rate, making them perfect for startups<|eor|><|sor|>Damn, I couldn't even make it six months as an octopus<|eor|><|eols|><|endoftext|> | 9 |
programmingcirclejerk | lengau | g6j54xi | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|sor|>Fun fact: the plural of octopus actual shouldn't be octopi because it is a greek word not a latin one!
Conversely though, using whatever word is more likely to be understood is almost always the correct thing to do and pedants like me should just stay in the woodwork but I became a programmer to feel better than people so that's what I'm gonna do damnit.<|eor|><|sor|>But using words people don't know or have to think about a bit makes you sound smart, so using 'octopodes' would be perfect for this subreddit!<|eor|><|eols|><|endoftext|> | 8 |
programmingcirclejerk | zetaconvex | g6jvrkw | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>If a room full of monkeys can write shakespeare, then surely a room full of octopi can write a lisp interpreter.<|eor|><|sor|>It only takes one octopus to write code that is indistinguishable from valid Perl, though.<|eor|><|eols|><|endoftext|> | 7 |
programmingcirclejerk | dopefish917 | g6jdim0 | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>Good call, octopuses naturally eat rustaceans<|eor|><|sor|>octopodes<|eor|><|eols|><|endoftext|> | 7 |
programmingcirclejerk | officerthegeek | g6j3rfq | <|sols|><|sot|>If an octopus can beat me at Sokoban, I don't care whether it thinks with its brain or its arms, I would like to hire it as a programmer for my startup.<|eot|><|sol|>https://news.ycombinator.com/item?id=24585366<|eol|><|sor|>I mean, it thinks with his brainS not his brain. So it would make a shitty programmer<|eor|><|sor|>It's been known for a few years now that we shouldn't write multithreaded applications because of how slow communication between CPU cores is. It's no different with octopi.<|eor|><|sor|>What<|eor|><|sor|>It seems your brain is suffering the fate of octopus brains.<|eor|><|eols|><|endoftext|> | 7 |
programmingcirclejerk | cmov | e3fux2 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|eols|><|endoftext|> | 142 |
programmingcirclejerk | stone_henge | f92uf0x | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>O(0) map! all it took was a language that forces developers to think<|eor|><|eols|><|endoftext|> | 88 |
programmingcirclejerk | PrimozDelux | f92zysj | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Hey guys, I wrote a function which runs in O(n) time!
fn O(n: i64): i64 {
O(O(n))
}<|eor|><|sor|>Recursion is considered unidiomatic. Please rewrite it in a for loop so people without a PhD can read your code.<|eor|><|eols|><|endoftext|> | 77 |
programmingcirclejerk | three18ti | f92wff2 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>> IMO it is easier to see how expensive such functions are, if iteration is expressed syntactically.
That's just like, you're _[sic]_ opinion, man.
/uj as opposed to? Wtf is this big brain gopher saying? I'm clearly not 10x yet.<|eor|><|eols|><|endoftext|> | 67 |
programmingcirclejerk | muntoo | f92te39 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Hey guys, I wrote a function which runs in O(n) time!
fn O(n: i64): i64 {
O(O(n))
}<|eor|><|eols|><|endoftext|> | 64 |
programmingcirclejerk | covercash2 | f92y27o | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>> IMO it is easier to see how expensive such functions are, if iteration is expressed syntactically.
That's just like, you're _[sic]_ opinion, man.
/uj as opposed to? Wtf is this big brain gopher saying? I'm clearly not 10x yet.<|eor|><|sor|>any functionality not present in go is not necessary.<|eor|><|eols|><|endoftext|> | 61 |
programmingcirclejerk | orgulodfan82 | f933hd0 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Guys I have just proven P=NP:
(arg) {
return;
solve_sudoku(arg);
}<|eor|><|eols|><|endoftext|> | 57 |
programmingcirclejerk | wheypoint | f93a3u2 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>O(0) map! all it took was a language that forces developers to think<|eor|><|sor|>The key point here is our programmers are Gophers, theyre not researchers. Theyre typically, fairly young, fresh out of school, probably learned Java, maybe learned C or C++, probably learned Python. Theyre not capable of understanding a brilliant language but we want to use them to build good software. So, the language that we give them has to be easy for them to understand and easy to adopt<|eor|><|eols|><|endoftext|> | 50 |
programmingcirclejerk | BaldLife | f92wq6c | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>what is unreachable code :S<|eor|><|eols|><|endoftext|> | 42 |
programmingcirclejerk | muntoo | f939jau | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Hey guys, I wrote a function which runs in O(n) time!
fn O(n: i64): i64 {
O(O(n))
}<|eor|><|sor|>Recursion is considered unidiomatic. Please rewrite it in a for loop so people without a PhD can read your code.<|eor|><|sor|>All recursive functions can be trivially converted to 0.1xer functions. This:
fn O(n: i64): i64 { // instruction 0
let n = O(n); // instruction 1
let n = O(n); // instruction 2
n
}
becomes:
fn O(n: i64): i64 {
let mut result: i64; // result of previous func call
let stack = Vec::new(); // instruction/call stack
stack.push((0, n, None));
while let &(instruction, arg, local) = stack.pop() {
match instruction {
0 => { // Call O on n
stack.push((1, arg, None));
stack.push((0, arg, None));
},
1 => { // Call O on result of O(n)
stack.push((2, arg, Some(result)));
stack.push((0, result, None));
},
2 => { // Return result of O(O(n))
// <unjerk>result = undefined;</unjerk>
},
}
result
}<|eor|><|eols|><|endoftext|> | 40 |
programmingcirclejerk | 0xF013 | f92xml3 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Hey guys, I wrote a function which runs in O(n) time!
fn O(n: i64): i64 {
O(O(n))
}<|eor|><|sor|>`[2, 145, 34, 553, 3, 55].map(x => setTimeout(() => console.log(x), x));`<|eor|><|eols|><|endoftext|> | 39 |
programmingcirclejerk | jess-sch | f9385n7 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Guys I have just proven P=NP:
(arg) {
return;
solve_sudoku(arg);
}<|eor|><|sor|>>proven P=NP
more like proven N=1<|eor|><|eols|><|endoftext|> | 32 |
programmingcirclejerk | wheypoint | f939tww | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>> IMO it is easier to see how expensive such functions are, if iteration is expressed syntactically.
That's just like, you're _[sic]_ opinion, man.
/uj as opposed to? Wtf is this big brain gopher saying? I'm clearly not 10x yet.<|eor|><|sor|>any functionality not present in go is not necessary.<|eor|><|sor|>Generic<lol, no>()<|eor|><|eols|><|endoftext|> | 32 |
programmingcirclejerk | cmov | f93bds4 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>> Syntax does make evaluating the complexity of a function easier. To prove that, feel free to try and evaluate the complexity of this program:
if err != nl {
return err, nil
}<|eor|><|soopr|>It's three lines with no "for", so O(3).<|eoopr|><|eols|><|endoftext|> | 30 |
programmingcirclejerk | do_some_fucking_work | f930k0d | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Hey guys, I wrote a function which runs in O(n) time!
fn O(n: i64): i64 {
O(O(n))
}<|eor|><|sor|>`[2, 145, 34, 553, 3, 55].map(x => setTimeout(() => console.log(x), x));`<|eor|><|sor|>Did you just solve the sorting problem in O(n) time?<|eor|><|eols|><|endoftext|> | 29 |
programmingcirclejerk | wheypoint | f93ai68 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>> Syntax does make evaluating the complexity of a function easier. To prove that, feel free to try and evaluate the complexity of this program:
if err != nl {
return err, nil
}<|eor|><|eols|><|endoftext|> | 26 |
programmingcirclejerk | categorical-girl | f9394rp | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Hey guys, I wrote a function which runs in O(n) time!
fn O(n: i64): i64 {
O(O(n))
}<|eor|><|sor|>`[2, 145, 34, 553, 3, 55].map(x => setTimeout(() => console.log(x), x));`<|eor|><|sor|>Did you just solve the sorting problem in O(n) time?<|eor|><|sor|>/uj sorting integers can be done in O(n) with radix sort/counting sort<|eor|><|eols|><|endoftext|> | 22 |
programmingcirclejerk | samnardoni | f93oqf6 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Guys I have just proven P=NP:
(arg) {
return;
solve_sudoku(arg);
}<|eor|><|sor|>Gopher here. N=1 or P=0.<|eor|><|eols|><|endoftext|> | 19 |
programmingcirclejerk | SilensAngelusNex | f94746y | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>> IMO it is easier to see how expensive such functions are, if iteration is expressed syntactically.
That's just like, you're _[sic]_ opinion, man.
/uj as opposed to? Wtf is this big brain gopher saying? I'm clearly not 10x yet.<|eor|><|sor|>any functionality not present in go is not necessary.<|eor|><|sor|>Generic<lol, no>()<|eor|><|sor|> error: chained comparison operators require parentheses
--> src/main.rs:1:8
|
1 | Generic<lol, no>()
| ^^^^^^^^^
= help: use `::<...>` instead of `<...>` if you meant to specify type arguments
= help: or use `(...)` if you meant to specify fn arguments<|eor|><|eols|><|endoftext|> | 18 |
programmingcirclejerk | wheypoint | f93abg9 | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Hey guys, I wrote a function which runs in O(n) time!
fn O(n: i64): i64 {
O(O(n))
}<|eor|><|sor|>Recursion is considered unidiomatic. Please rewrite it in a for loop so people without a PhD can read your code.<|eor|><|sor|>All recursive functions can be trivially converted to 0.1xer functions. This:
fn O(n: i64): i64 { // instruction 0
let n = O(n); // instruction 1
let n = O(n); // instruction 2
n
}
becomes:
fn O(n: i64): i64 {
let mut result: i64; // result of previous func call
let stack = Vec::new(); // instruction/call stack
stack.push((0, n, None));
while let &(instruction, arg, local) = stack.pop() {
match instruction {
0 => { // Call O on n
stack.push((1, arg, None));
stack.push((0, arg, None));
},
1 => { // Call O on result of O(n)
stack.push((2, arg, Some(result)));
stack.push((0, result, None));
},
2 => { // Return result of O(O(n))
// <unjerk>result = undefined;</unjerk>
},
}
result
}<|eor|><|sor|>How exciting! How exciting!<|eor|><|eols|><|endoftext|> | 18 |
programmingcirclejerk | cmov | f93b6bo | <|sols|><|sot|>Gopher writes a function which calls map() but runs in O(1)<|eot|><|sol|>https://old.reddit.com/r/golang/comments/e06rou/will_map_filter_and_reduce_be_added_with_future/f8kl2bu/<|eol|><|sor|>Hey guys, I wrote a function which runs in O(n) time!
fn O(n: i64): i64 {
O(O(n))
}<|eor|><|sor|>Recursion is considered unidiomatic. Please rewrite it in a for loop so people without a PhD can read your code.<|eor|><|sor|>All recursive functions can be trivially converted to 0.1xer functions. This:
fn O(n: i64): i64 { // instruction 0
let n = O(n); // instruction 1
let n = O(n); // instruction 2
n
}
becomes:
fn O(n: i64): i64 {
let mut result: i64; // result of previous func call
let stack = Vec::new(); // instruction/call stack
stack.push((0, n, None));
while let &(instruction, arg, local) = stack.pop() {
match instruction {
0 => { // Call O on n
stack.push((1, arg, None));
stack.push((0, arg, None));
},
1 => { // Call O on result of O(n)
stack.push((2, arg, Some(result)));
stack.push((0, result, None));
},
2 => { // Return result of O(O(n))
// <unjerk>result = undefined;</unjerk>
},
}
result
}<|eor|><|soopr|>lol not using enum<|eoopr|><|eols|><|endoftext|> | 17 |
programmingcirclejerk | MagicalVagina | dgo6tq | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|eols|><|endoftext|> | 138 |
programmingcirclejerk | Busti | f3duwyj | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>So basically a readme in HTML?
Time does indeed flow backwards.<|eor|><|eols|><|endoftext|> | 114 |
programmingcirclejerk | orangereds | f3dx5wj | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>I, too, am disappointed by the lack of boilerplate and package management involved in writing a Readme.<|eor|><|eols|><|endoftext|> | 74 |
programmingcirclejerk | McGlockenshire | f3dypjg | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>Be sure to hit the Other Discussions tabs for such quotes from the author as
> About HTML, I would have gone with HTML but I would lose the benefit of having shareable components, that's why I went with JSX instead ( and let's be real, who uses HTML these days anyways )<|eor|><|eols|><|endoftext|> | 56 |
programmingcirclejerk | F54280 | f3e9y43 | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>I, too, am disappointed by the lack of boilerplate and package management involved in writing a Readme.<|eor|><|sor|>Look at [the source of the README.jsx](https://github.com/solidsnail/readme-jsx/blob/master/README.jsx) before complaining. Who doesnt want to start his READMEs by ``const React = require("react");``?
It was about time that someone made READMEs webscale. And all decent projects already have already react as a dependency.<|eor|><|eols|><|endoftext|> | 44 |
programmingcirclejerk | silentrunningfan | f3doiup | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>> Create beautiful HD readme content with ease
What is stylesheet :S<|eor|><|eols|><|endoftext|> | 33 |
programmingcirclejerk | SpoliatorX | f3e9yof | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>So basically a readme in HTML?
Time does indeed flow backwards.<|eor|><|sor|>There's a fun new trend amongst ~~talentless hacks~~ React Devs where they put the CSS in the JSX. It's like using inline styles on everything but "component based" so somehow not a really fucking stupid idea <|eor|><|eols|><|endoftext|> | 32 |
programmingcirclejerk | m50d | f3efvmy | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>So basically a readme in HTML?
Time does indeed flow backwards.<|eor|><|sor|>There's a fun new trend amongst ~~talentless hacks~~ React Devs where they put the CSS in the JSX. It's like using inline styles on everything but "component based" so somehow not a really fucking stupid idea <|eor|><|sor|>I'm still torn on what I think about the whole CSS in JSX thing. I kind of get that the concept is all about having your components exist as fully independent chunks of code where you can edit all aspects of a component in one place, but I still see way too much value in keeping your styles nicely organized on their own in css (or .scss) files.<|eor|><|sor|>It's time to admit that CSS is a failure and go back to inline styling (which is what this is). Remember the CSS zen garden? How many real sites do you see doing something like that? Mobile sites are theoretically the perfect use case for CSS but I've literally never seen a mobile site use the same HTML with different CSS - it's much easier to just generate different HTML from the same data.
Spooky-action-at-a-distance selectors break as soon as you do anything unexpected. The syntax is weird. The language is simultaneously so complex that no-one can predict its behaviour and so simplistic that you can't even do arithmetic in it. CSS is a fractal of bad design and I'm amazed it's held on this long.<|eor|><|eols|><|endoftext|> | 32 |
programmingcirclejerk | bitfxxker | f3ee18l | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>So basically a readme in HTML?
Time does indeed flow backwards.<|eor|><|sor|>From the w3sk00l react jsx manual:
>JSX allows us to write HTML elements in JavaScript and place them in the DOM without any createElement() and/or appendChild() methods.
I can hear the plates boiling!<|eor|><|eols|><|endoftext|> | 31 |
programmingcirclejerk | MagicalVagina | f3e0o04 | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>Be sure to hit the Other Discussions tabs for such quotes from the author as
> About HTML, I would have gone with HTML but I would lose the benefit of having shareable components, that's why I went with JSX instead ( and let's be real, who uses HTML these days anyways )<|eor|><|soopr|>Let's be real. HTML is so 2009.<|eoopr|><|eols|><|endoftext|> | 31 |
programmingcirclejerk | fp_weenie | f3erv90 | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>> Create beautiful HD readme content with ease
What is stylesheet :S<|eor|><|sor|>The best part is that ReadMe's don't even need to be beautiful. They just need to be clean and easy to read. Who really needs anything else?<|eor|><|sor|>Also, the pretty headers are images. You cant use ctrl-f to find a README heading.<|eor|><|sor|>Hey, it may not be accessible, but at least it looks like shit.<|eor|><|eols|><|endoftext|> | 30 |
programmingcirclejerk | imatree | f3edgvf | <|sols|><|sot|>Readme in JSX. Because Markdown is too complex.<|eot|><|sol|>https://github.com/solidsnail/readme-jsx<|eol|><|sor|>Be sure to hit the Other Discussions tabs for such quotes from the author as
> About HTML, I would have gone with HTML but I would lose the benefit of having shareable components, that's why I went with JSX instead ( and let's be real, who uses HTML these days anyways )<|eor|><|sor|>>let's be real, who uses HTML these days anyways
MODS FLAIR PLS<|eor|><|eols|><|endoftext|> | 28 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.