archived stringclasses 2 values | author stringlengths 3 20 | author_fullname stringlengths 4 12 ⌀ | body stringlengths 0 22.5k | comment_type stringclasses 1 value | controversiality stringclasses 2 values | created_utc stringlengths 10 10 | edited stringlengths 4 12 | gilded stringclasses 7 values | id stringlengths 1 7 | link_id stringlengths 7 10 | locked stringclasses 2 values | name stringlengths 4 10 ⌀ | parent_id stringlengths 5 10 | permalink stringlengths 41 91 ⌀ | retrieved_on stringlengths 10 10 ⌀ | score stringlengths 1 4 | subreddit_id stringclasses 1 value | subreddit_name_prefixed stringclasses 1 value | subreddit_type stringclasses 1 value | total_awards_received stringclasses 19 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
False | patrick_____bateman | t2_9tv5f | What's that one thing?
| null | 0 | 1546094158 | False | 0 | ecsy2x9 | t3_aaco1d | null | null | t1_ecskylm | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ecsy2x9/ | 1548224174 | 1 | t5_2fwo | r/programming | public | null |
False | welkam | t2_o4k0x | It would be possible to revive DMC compiler. It is open sourced and still receiving commits [https://github.com/DigitalMars/Compiler](https://github.com/DigitalMars/Compiler)
It only lacks new c++ features and because it shares backend with D language I am looking on improving performance of it. | null | 0 | 1546094181 | False | 0 | ecsy3lu | t3_aac4hg | null | null | t1_ecrn7c1 | /r/programming/comments/aac4hg/modern_c_lamentations/ecsy3lu/ | 1548224182 | 1 | t5_2fwo | r/programming | public | null |
False | bloody-albatross | t2_cdjk3 | There is an API mode for Laravel. It is still useful for routing, ORM, migrations, structuring code in controllers, middelware infrastructure etc. There are integrations with React and Vue for Laravel, too.
I'm not a Laravel fan or something, just want to check that I haven't missed something. | null | 0 | 1546094354 | False | 0 | ecsy8vw | t3_a9psuk | null | null | t1_ecscxt2 | /r/programming/comments/a9psuk/javascript_form_data_validation_with_laravel_rules/ecsy8vw/ | 1548224247 | 1 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [deleted] | null | 0 | 1546094393 | False | 0 | ecsya4d | t3_aai5ap | null | null | t1_ecsodsm | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ecsya4d/ | 1548224263 | 2 | t5_2fwo | r/programming | public | null |
False | eskimoFry | t2_gxd2g | Network programming L2 and above.. But unfortunately demand is in L1 and embedded SDK development | null | 0 | 1546094663 | False | 0 | ecsyih1 | t3_aaco1d | null | null | t1_ecsy2x9 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ecsyih1/ | 1548224365 | 1 | t5_2fwo | r/programming | public | null |
False | PorkChop007 | t2_4c7ynac | I'm not entirely against using random tweets as inspiration to write an article. This, however, was a series of tweets with some comment upon them, something that could be done without leaving Twitter just by @ them. | null | 0 | 1546094841 | False | 0 | ecsynye | t3_aakiko | null | null | t1_ecsrajn | /r/programming/comments/aakiko/on_guishaming_and_a_mountain_of_hot_takes/ecsynye/ | 1548224464 | 5 | t5_2fwo | r/programming | public | null |
False | foBrowsing | t2_lxd4j | I'm not sure your explanation for Applicative is very helpful. Things like:
> you apply a function to its content
Are more apt to describe Functor, not Applicative. Similarly for your explanations for list and tree:
> you can apply a function to each element but the list stays the same size
> you can apply a function to each node in the tree
These describe `fmap`, not Applicative. The first of these is incorrect, also. `<*>` absolutely does change the length of the lists involved:
>>> [not,id] <*> [True,False,True]
[False,True,False,True,False,True]
Applicative is all about letting you combine things. | null | 0 | 1546095182 | False | 0 | ecsyyih | t3_aai5ap | null | null | t1_ecso2hr | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ecsyyih/ | 1548224594 | 5 | t5_2fwo | r/programming | public | null |
False | YM_Industries | t2_70ork | To me it doesn't look recognisable as fire, it looks more like weird clouds. The Doom onenis unmistakeable. | null | 0 | 1546095219 | False | 0 | ecsyzop | t3_aajb7r | null | null | t1_ecsupnl | /r/programming/comments/aajb7r/how_doom_fire_was_done/ecsyzop/ | 1548224608 | 37 | t5_2fwo | r/programming | public | null |
False | DJRBuckingham | t2_ywqtq | I think this whole committee/implementer divide is little more than an excuse.
In many cases, the committee members and implementers are one-and-the-same person. Often these language extensions take the form of a library (as covered in the linked article), and the people proposing the standard are also providing the reference implementation, which gets dropped in verbatim. Then you have the argument that a lot of work goes into ensuring the "zero cost abstractions" mantra is upheld, because they know if a new feature produced sub-optimal release code it would be avoided by the community.
All I am say is to widen that mantra from "optimised runtime performance" to "optimised and un-optimised runtime performance, and compile times". If that is too much work, give us the telemetry and tools to debug the issues ourselves, we'll quickly figure out which features to ban in our codebases.
As for making code faster without optimisations, there are diminishing returns, as with most things. I expect code to be slower in debug. When I write C code it is anything from 2-3x slower in debug than release. But when I write modern C++ code, it is anything from 10-200x slower in debug than release. This is because code isn't written with debug performance in mind, it is waved away and ignored because "it'll all get compiled out in a release build". Debug performance should be a concern, something to weigh pros-and-cons on. Sometimes it will be worth the performance hit to get the verbosity that is burnt out in release, other times it is not. At the moment, it isn't even considered.
As for general C++ being slow to compile, I just have to disagree. Elsewhere in this chain there is a game developer who has a 500k LOC project that compiles in 70 seconds, and I think he could make it quicker by doing a unity build also. There are multiple orders of magnitude gains on the table to be had by avoiding the pathological style of code that template meta-programming and the standard espouse. One of my projects is ~100k LOC and full rebuilds in under two seconds; that is 50k lines of code compiled per second per core. UE4 on the other hand, a bigger project for sure, has a compile speed of about 60 lines per second per core. C++ compilation does not have to be slow, we are making it slow with our programming practises. | null | 0 | 1546095298 | False | 0 | ecsz28z | t3_aac4hg | null | null | t1_ecsu8xm | /r/programming/comments/aac4hg/modern_c_lamentations/ecsz28z/ | 1548224640 | 10 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [deleted] | null | 0 | 1546095431 | False | 0 | ecsz6zk | t3_aaco1d | null | null | t1_ecslykw | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ecsz6zk/ | 1548224699 | 1 | t5_2fwo | r/programming | public | null |
False | RasterTragedy | t2_zrkyg | I mean, matrix multiplication is nigh-pathological. The base algorithm is O(n³), and naïve matrix storage leaves your cache sobbing while it scrambles to load one of the input matrices. You gotta get deep into math shit to get matrix multiplication down to O( n^2.x ), and you've gotta get some fancy storage formats to feed the damn thing anyway.
Matrix multiplication is so obnoxious that we have dedicated hardware for it (GPUs). | null | 0 | 1546095442 | False | 0 | ecsz7f1 | t3_aajb7r | null | null | t1_ecsv95a | /r/programming/comments/aajb7r/how_doom_fire_was_done/ecsz7f1/ | 1548224703 | 55 | t5_2fwo | r/programming | public | null |
False | welkam | t2_o4k0x | Warp a C preprocessor is written in D by one person and it uses GC and is/was faster 10-40% than GCC\`s preprocessor. I find that GC is such a huge distraction when talking about performance that other more important things are never discussed.
[Source](https://code.fb.com/open-source/under-the-hood-warp-a-fast-c-and-c-preprocessor/) | null | 0 | 1546095549 | False | 0 | ecszb9u | t3_aac4hg | null | null | t1_ecroylj | /r/programming/comments/aac4hg/modern_c_lamentations/ecszb9u/ | 1548224751 | 2 | t5_2fwo | r/programming | public | null |
False | brian_1970 | t2_ti45c | A monad is a man with only 1 gonad | null | 1 | 1546095600 | False | 0 | ecszd5m | t3_aai5ap | null | null | t3_aai5ap | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ecszd5m/ | 1548224775 | 4 | t5_2fwo | r/programming | public | null |
False | airflow_matt | t2_meh1h | Well, to be fair, as I mentioned only about 250kloc is c++, the other \~220k is C, which is of course blazingly fast to compile. Still night and day difference.
To give you some example of how concise our headers are - here's [web socket](https://pastebin.com/x1CtTtgS), [http(s) client](https://pastebin.com/aBS9V44c) (\~300loc), [json](https://pastebin.com/vZV5GGMw). The json one might look a bit misleading since it relies on our Value variant type, but that itself is only about [800loc](https://pastebin.com/mnBUgT6C), and also used for other things such as [msgpack](https://pastebin.com/deeY7nGR) or property list.
I can imaging code like this being frowned upon as not being modern c++, and many of indirect function calls could be removed by templatization, but at what cost? None of this code is likely to be a hotspot in our project, and if it turns out to be, it can always be optimized. But the productivity gains are huge. The code is straighforward, easy to read, debuggable, and compiles fast. | null | 0 | 1546095619 | False | 0 | ecszdue | t3_aac4hg | null | null | t1_ecsxqmv | /r/programming/comments/aac4hg/modern_c_lamentations/ecszdue/ | 1548224783 | 3 | t5_2fwo | r/programming | public | null |
False | richraid21 | t2_pgck6 | Cool proof of concept.
Doesn't protect against malicious post-install scripts but I suppose it's a step in the right direction. | null | 0 | 1546095664 | False | 0 | ecszfj1 | t3_aakn4q | null | null | t3_aakn4q | /r/programming/comments/aakn4q/introducing_nodesecurity_the_easiest_way_to/ecszfj1/ | 1548224804 | 6 | t5_2fwo | r/programming | public | null |
False | bdtddt | t2_x8et0 | Those things should already be well understood by anyone wanting to learn monads, they’re elementary concepts for a modern programmer. | null | 1 | 1546095725 | False | 0 | ecszhts | t3_aai5ap | null | null | t1_ecsfuii | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ecszhts/ | 1548224832 | -4 | t5_2fwo | r/programming | public | null |
False | tonefart | t2_ywdx0 | You can do API without using Laravel. Laravel is just backend bloatware that is trying to be relevant in today's microservices oriented architecture. I cannot see any reason to use ORM, or server side frameworks when PDO with PHP is enough. Anything else is just over-engineering and bloating up server side code. Leave the heavy duty UI stuff to the front end side frameworks. Keep the server code clean, simple and avoid CakePHP, Yii2, Laravel, Symfony and the likes. There is no real reason to use php frameworks anymore other than for maintaining obsolete MVC pattern apps. | null | 0 | 1546095762 | False | 0 | ecszj4t | t3_a9psuk | null | null | t1_ecsy8vw | /r/programming/comments/a9psuk/javascript_form_data_validation_with_laravel_rules/ecszj4t/ | 1548224848 | 1 | t5_2fwo | r/programming | public | null |
False | bdtddt | t2_x8et0 | So many of the ignoramuses on that Github issue should feel truly ashamed of themselves. What an horrifically poor show, they made things worse due to their own ignorance and inability to accept new ideas. | null | 0 | 1546095869 | False | 0 | ecszn4j | t3_aai5ap | null | null | t1_ecswocv | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ecszn4j/ | 1548224897 | 13 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [deleted] | null | 0 | 1546095953 | False | 0 | ecszqbb | t3_aac4hg | null | null | t1_ecsincj | /r/programming/comments/aac4hg/modern_c_lamentations/ecszqbb/ | 1548224936 | 1 | t5_2fwo | r/programming | public | null |
False | lobster_johnson | t2_36b2i | Just to be clear, I wasn't criticizing it! I think that even without coroutines and standard ranges it could be a useful library. Looks easier to read and reason about than the official Ranges spec, too. | null | 0 | 1546095954 | False | 0 | ecszqdj | t3_aach46 | null | null | t1_ecsktwf | /r/programming/comments/aach46/lazy_code_a_c_header_only_lib_what_if_you_could/ecszqdj/ | 1548224937 | 2 | t5_2fwo | r/programming | public | null |
False | shinazueli | t2_dprsa | Nothing will ever top M$ being 20 years behind C standards and not being able to initialize in a for loop until like 2014. Ever. | null | 0 | 1546095956 | False | 0 | ecszqgv | t3_aac4hg | null | null | t1_ecsiw8n | /r/programming/comments/aac4hg/modern_c_lamentations/ecszqgv/ | 1548224938 | 1 | t5_2fwo | r/programming | public | null |
False | shawwwn | t2_12nqdn6d | >
The whole solution, the “web stack”, is wrong. The same thing could be done faster and more efficient easily—there is just so much wasted potential. Time to admit that and start over.
It sounds like programmers would say the same thing about human evolution. | null | 0 | 1546096028 | False | 0 | ecszt4e | t3_aalgpq | null | null | t3_aalgpq | /r/programming/comments/aalgpq/it_is_fast_or_it_is_wrong/ecszt4e/ | 1548224971 | 2 | t5_2fwo | r/programming | public | null |
False | welkam | t2_o4k0x | I would not call Haskell a C++ replacment. Rust can be C++ replacement in many cases but I dont think it should be used in game dev. Most games that ship today are broken on release so anything that can reduce development time should be preferred. Also poor Nim never gets a mention. | null | 0 | 1546096244 | False | 0 | ect01hr | t3_aac4hg | null | null | t1_ecstg09 | /r/programming/comments/aac4hg/modern_c_lamentations/ect01hr/ | 1548225105 | 9 | t5_2fwo | r/programming | public | null |
False | Occivink | t2_53r1h | That's all well and good, but tell me that the example I posted is not surprising, if not downright dangerous.
>So you're now seeing Fish improving its POSIX compliance
That's never been a goal for fish. | null | 0 | 1546096259 | False | 0 | ect024h | t3_aabai1 | null | null | t1_ecsuvuw | /r/programming/comments/aabai1/fish_shell_30/ect024h/ | 1548225112 | 3 | t5_2fwo | r/programming | public | null |
False | dhruvrajvanshi | t2_kji30 | You can't use python for everything.
Try writing an os in Python.
That being said, a higher level language is a better choice for most use cases. That's why I feel iffy about people writing things in Rust just for the sake of it. GC makes a lot of stuff easier. | null | 0 | 1546096440 | False | 0 | ect091t | t3_aac4hg | null | null | t1_ecs1a2f | /r/programming/comments/aac4hg/modern_c_lamentations/ect091t/ | 1548225198 | 2 | t5_2fwo | r/programming | public | null |
False | v_fv | t2_nri6r | > What is a monad?
An indivisible building element of the universe, acting in a pre-established, harmonious hierarchy with other monads.
> What problems that people have do monads solve?
The mind-body problem.
Change my mind!
By the way, I like Professor Hutton's point that if we know the proper term for a thing, we should use that term. Clearly, _monad_ is the best possible name. For anything. | null | 0 | 1546096450 | False | 0 | ect09en | t3_aai5ap | null | null | t3_aai5ap | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ect09en/ | 1548225202 | 4 | t5_2fwo | r/programming | public | null |
False | Fiennes | t2_4ddzc | You should give Monogame a try. | null | 0 | 1546096501 | False | 0 | ect0bc9 | t3_aajb7r | null | null | t1_ecspvls | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect0bc9/ | 1548225226 | 3 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | I’m on the other side now (doing interviews) and I can assure you we don’t hire people who fail the interview regardless of their open source credentials. | null | 0 | 1546096594 | False | 0 | ect0ex6 | t3_aaco1d | null | null | t1_ecschu2 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect0ex6/ | 1548225270 | 8 | t5_2fwo | r/programming | public | null |
False | mr_birkenblatt | t2_d7qfg | true. hmm, that makes it less elegant :/ Functor doesn't have a way to wrap things.
also, yeah, I was thinking of `fmap`.
however, about the length change. I think that was formulated a bit unclear. with `<*>` you cannot *arbitrarily* change the structure. when combining two functions over a list like in your example you get double the list length. my point was that the function cannot decide whether there will be more or fewer elements
EDIT: you can still use `Applicative` to explain it this way | null | 0 | 1546096621 | 1546097773 | 0 | ect0fx1 | t3_aai5ap | null | null | t1_ecsyyih | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ect0fx1/ | 1548225282 | 1 | t5_2fwo | r/programming | public | null |
False | RedUser03 | t2_56ozu | The difference between engine programming and gameplay programming.
To be fair, Unity is great in that it allows you to focus on building *the game* and not *the engine*. Game development used to always require both but not anymore with Unity, Unreal, Godot, etc. | null | 0 | 1546096650 | False | 0 | ect0gz6 | t3_aajb7r | null | null | t1_ecsjz8t | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect0gz6/ | 1548225297 | 25 | t5_2fwo | r/programming | public | null |
False | qzrt | t2_175xbf | Well anything is an excuse if you want to get down to describing what a problem is. Do you think Clang and GCC do optimization in the same way? What about MSVC? How are you going to guarantee that code written in every single C++ compiler is optimized the same way to ensure it works, that it compiles fast and that the code generated also runs fast. There's no way to enforce that, committee or no committee. I'm not saying it's impossible, but C++98 already had compiling time problems. If you started with a new language and designed it with that in mind you can do it. But if you started with C++98 and went forward, there's already features there that would need to be removed/reinvented in order to ensure that C++ compiled fast. One of the top priorities of the committee is backwards compatibility, as I think it is with virtually every language. You can see what happens when backwards compatibility is broken, look at python 2/3.
But they don't even guarantee optimized runtime performance. MSVC's std::cout runtime performance is absolute garbage. All the standard library is is an interface and a few guarantees about the implementation. It doesn't actually go into detail how it is implemented. I think GCC C++ std library has an optimization where it can store a std::string in memory. So most std::string's are 2 variables a pointer and a size_t right. So you can fit a 16-byte string in place rather than allocating memory on the heap. This is a runtime optimization that is not defined the spec and the spec is so loosely defined that you can implement this behavior and still conform to it.
Yah some C++ features like lambdas rely on it. Especially when passing one to a template. It's great when you have optimization enabled it can be optimized out and generate code as if it wasn't a lambda but that's just the nature of lambdas. I don't see how you can add that feature and not have a debug build perform poorly. I think lambdas are a useful feature, I'd rather have them than not have them.
Of course what you use with C++ depends on what is going to be fast and slow. If you write in what is effectively C code, then you are going to get the performance of C for compiling. I've seen people write C code in C++, right down to using macros to use arrays. If you wanted to use an array you had to define a macro somewhere with that type to be able to have the functions defined with that specific type. I'm all for improving compile time speed but I'm not willing to go that fair to lose those features. What it comes down to with templates, is they started out as one thing and over time they realized the potential that it held and it turned into something else entirely. C++ is slow to compile because of the design of the language, because of namespaces, because of macros, along with templates, all of it adds up. There is no fixing it without breaking existing code. That is to say, if you want a faster compiling language with templates similar to C++, then you are going to have to find another language. Because C++ can't be fixed, the design of the language the features it chose don't mesh well together and cause the long compile times. All of this and you also have to do forward declaring and get slower compiler times than a language that doesn't. The only thing keeping C++ alive is just how much code is already written in it. | null | 0 | 1546096652 | 1546097427 | 0 | ect0h2c | t3_aac4hg | null | null | t1_ecsz28z | /r/programming/comments/aac4hg/modern_c_lamentations/ect0h2c/ | 1548225298 | 4 | t5_2fwo | r/programming | public | null |
False | johnjannotti | t2_26zs0 | This is tripe. The author knows it's tripe. He makes the proper counter argument in his own work.
| null | 0 | 1546096657 | False | 0 | ect0h8k | t3_aalgpq | null | null | t3_aalgpq | /r/programming/comments/aalgpq/it_is_fast_or_it_is_wrong/ect0h8k/ | 1548225300 | 11 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [deleted] | null | 0 | 1546096728 | 1546910042 | 0 | ect0jwh | t3_aajb7r | null | null | t1_ecsopcl | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect0jwh/ | 1548225333 | -13 | t5_2fwo | r/programming | public | null |
False | korkskrue | t2_7dbug | Yeah, I see your point, since both mobile and Frontend typically stop at the backend API layer. I think it might have to do with how much context you need to be an effective frontend developer? Needing to know about HTML, modern JS, the DOM, browser compatibility, amongst other things makes the role a bit more specialized than mobile (from my limited experience doing Android dev). There is also more hardware interaction in mobile (accelerometer, camera, etc) so that might be another reason why it's treated similar to general SWE? Either way, I feel mobile positions should be split off from the main SWE pipeline. | null | 0 | 1546096785 | False | 0 | ect0lza | t3_aaco1d | null | null | t1_ecsmxnj | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect0lza/ | 1548225359 | 1 | t5_2fwo | r/programming | public | null |
False | shellac | t2_1oog | I think your java version is a bit clunky. How about:
var triples = IntStream.range(1, Integer.MAX_VALUE).boxed()
.flatMap(z -> IntStream.range(1, z).mapToObj(x -> new Tuple(x, -1, z)))
.flatMap(t -> IntStream.range(1, t.x).mapToObj(y -> new Tuple(t.x, y, t.z)))
.filter(t -> t.z * t.z == t.x * t.x + t.y * t.y);
triples.limit(100).forEach(t ->
System.out.println(String.format("(%d,%d,%d)", t.x, t.y, t.z)));
| null | 0 | 1546096942 | False | 0 | ect0rvp | t3_aac4hg | null | null | t1_ecsejdm | /r/programming/comments/aac4hg/modern_c_lamentations/ect0rvp/ | 1548225431 | 3 | t5_2fwo | r/programming | public | null |
False | burnblue | t2_33e7x | That point read like he was just being humble about what he can do with Python. Like he's just missing deep knowledge about how the language works. | null | 0 | 1546097091 | False | 0 | ect0xlm | t3_aaco1d | null | null | t1_ecrf8qc | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect0xlm/ | 1548225501 | 1 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | Author checking in.
Before client-side JS apps I worked on .NET desktop (Windows Forms), server (ASP .NET MVC, NHibernate, Entity Framework), and mobile (Xamarin/MonoTouch, Rx) apps. | null | 0 | 1546097164 | False | 0 | ect10jd | t3_aaco1d | null | null | t1_ecs7z7q | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect10jd/ | 1548225538 | 16 | t5_2fwo | r/programming | public | null |
False | fieldstrength | t2_12it2v | A big motivation is you get a lot of standardized intuition and machinery that is applicable in a wide array of contexts, and easy to adopt in a new context you've never seen before. Whenever I pick up a new Haskell library there is usually some central types implementing the `Functor`, `Applicative`, `Monad` interface hierarchy. Together with the package's basic type signatures, this usually makes it pretty clear how to use, at least in broad strokes.
This means not only do I know a bunch of standard functions that are applicable in these different contexts with mostly obvious semantics, but also the laws governing their implementations provide a basic sanity check. The monad (functor, etc) laws are simple and seem 'obvious' at first glance, but when you consider what they mean in specific cases, a violation of these laws always corresponds to some violation of your intuition of how such an interface ought to work.
After working with these for some time, these sorts of considerations give one confidence that Monad/Functor are a correct, sound, useful interface for general computational contexts.
Also, an ecosystem like Haskell's gets even more mileage out of the monad interface because many monads are made to be combined with many others. Its quite nice to be able to build up your own computational contexts by selecting combinations of monadic effects you want in a fine-grained way (some state here, some error handling there, some database access here, some configuration there). | null | 0 | 1546097232 | False | 0 | ect13ag | t3_aai5ap | null | null | t1_ecsqy4s | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ect13ag/ | 1548225572 | 12 | t5_2fwo | r/programming | public | null |
False | burnblue | t2_33e7x | Gretzky would know how to use Flexbox though.
I think this and some other things on his list are things he does understand how they work but has to look up their syntax and rules everytime so he doesn't "know" them off top. | null | 0 | 1546097275 | False | 0 | ect151n | t3_aaco1d | null | null | t1_ecs7z7q | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect151n/ | 1548225622 | 1 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [deleted] | null | 0 | 1546097295 | False | 0 | ect15vh | t3_aac4hg | null | null | t1_ecqrdob | /r/programming/comments/aac4hg/modern_c_lamentations/ect15vh/ | 1548225633 | 1 | t5_2fwo | r/programming | public | null |
False | korkskrue | t2_7dbug | Flow is used in place of typescript at FB so he is probably familiar with that. | null | 0 | 1546097340 | False | 0 | ect17q2 | t3_aaco1d | null | null | t1_ecrsgqk | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect17q2/ | 1548225655 | 3 | t5_2fwo | r/programming | public | null |
False | FluorineWizard | t2_g4bb0 | Eh, checked nullable types are just Option/Maybe formulated in a way that sounds familiar to imperative programmers who've never seen a sum type. Usually involves substantial syntax sugar to fit in the imperative mindset too. | null | 0 | 1546097482 | False | 0 | ect1dkg | t3_aai5ap | null | null | t1_ecsodsm | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ect1dkg/ | 1548225728 | 2 | t5_2fwo | r/programming | public | null |
False | __j_random_hacker | t2_4rnnt | As I understand it, the logic with these interviews is that skill with algorithms *accurately predicts* good performance as a "regular" programmer. I'm not claiming that that is necessarily true, only that it's plausible, and that tech giants have a huge vested interest in determining accurate predictors of general programming ability that can be evaluated in a short (interview-length) time, so if they are going with this, it's at least one of the best predictors *currently known*. (In the past, they often used "riddle questions" like "Estimate how many screws there are in a 747", but AFAIK these turned out to be a poor predictor -- so most have now dropped that strategy.)
If it's really the case that high skill with algorithms predicts high general programming ability, then provided that there are enough programmers constantly applying to work at your company, that's all you (the company) really need -- it doesn't really hurt if you turn away many people who can't program their own balanced search tree but would nevertheless be good "regular" programmers.
I mean, if tomorrow it was discovered that 99% of left-handed people are great programmers, I think the tech giants would rapidly cut down their interview processes to the shortest amount of time needed to (a) let them get a look at the candidate write something down and (b) minimally satisfy legal requirements. Only if they couldn't find enough lefties would they resort to traditional interviews. | null | 0 | 1546097512 | False | 0 | ect1es8 | t3_aaco1d | null | null | t1_ecs5llh | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect1es8/ | 1548225743 | 2 | t5_2fwo | r/programming | public | null |
False | aphexairlines | t2_319so | Related twitter thread: [https://twitter.com/themattchan/status/1076977773195931648](https://twitter.com/themattchan/status/1076977773195931648) | null | 0 | 1546097539 | False | 0 | ect1fuv | t3_aam1ft | null | null | t3_aam1ft | /r/programming/comments/aam1ft/languageoriented_software_engineering_sort_of_a/ect1fuv/ | 1548225756 | 1 | t5_2fwo | r/programming | public | null |
False | KadaBen | t2_p9x21w7 | I think that's a point you find in most tech journals. I don't find it very convincing..
C++ always tried a split between application programming and systems programming.
The people sticking with C++ are not sticking, because it's the best way, but because it's the legacy way.
Building a language that goes bare metal up for systems development could look very different if that were the main purpose.
The industry sticks with the language, because you don't need new tools to do the most jobs, because it's all in the language..
Doesn't mean that there isn't room for improvement in the specialized fields. But nobody is trying as long as you can be complacent with vintage C++ | null | 0 | 1546097653 | False | 0 | ect1k89 | t3_aac4hg | null | null | t1_ecrczt8 | /r/programming/comments/aac4hg/modern_c_lamentations/ect1k89/ | 1548225810 | 1 | t5_2fwo | r/programming | public | null |
False | hasen-judy | t2_2j2as8va | People think a 2 second build is fast.
I have a code base in Go that is about ~6k lines and it takes 2 seconds to build.
Well actually, it builds almost instantly but takes 2 seconds to *link*.
I tried to Google for how to fix slow builds with Go. Most results are about reducing build times from 30 seconds to 8 seconds.
| null | 0 | 1546097741 | False | 0 | ect1nqh | t3_aalgpq | null | null | t3_aalgpq | /r/programming/comments/aalgpq/it_is_fast_or_it_is_wrong/ect1nqh/ | 1548225853 | 7 | t5_2fwo | r/programming | public | null |
False | Scroph | t2_6p6h0 | Impressive ! I thought betterC didn't support most of the standard library, but it looks like things have been improving faster than I anticipated. Does D have a tuple unpacking syntax like std::tie ? | null | 0 | 1546097857 | False | 0 | ect1smx | t3_aac4hg | null | null | t1_ecrfn7f | /r/programming/comments/aac4hg/modern_c_lamentations/ect1smx/ | 1548225914 | 3 | t5_2fwo | r/programming | public | null |
False | PorkChop007 | t2_4c7ynac | Back in the day, when Eclipse randomly hanged, crashed, decided a maven dependency was no longer there and fucked up my workspace in general I could swear a broken calculator was better than Eclipse.
Then I switched to IntelliJ. I never knew to what extent my productivity was being impacted by a defective tool until I found one that worked perfectly. Honestly, I can't go back to Eclipse now. Not even Netbeans. | null | 0 | 1546097897 | False | 0 | ect1ud1 | t3_aa05by | null | null | t1_ecr25u4 | /r/programming/comments/aa05by/netbeans_100_released/ect1ud1/ | 1548225935 | 4 | t5_2fwo | r/programming | public | null |
False | korkskrue | t2_7dbug | /u/gaearon convenient guide to Monads for you if you're interested | null | 0 | 1546097976 | False | 0 | ect1xnz | t3_aai5ap | null | null | t3_aai5ap | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ect1xnz/ | 1548225976 | 3 | t5_2fwo | r/programming | public | null |
False | F-0X | t2_lk6ut | > Well that's a lie.
How obnoxious. If you believe what I've written is wrong, why assume I am lying rather than simply mistaken? You're going to have problems in the future if this is how you communicate.
>Code bases in nim aren't forced to...
Entirely irrelevant. Rust decided not to provide (init; condition; increment) style for-loops on the basis that they are too complex (I disagree, but still), even though nobody is forced to use them.. same goes for any feature deliberately left out of a language. Bad ideas just shouldn't be optional.
>For nim this is more likely because of the great C integration so there are fewer wrappers than in for example Python
A cursory look at their docs and github, the docs feature nothing when you search "c" and nothing related to C when you search "ffi". There is an [open github issue](https://github.com/nim-lang/Nim/issues/8327) asking for wrapper-less C interop, so it seems wrappers are currently unavoidable. Were you mistaken or lying? | null | 0 | 1546098092 | False | 0 | ect22bj | t3_aaamfb | null | null | t1_ecss4z9 | /r/programming/comments/aaamfb/how_you_ever_thought_about_which_casing/ect22bj/ | 1548226033 | -1 | t5_2fwo | r/programming | public | null |
False | Sfxrill | t2_qcy8m | The concepts thing really bothers me. I suppose I understand *why* they're designed the way they are, but at this point I really just don't understand the point of even having them outside of potentially prettier error messages.
At first I thought they would be like Rusts traits, which I was over the moon about. Being able to constrain template parameters would be extremely useful for writing generic code.
Then I learned that they aren't marked anywhere, it's just implicit if a type fits a concept or not based on it's methods. Great, so I have to waste time looking through a class's methods to determine if it's sortable or not, rather than just an `impl Sortable` somewhere. That's potentially a usability nightmare.
Ok, it may be annoying, but at least I can use an interface safe in the knowledge that it will compile nicely so long as a concept is met and absolutely nothing can go wrong. Oops, concepts are still duck typed and can use methods not in the concept. So they have exactly the same problems as templates with some convenience error messages added, convenience messages that you probably won't even see under the cascade of duck typed error messages from a function trying to use `operator <<` for debugging when that wasn't specified in the requirements.
I suppose I understand why these decisions were made, but they seem to just completely neuter the entire concept (pun not intended) of concepts. | null | 0 | 1546098270 | False | 0 | ect29ws | t3_aac4hg | null | null | t1_ecrh8z2 | /r/programming/comments/aac4hg/modern_c_lamentations/ect29ws/ | 1548226127 | 4 | t5_2fwo | r/programming | public | null |
False | stone_henge | t2_hw9z1 | > That's all well and good, but tell me that the example I posted is not surprising, if not downright dangerous.
Since I've used many different shells over the years, and because I am familiar with the UNIX userland and its many other inconsistencies, no, that does not seem surprising to me. I have not used fish for more than minutes at coworkers' computers, but if I did, I think I'd be surprised to learn that it did not resolve `cd ..` based on the current `PWD` like pretty much every other shell does, and I can see why they now think that it's better to do so.
> That's never been a goal for fish.
I never said that it has been. By now exhibiting some behavior that is consistent with POSIX that it did not before, it has improved its compliance to POSIX whether they changed it to that end deliberately or not. In this case they changed the `cd` command to "match other shells" which incidentally work the way they do in this respect because they observe POSIX.
My main gripe with your argument is its appeal to correctness.The only basis you present for `cd` resolving symlinks by default being "correct" is that you personally find it surprising (because somehow inconsistency in UNIX is surprising to you?). My basis for saying that it's not correct is that there exists a standard specification that almost all shells implement and which all major UNIX clones strive to comply to from kernel to userland. Ultimately, that standards in itself is based on observed conventions
For all I care, fish can ignore these standards and do whatever it wants, and its users may be better off for it, but by ignoring existing standards and conventions it really loses any claim to "correctness". If you had said that this is "ugly" or "inconsistent" I wouldn't have batted an eye at your post because I agree that it is inconsistent and ugly. | null | 0 | 1546098311 | False | 0 | ect2bql | t3_aabai1 | null | null | t1_ect024h | /r/programming/comments/aabai1/fish_shell_30/ect2bql/ | 1548226149 | 2 | t5_2fwo | r/programming | public | null |
False | cyanrave | t2_3thxo | This is a very understated statement. | null | 0 | 1546098422 | False | 0 | ect2gb0 | t3_aac4hg | null | null | t1_ecrzly1 | /r/programming/comments/aac4hg/modern_c_lamentations/ect2gb0/ | 1548226235 | 3 | t5_2fwo | r/programming | public | null |
False | fuddlesworth | t2_djve0 | IMO they really aren't good indicators and are actually biased and reject a lot of good candidates. Asking these questions is fine for a new grad as it's a good indicator they actually paid attention in school. However, for a senior, lead, or higher position? Most of the time you are having to draw up knowledge from your college days that was 5, 10, 15 years ago.
There are also people that are great at hacking, doing these sorts of puzzles, etc but actual skills in a professional setting draw up short. There are also people that totally suck at being put on the spot to solve puzzles but are actually really good developers in a professional setting.
I've recently gone through the interview process for a new job. I've got 10 years of professional experience which ranges from doing os and virtualization coding for IBM on AIX, the old LAMP stack monolith, to being one of the first in my company to adopt and teach modern day web technology.
You know what? Most interviewers still focused on this 'algorithm puzzle' bs. I was interviewed like a new grad for several places. Doesn't matter that I evangelized GraphQL at my company leading teams to increase productivity and standardize APIs, or created a mechanism for other projects to consume our React app to rapidly gain functionality that would cost the company millions in non compliance. No, none of that matters in the interview. The only thing that mattered was me drawing up information that I haven't used in 10 years since college.
The GOOD interviewers had an at home coding exercise and evaluated my work based off that or had more of an architect style problem. Those were great experiences. That is how interviews should go. Not this 'your resume doesn't matter, only how well you can solve our puzzle'.
Some jobs do require these skills. Game development, data science, AI, etc. These are also specialized positions. A typical app or web dev job though? No, they don't really matter much. | null | 0 | 1546098458 | 1546098643 | 0 | ect2hwp | t3_aaco1d | null | null | t1_ect1es8 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect2hwp/ | 1548226254 | 2 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | I will once I get back to product dev. | null | 0 | 1546098496 | False | 0 | ect2jk7 | t3_aaco1d | null | null | t1_ecsr9dx | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect2jk7/ | 1548226275 | 9 | t5_2fwo | r/programming | public | null |
False | i_tried_butt_fuck_it | t2_10vn58 | > It is also hypergolic with such things as cloth, wood, and test engineers
.
> **and test engineers**
So, some engineers tested it? | null | 0 | 1546098499 | False | 0 | ect2jp9 | t3_aaco1d | null | null | t1_ecska5q | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect2jp9/ | 1548226277 | 5 | t5_2fwo | r/programming | public | null |
False | Calavar | t2_gm1q8 | Not enough to matter unless it's at a hot point in your code. You know what they say: avoid early optimization. | null | 1 | 1546098522 | False | 0 | ect2ko9 | t3_aac4hg | null | null | t1_ecsqwuy | /r/programming/comments/aac4hg/modern_c_lamentations/ect2ko9/ | 1548226289 | -1 | t5_2fwo | r/programming | public | null |
False | FrogsEye | t2_491uo | Some people are blunt and direct. Which is something I prefer to political correctness and trying to be nice all the time. It's okay for a community to have some standards and hold others to them. | null | 0 | 1546098526 | False | 0 | ect2kt2 | t3_aaco1d | null | null | t1_ecsfwvf | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect2kt2/ | 1548226290 | 2 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | Why is it ridiculous? I have a full time job that nevertheless barely touches either of these concerns. Programming is a _really_ big tent. That’s what the post is about. | null | 0 | 1546098634 | False | 0 | ect2pfs | t3_aaco1d | null | null | t1_ecsizeh | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect2pfs/ | 1548226347 | 9 | t5_2fwo | r/programming | public | null |
False | verylittlefinger | t2_ta9ws | You get to exchange it for good grades at the review time, which in turn means stock and bonuses. | null | 0 | 1546098693 | False | 0 | ect2ry8 | t3_aaagix | null | null | t1_ecsnskz | /r/programming/comments/aaagix/why_review_code/ect2ry8/ | 1548226379 | 2 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | Which of these topics would you say are directly linked to my work?
I’d like to understand low-level graphics and manual memory management more. What else?
Also, I’d be curious to look at your version of this list. | null | 0 | 1546098868 | False | 0 | ect2zb1 | t3_aaco1d | null | null | t1_ecsx6kx | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect2zb1/ | 1548226470 | 11 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [deleted] | null | 0 | 1546098896 | False | 0 | ect30j6 | t3_aajb7r | null | null | t1_ecsopcl | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect30j6/ | 1548226485 | 1 | t5_2fwo | r/programming | public | null |
False | fjallidergodur | t2_12vkpv | With a VGA output ! | null | 0 | 1546098901 | False | 0 | ect30qc | t3_aajb7r | null | null | t1_ecswue8 | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect30qc/ | 1548226488 | 3 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | Not really. As mentioned in the post I don’t know Node that well either. ;-) | null | 0 | 1546098968 | False | 1 | ect33k0 | t3_aaco1d | null | null | t1_ecs5erq | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect33k0/ | 1548226523 | 10 | t5_2fwo | r/programming | public | null |
False | skeeto | t2_3em9l | Gave it a shot for myself (C):
https://gist.github.com/skeeto/871f6b56684608ab64131afe8e7c7280
[**Sample Video**](https://nullprogram.com/video/?v=fire)
Edit: Made a WebGL version to see how well it would work in a shader. ~~Doesn't seem to work well on mobile, though.~~
[**WebGL Fire**](https://nullprogram.com/webgl-fire/) ([source](https://github.com/skeeto/webgl-fire))
Use SPACE to pause, PgUp and PgDown to control the "temperature."
| null | 0 | 1546098979 | 1546176507 | 0 | ect340o | t3_aajb7r | null | null | t3_aajb7r | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect340o/ | 1548226528 | 35 | t5_2fwo | r/programming | public | null |
False | venuswasaflytrap | t2_3g78x | Yeah, that put me off too. The first line says he's mastered learning. Doesn't seem right. | null | 0 | 1546099083 | False | 0 | ect385m | t3_aab645 | null | null | t1_ecs6bwq | /r/programming/comments/aab645/learning_to_learn_develop_skills_to_master/ect385m/ | 1548226580 | 2 | t5_2fwo | r/programming | public | null |
False | echeese | t2_31ppm | Probably Redux | null | 0 | 1546099231 | False | 0 | ect3eis | t3_aaco1d | null | null | t1_ecs6any | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect3eis/ | 1548226659 | 4 | t5_2fwo | r/programming | public | null |
False | evmar | t2_3c55u | I am confused why the author takes an app written in Cloujure, whose whole design goal is to target the JVM, and then expects it to perform better when you run it on something other than the JVM. The design goals and tradeoffs are entirely separate. E.g. the primary design goal of the Closure compiler is to reduce output code size, which I would guess is not a big concern of the Clojure compiler.
Like even using their own metaphor, they're asking: why do trains even exist? And the answer there is obvious: for example, they can move heavier cargo more cheaply than planes. | null | 0 | 1546099245 | False | 0 | ect3f6u | t3_aalgpq | null | null | t1_ect0h8k | /r/programming/comments/aalgpq/it_is_fast_or_it_is_wrong/ect3f6u/ | 1548226667 | 4 | t5_2fwo | r/programming | public | null |
False | MadRedHatter | t2_skbl1 | "Fast" is not the only consideration. GC pauses would be unacceptable for UE4, and probably Chromium also. | null | 0 | 1546099254 | False | 0 | ect3flt | t3_aac4hg | null | null | t1_ecszb9u | /r/programming/comments/aac4hg/modern_c_lamentations/ect3flt/ | 1548226672 | 3 | t5_2fwo | r/programming | public | null |
False | thirdegree | t2_63m0r | Test engineers are approximately 2/3rds water, so I think it could probably be deduced. | null | 0 | 1546099373 | False | 0 | ect3kuf | t3_aaco1d | null | null | t1_ect2jp9 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect3kuf/ | 1548226736 | 9 | t5_2fwo | r/programming | public | null |
False | Groundbreaking_Lion | t2_10l76bxa | Yasssss ! FPGAs for the WIN I freaking love FPGAs especially hardware engineering | null | 0 | 1546099419 | False | 0 | ect3mns | t3_aajb7r | null | null | t1_ect30qc | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect3mns/ | 1548226759 | 4 | t5_2fwo | r/programming | public | null |
False | amazondrone | t2_e5y3o | > the amount of developers who can't get low-level ideas is embarrassingly high
Perhaps. On the other hand, what's the point in all developers knowing that stuff? Better to leave it to a smaller group of specialists to write good tools, instead of constantly reinventing the wheel? A Formula 1 driver should know something about how his car works, but shouldn't be the expert in that - rather, s/he should be expert at driving it. | null | 0 | 1546099435 | False | 0 | ect3nb6 | t3_aajb7r | null | null | t1_ecsv95a | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect3nb6/ | 1548226767 | 32 | t5_2fwo | r/programming | public | null |
False | shinazueli | t2_dprsa | Honestly, I'd rather waste 150% of the time every time then pay the 1500000% cost *once*. I can measure and predict the speed at which I'll finish with confidence that way -- as opposed to "well, turns out I need an extra 4 months to finish that thing we thought was going to take 2 weeks." Pointy headed managers and executives *love* hearing those words, let me tell you.
Anyone that advocates for less generality and abstraction has *never* had to pay that debt.
I've literally spent most of my career going from fire to fire paying debt like this from people that said shit **just** like that.
"Why abstract it if there's only one use case?"
"Because then I don't need to spend **six months** rewiring everything that code touches because you exposed implementation details that weren't necessary and other idiots depended on them unnecessarily."
I'll just flat out reject code reviews if most/all of the seams are not extracted into interfaces, these days. There needs to be a *compelling* reason to not abstract virtually everything. And "I need to close my JIRA ticket and submit this code" is *not* compelling.
I've heard the performance arguments and called complete bullshit on it over and over again. I write raw C++ for an embedded product. Unless you can *measurably* show me a *real* performance drop in *real* production code, not some made up bullshit, I don't care. The sad truth is that the hardware has gotten so good that realistically you just don't need optimized code outside of your real tight areas -- they'll be the bottleneck for everything else. And the real long term cost of paying devs to fix idiotic decisions later is *way* more expensive than some imaginary "maintenance" cost. | null | 0 | 1546099546 | 1546108054 | 0 | ect3ruk | t3_aac4hg | null | null | t1_ecrhn0z | /r/programming/comments/aac4hg/modern_c_lamentations/ect3ruk/ | 1548226852 | 3 | t5_2fwo | r/programming | public | null |
False | mgostIH | t2_y3ijl | The post seems more about the performance drop in having 2 different systems to handle files glued together for compatibility, rather than a strict difference between Windows and Linux as the title may suggest.
> And it's not even as simple as saying "Windows is the cause of the slowness" either, since WSL does play a role. Most notably, Windows path parsing is very different than Linux path parsing. [...] Linux apps expect the Linux behavior, so we have to carefully emulate that behavior, and unfortunately that means sending more operations down to the file system. | null | 0 | 1546099555 | False | 0 | ect3s9f | t3_aalc4n | null | null | t3_aalc4n | /r/programming/comments/aalc4n/windows_file_access_performance_compared_to_linux/ect3s9f/ | 1548226856 | 123 | t5_2fwo | r/programming | public | null |
False | FACastello | t2_12yma2 | I have a weird obsession with tile-based graphics and pixel manipulation since I was a child, so I tend to develop a lot of projects in several different programming languages that attempt to emulate "screen modes" or "graphics drivers" which look like the ones found in early computer systems and videogame consoles, where the screen is divided into tiles and the resolution is far lower than most modern systems. I have programmed so much of this kind of stuff that I already know by heart most of the algorithms and data structures involved, and I can create a complete, retro-looking graphics API in 1 hour or less. | null | 0 | 1546099661 | False | 0 | ect3wli | t3_a8wlar | null | null | t3_a8wlar | /r/programming/comments/a8wlar/do_you_program_for_leisure_and_how/ect3wli/ | 1548226910 | 2 | t5_2fwo | r/programming | public | null |
False | DJRBuckingham | t2_ywqtq | I'm not looking for guarantees or enforcing anything, just that debug performance and compile times be on the agenda. I think a huge part of this very real world problem is that everyone with the power to improve matters is explicitly ignoring it. If I were the standards committee I would take actions along these lines:
* Make a statement that debug performance and compile times are important and should not be needlessly sacrificed.
* Request that compiler vendors produce compile time telemetry for users, so they can profile & investigate slow compile times.
* Provide guidelines on how to assess debug performance and compile time characteristics of reference implementations against the common compilers (gcc/clang/MSVC), and include the results in formal proposal documents as supporting evidence.
These are designed to bring the debug performance and compile time characteristics of proposals & existing features out into the open, and provide a benchmark with the reference implementations that compiler implementers are obliged to maintain or beat. It would also bring to attention cases of egregiously bad scenarios and thus either force a rethink, or raise up the priority of fixing whatever bug in a compiler was causing the issue.
As for the rest of your post, it is clear we have different priorities, and we're getting into the subjective realm of preference. For example, I do not use lambdas anywhere, because I consider the programming practises that they enable and encourage to rapidly degrade a codebase due to (amongst other things) the aforementioned debug/compile time concerns. I believe any marginal improvements in readability or functionality are dwarfed by the costs to productivity. But I recognise this is personal opinion, and I wouldn't want to *remove* lambdas from the language, I just wouldn't use them myself.
What I do want is the tools and data to allow us to accurately assess what the impacts of lambdas, templates, meta-programming and so on, all have on our compile times. And I don't think this should be controversial, its just understanding the problem of "compile times" better so we can fix them. Perhaps everything in the language is great except X, in which case we can use everything else and just avoid X. But the cynic in me says folks are scared it would expose how universally bad all these constructs really are, and then they would get banned as if they produced sub-optimal release code, undoing twenty years of committee work. | null | 0 | 1546099663 | False | 0 | ect3wpd | t3_aac4hg | null | null | t1_ect0h2c | /r/programming/comments/aac4hg/modern_c_lamentations/ect3wpd/ | 1548226912 | 4 | t5_2fwo | r/programming | public | null |
False | TheRedManFromRussia | t2_ryvp7 | I mean, idk what specifically you work on, but I'd imagine that something like a front-end framework would require knowledge of low-level languages and algorithms, but of course you will think it's unnecessary. | null | 0 | 1546099920 | False | 0 | ect4782 | t3_aaco1d | null | null | t1_ect2zb1 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect4782/ | 1548227041 | -5 | t5_2fwo | r/programming | public | null |
False | __j_random_hacker | t2_4rnnt | > actually biased and reject a lot of good candidates
That's quite possibly true, but part of my point was that this -- the possibility of missing a good candidate -- only matters to companies if they are short on interviewees. TTBOMK, the "big name" companies aren't, so they can afford to just interview the next person and wait for a "definite hit". It makes much more sense for less well-known companies to have a more nuanced process.
FWIW, I also like coding at home exercises, and feel they are or at least can be a fairer way of evaluating candidates. But they also have their detractors -- often seasoned pros like yourself who object to doing hours of "homework". A couple of years ago I implemented a whole calculator app for one company I applied to -- I thought it would take me a weekend, perhaps a bit longer as I wasn't familiar with the language they wanted me to use, but it ended up taking weeks. (They wanted exact arithmetic with rational numbers -- or at least that was my interpretation. Unclear specs -- such a realistic test! ;-) ) Fortunately I got a lot out of the process, but it's not something I could or would want to do every time. | null | 0 | 1546099920 | False | 0 | ect4791 | t3_aaco1d | null | null | t1_ect2hwp | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect4791/ | 1548227041 | 3 | t5_2fwo | r/programming | public | null |
False | Occivink | t2_53r1h | >I think I'd be surprised to learn that it did not resolve cd .. based on the current PWD like pretty much every other shell does,
The surprise is not in the behavior of `cd`, I agree that in isolation it's nicer for cd to work like that. The surprise is in the fact that any other program will interpret arguments containing `..` differently depending whether there are symlinks in your `PWD`. It's especially dangerous considering that there is no indication whatsoever that there might be symlinks in it.
I guess this is "correct" behavior as far as posix is concerned, but I don't think anybody would argue that this is correct as far as a reasonable user would expect. | null | 0 | 1546099933 | False | 0 | ect47t1 | t3_aabai1 | null | null | t1_ect2bql | /r/programming/comments/aabai1/fish_shell_30/ect47t1/ | 1548227049 | 3 | t5_2fwo | r/programming | public | null |
False | Malor | t2_4fo45 | Well, not necessarily, he's also directly saying that Windows is a lot slower about handling files in general, because it's doing a lot more work whenever one gets touched. This is my own supposition, but I believe this may partly be due to all the backward compatibility layers Windows has to haul around. He gives a specific example of how path names get morphed at least twice as they pass through various I/O layers, which I suspect may only be necessary because of all the BC stuff.
He also directly points out that a naive port of filesystem-intensive software from Linux to Windows may suffer very badly. He mentions Git as something that would be kind of a disaster if the port hadn't been adjusted to work in a more Windows-friendly way.
It sounds like the Linux view of files in general is simpler, perhaps as a side effect of the 'everything is a file' idea of Unix. When absolutely everything is touching your file code all the time, it tends to stay as efficient as the programmers can possibly make it.
edit to add: Linux may well pay for this in different areas. Witness all the pain around path-based security systems, for example. Linux thinks in terms of path names, but with symbolic and hard links, the same exact file can have many possible ways to address it. Not even inodes are unique, as hard links are just (IIUC) pointing different inodes at the same file on disk. So uniquely determining the security of a file in a path-based scheme can be damn difficult, and there's been lots of bugs in that area. Also look at the endless pain in union filesystems. Valerie Aurora was working heavily on something filesystem-related, and I think that ended up being vastly difficult and fizzling out, probably for similar reasons.... not much abstraction in the kernel, and an overly simple idea of what files are and how they work.
NT may be slower, even much slower, but it seems to be easier to extend in interesting and unusual ways. It sounds like its file abstractions are kind of painful in what we consider routine use cases, but it's pretty easy to work with programmatically. Linux filesystem handling is really fast, but doesn't seem fully thought out. It's been a pain point on that OS for pretty much its entire lifespan. Offhand, filesystem issues and the Big Kernel Lock come most strongly to mind when I think about Linux problems, and they finally removed the BKL several years ago. Yet, AFAIK, the endless pain in extending filesystems to offer new features is just as present as it's ever been.
Is the NT approach worth it? If you're really performance-sensitive, like on big servers, almost certainly not. From an end-user perspective, though, particularly on desktops/workstations, losing speed to gain easy flexibility could be considered a big win.
second edit: however, that extendability has limits... look how badly the Longhorn filesystem project failed on the Windows side of the fence.
It may just be that filesystems in general are one of the really difficult problems.
| null | 0 | 1546100033 | 1546120856 | 0 | ect4c03 | t3_aalc4n | null | null | t1_ect3s9f | /r/programming/comments/aalc4n/windows_file_access_performance_compared_to_linux/ect4c03/ | 1548227100 | 125 | t5_2fwo | r/programming | public | null |
False | Sedbict | t2_670l7m | This is a poor analogy. F1 drivers need do know more than the basics of how their engine works in other to be able to respond quickly to any problem thrown their way. Sure, not every dev \*needs\* to know low-level stuff (and to be frank, most people probably wouldn't be able to correctly utilize any gained knowledge anyway), but it would be far-fetched to insinuate that this doesn't make you a better programmer. Familiarizing yourself with memory management and control flow in pure assembly is invaluable knowledge to any programmer worth their salt.
&#x200B;
A simple yet infuriating- example: many people roll back to already-implemented "search" functions ( traversing the same elements multiple times) without worrying about the toll it has on running times. So no need to reinvent the wheel, but being aware of it wouldn't hurt. | null | 1 | 1546100255 | False | 0 | ect4lki | t3_aajb7r | null | null | t1_ect3nb6 | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect4lki/ | 1548227219 | 4 | t5_2fwo | r/programming | public | null |
False | anatoly722 | t2_24ckremk | >never
Just give it a try and you will know why | null | 0 | 1546100389 | False | 0 | ect4r92 | t3_aabai1 | null | null | t1_ecrbl5r | /r/programming/comments/aabai1/fish_shell_30/ect4r92/ | 1548227289 | 1 | t5_2fwo | r/programming | public | null |
False | talexx | t2_lbeq4 | Nothing to be proud of. | null | 0 | 1546100462 | 1546101418 | 0 | ect4uez | t3_aaco1d | null | null | t3_aaco1d | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect4uez/ | 1548227328 | -6 | t5_2fwo | r/programming | public | null |
False | BeowulfShaeffer | t2_38oj4 | https://www.google.com/search?q=michael+abrash+black+book
https://books.google.com/books/about/Game_Engine_Black_Book_DOOM.html?id=wel6DwAAQBAJ | null | 0 | 1546100622 | False | 0 | ect518u | t3_aajb7r | null | null | t1_ecsr7xc | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect518u/ | 1548227441 | 7 | t5_2fwo | r/programming | public | null |
False | kevingranade | t2_je91k | Depends on what you mean by legacy. One of the reasons I'm sticking with c++ is so I can attract contributors that already know the language, another is tooling and another is cross-platform support.
I'll certainly revisit this choice any time i start a new project, but c++ is still the only language with the features I need. | null | 0 | 1546100756 | False | 0 | ect56xm | t3_aac4hg | null | null | t1_ect1k89 | /r/programming/comments/aac4hg/modern_c_lamentations/ect56xm/ | 1548227512 | 2 | t5_2fwo | r/programming | public | null |
False | spacejack2114 | t2_fp92m | [This set of tutorials](https://webglfundamentals.org/) is pretty good. There's less compiler/linker fiddling and cross-platform window boilerplate to worry about. | null | 0 | 1546100962 | False | 0 | ect5fkt | t3_aajb7r | null | null | t1_ecsp9lv | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect5fkt/ | 1548227618 | 6 | t5_2fwo | r/programming | public | null |
False | HellfireOwner | t2_2juz5fhu | Free?! OMFG!! I DONT NEED THE INTERNET ANYMORE!!
&#x200B;
Wait... | null | 0 | 1546101071 | False | 0 | ect5k1o | t3_aam55m | null | null | t3_aam55m | /r/programming/comments/aam55m/free_step_by_step_tutorials_on_python_programming/ect5k1o/ | 1548227673 | 0 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | I have a decent idea of which algorithms are relevant to writing a front-end library given that I worked on one for the past three years. In practice we don’t do much more than linked list traversals which I alluded to in the article.
As for low-level languages... I think understanding JS engine runtime internals (JIT, GC) is more relevant to my job than knowing C specifically. Do you disagree?
What algorithms do you think I need to learn in order to be competent?
| null | 0 | 1546101333 | 1546101520 | 0 | ect5uk0 | t3_aaco1d | null | null | t1_ect4782 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect5uk0/ | 1548227803 | 8 | t5_2fwo | r/programming | public | null |
False | Ozwaldo | t2_3tdnf | Yup, it's the same effect, albeit with different parameters for seeding, convection, and cooling. Also take note of this sentence in the original article:
>The fire effect is a vibrant testimony to a time when **judiciously picked palette colors** combined with a simple trick were the only way to get things done.
mrkite77's looks like it's just doing degrees of red. | null | 0 | 1546101352 | False | 0 | ect5vc3 | t3_aajb7r | null | null | t1_ecsrcap | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect5vc3/ | 1548227812 | 37 | t5_2fwo | r/programming | public | null |
False | johnothecoder | t2_c4rqoc4 | I was somehow unaware of this thread, but having just read it, made for a good read; thanks both! | null | 0 | 1546101411 | False | 0 | ect5xmp | t3_a8ufx5 | null | null | t1_ecera7o | /r/programming/comments/a8ufx5/what_is_a_memory_leak_a_quick_analogy_this_was/ect5xmp/ | 1548227841 | 2 | t5_2fwo | r/programming | public | null |
False | HolyGarbage | t2_4xv0e | Does anyone know what programming language he's using? I really didnt understand his random formula, is he using a bit mask on a floating point number? :s And twice too, first with 3 and then with 1. | null | 0 | 1546101428 | False | 0 | ect5ycf | t3_aajb7r | null | null | t3_aajb7r | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect5ycf/ | 1548227849 | 2 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | Which is why nowhere in the post it says I’m _proud_ of not knowing something. Just that everybody has knowledge gaps. I’m curious about yours. | null | 0 | 1546101714 | False | 0 | ect6aeu | t3_aaco1d | null | null | t1_ect4uez | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect6aeu/ | 1548228029 | 6 | t5_2fwo | r/programming | public | null |
False | PM_ME_YOUR_PROOFS | t2_jo06e | Just using a socket to implement something. Even if it's just a datagram socket like websockets or something. You should understand how, at some level, to communicate between two devices. | null | 0 | 1546101950 | False | 0 | ect6lci | t3_aaco1d | null | null | t1_ecst6ww | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect6lci/ | 1548228163 | -1 | t5_2fwo | r/programming | public | null |
False | kch_l | t2_fezzt | Some people thinks that you need to be good at everything to hire you, I believe you need to have good knowledge on the tech stack you'll be working on, you don't need to know Unix commands or networking or docker if you're going to be working on frontend | null | 0 | 1546101998 | False | 0 | ect6nik | t3_aaco1d | null | null | t1_ect2pfs | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect6nik/ | 1548228190 | 3 | t5_2fwo | r/programming | public | null |
False | seamsay | t2_1zos4clf | Here you go:
GraphicsDocumentation* resources = building_graphics_pipelines_and_shaders(); | null | 1 | 1546102033 | False | 0 | ect6p1u | t3_aajb7r | null | null | t1_ecsp9lv | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect6p1u/ | 1548228209 | 3 | t5_2fwo | r/programming | public | null |
False | Code4Reddit | t2_fd0jj | At work I use a Linux VM inside Windows and I get a huge performance boost doing any kind of build, maybe 2x speed or something but it’s been a long time since I even tried a native windows build to compare. I’ve heard that it is primarily due to the virus protection ignoring the VM, but I imagine it also has something to do with the better file system performance in general too. I’ve never tried turning off the virus protection and comparing. I’m happy with my VM approach. | null | 0 | 1546102040 | False | 0 | ect6pe5 | t3_aalc4n | null | null | t3_aalc4n | /r/programming/comments/aalc4n/windows_file_access_performance_compared_to_linux/ect6pe5/ | 1548228213 | 88 | t5_2fwo | r/programming | public | null |
False | Batman_AoD | t2_1zs3wnd7 | I haven't heard this before; could you please provide a link or something? | null | 0 | 1546102083 | False | 0 | ect6rb3 | t3_aac4hg | null | null | t1_ecsc9zp | /r/programming/comments/aac4hg/modern_c_lamentations/ect6rb3/ | 1548228237 | 1 | t5_2fwo | r/programming | public | null |
False | fabiensanglard | t2_5waty | It is javascript. | null | 0 | 1546102099 | False | 0 | ect6s0s | t3_aajb7r | null | null | t1_ect5ycf | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect6s0s/ | 1548228245 | 3 | t5_2fwo | r/programming | public | null |
False | fabiensanglard | t2_5waty | Where does the code references index 0 as upper left? | null | 0 | 1546102151 | False | 0 | ect6ucd | t3_aajb7r | null | null | t1_ecssy0m | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect6ucd/ | 1548228274 | 2 | t5_2fwo | r/programming | public | null |
False | Boza_s6 | t2_j1w9p | Because I wouldn't want to work with someone who has such superficial knowledge of such wide variety of topic with such a long time in industry, and then almost brag about that, like it's great thing. Then people here have a excuse not to know things "Oh he's very famous and he doesn't know this, why should I"..
Having more knowledge is better than having less. Even it doesn't helps directly it's really important because you can see patterns in other part of the system and reuse already built solutions or take ideas from those.
I want to work with someone who wants to know _how_ things work, not just use them blindly like a black box (and on the other hand knows how to be pragmatic, stop digging for a while and do the job). | null | 0 | 1546102438 | False | 0 | ect77ch | t3_aaco1d | null | null | t1_ect2pfs | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect77ch/ | 1548228435 | -2 | t5_2fwo | r/programming | public | null |
Subsets and Splits
Filtered Reddit Uplifting News
The query retrieves specific news articles by their link IDs, providing a basic overview of those particular entries without deeper analysis or insights.
Recent Programming Comments
Returns a limited set of programming records from 2020 to 2023, providing basic filtering with minimal analytical value.