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 | cyanrave | t2_3thxo | Can I join your team lol?
Code reviews where I work are just a check box, and rarely conducive to growth. Only way to garner *good, constructive* comments is to reach across the enterprise to other craftsman who can weigh in. | null | 0 | 1546102452 | False | 0 | ect77zu | t3_aaagix | null | null | t1_ecr4z3a | /r/programming/comments/aaagix/why_review_code/ect77zu/ | 1548228442 | 1 | t5_2fwo | r/programming | public | null |
False | MadDoctor5813 | t2_eifbq | I don’t think you provide the Makefile, I think the judges make their own based on your instructions. | null | 0 | 1546102475 | False | 0 | ect7927 | t3_aag673 | null | null | t1_ecsqcbc | /r/programming/comments/aag673/ioccc_2019_begins_official_contest_rules/ect7927/ | 1548228456 | 1 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [removed] | null | 0 | 1546102761 | False | 0 | ect7m1x | t3_aamrna | null | null | t3_aamrna | /r/programming/comments/aamrna/what_is_the_best_online_cours_discount_for_new/ect7m1x/ | 1548228646 | 1 | t5_2fwo | r/programming | public | null |
False | TheRedManFromRussia | t2_ryvp7 | As I said, you will disagree. It's a different school of thought. Agree to disagree. | null | 0 | 1546102770 | False | 0 | ect7mff | t3_aaco1d | null | null | t1_ect5uk0 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect7mff/ | 1548228651 | -6 | t5_2fwo | r/programming | public | null |
False | asegura | t2_39hjb | If going "generic" for reusability (over)using templates requires 10x as much effort, you need at least 10 reuses to make it worth it. I doubt that pythagorean triples algorithm is going to be reused in different ways that often (or other so specific problems). So it's better to use a simpler design in such a case. We have to estimate how useful and potentially reusable some code will be to spend some effort making it flexible-enough and easily reusable. | null | 0 | 1546102815 | 1546103007 | 0 | ect7ojn | t3_aac4hg | null | null | t1_ecqp2wu | /r/programming/comments/aac4hg/modern_c_lamentations/ect7ojn/ | 1548228676 | 3 | t5_2fwo | r/programming | public | null |
False | anchpop | t2_dnhif | you're getting downvoted because you lead off with "Monads are about null safety" which is factually wrong. Monads (such as Maybe or Optional) can be used as a replacement for null in other languages, but that's not what they're "about".
you then said "The simplest way I can think to explain it would be an array", which isn't wrong, but doesn't really tell you anything about monads (what does an array have to do with, say, IO or a [TARDIS](http://hackage.haskell.org/package/tardis-0.4.1.0/docs/Control-Monad-Tardis.html)?)
then you hit em with the "You can perform all the same operations on an empty array as you would with a non-empty array. Generalize that concept an you have monads", which makes it sound like you're talking about functors, not monads, since monads are basically all about the bind function of type "(Monad m) => m a -> (a -> m b) -> m b", if you'll forgive the Haskell syntax.
| null | 0 | 1546102861 | False | 0 | ect7qp3 | t3_aai5ap | null | null | t1_ecseuoi | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ect7qp3/ | 1548228703 | 2 | t5_2fwo | r/programming | public | null |
False | dhruvrajvanshi | t2_kji30 | /r/rimjob_steve | null | 0 | 1546103017 | False | 0 | ect7xpf | t3_aabai1 | null | null | t1_ecs28c7 | /r/programming/comments/aabai1/fish_shell_30/ect7xpf/ | 1548228790 | 1 | t5_2fwo | r/programming | public | null |
False | talexx | t2_lbeq4 | I've heard many times that js devs lack knowledge and expertise in many areas and was quite sceptical about that. And now you Dan come with this. I should reevaluate a lot of things in my head now. I really do not understand how you can deliver react/redux and work in js world not having experience with at least some areas you pointed out. Node is required for server-side rendering for example, algorithms/O(n) notation is necessary for optimizations and it is quite critical for UI frameworks and so on, so on. Anyway, it is quite brave to tell such things. | null | 0 | 1546103024 | False | 0 | ect7y16 | t3_aaco1d | null | null | t1_ect6aeu | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect7y16/ | 1548228793 | -4 | t5_2fwo | r/programming | public | null |
False | jlpoole | t2_3bzj3 | I've finally set up the "notebook" on my Gentoo laptop (Dell Inspiron 7i) and have submitted some JPEG images to it, it takes about 2-4 seconds to process a single image. I do not know if the processor is fully utilizing the CPU or not. | null | 0 | 1546103212 | False | 0 | ect860t | t3_aa91bp | null | null | t1_ecsmknp | /r/programming/comments/aa91bp/computer_vision_ai_object_detection_and/ect860t/ | 1548228892 | 1 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | You didn’t answer my questions. Whether you agree or not — which algorithms should I learn in your opinion? | null | 0 | 1546103242 | False | 0 | ect87a6 | t3_aaco1d | null | null | t1_ect7mff | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect87a6/ | 1548228907 | 6 | t5_2fwo | r/programming | public | null |
False | AyrA_ch | t2_8mz48 | Yes, but the instructions are part of the 1 MiB size limit too, and there is no rule against "Please copy this huge Base64 chunk into the makefile as follows", because according to Rule 20, we can essentially tell them the makefile contents since "The how to build instructions must be in make form." | null | 0 | 1546103250 | False | 0 | ect87mu | t3_aag673 | null | null | t1_ect7927 | /r/programming/comments/aag673/ioccc_2019_begins_official_contest_rules/ect87mu/ | 1548228912 | 6 | t5_2fwo | r/programming | public | null |
False | wredue | t2_1rbubxg4 | Sounds like you need to become a Real Full Stack Developer TM and not worry about barfing at your code because in 3 months you’ll be at another company ~~ruining~~ working on their code base. | null | 0 | 1546103337 | False | 0 | ect8b7s | t3_aaco1d | null | null | t1_ecsbhqj | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect8b7s/ | 1548228956 | 3 | t5_2fwo | r/programming | public | null |
False | FeepingCreature | t2_201xo | I don't think there is one in the standard library, but it seems like it would not be hard to implement.
BetterC does not support anything that does GC memory allocations, which is why I had to bypass the GC call by manually throwing it into calloc. As such this is a bit of a hack. But most range functions don't need to allocate memory. | null | 0 | 1546103349 | False | 0 | ect8bp6 | t3_aac4hg | null | null | t1_ect1smx | /r/programming/comments/aac4hg/modern_c_lamentations/ect8bp6/ | 1548228963 | 3 | t5_2fwo | r/programming | public | null |
False | FeepingCreature | t2_201xo | Every optimized version was built with -O -release. (LDC does not need -inline separately.) | null | 0 | 1546103398 | False | 0 | ect8dqs | t3_aac4hg | null | null | t1_ecswcv1 | /r/programming/comments/aac4hg/modern_c_lamentations/ect8dqs/ | 1548228987 | 2 | t5_2fwo | r/programming | public | null |
False | moocat | t2_rj8y | The entire argument is based on the need to run a program once. But when you need to run your program multiple times the argument starts to fall apart. Assume the case where your choices are 5 seconds to compile / 2 seconds to run vs 20 seconds to compile / 1 second to run. Run it once and the quicker build time is the clear winner (7 seconds vs 21 seconds). Run it 15 times and it's an tie (35 seconds each). The more times you run it the extra compile time becomes unimportant. | null | 0 | 1546103445 | False | 0 | ect8fpf | t3_aalgpq | null | null | t3_aalgpq | /r/programming/comments/aalgpq/it_is_fast_or_it_is_wrong/ect8fpf/ | 1548229011 | 1 | t5_2fwo | r/programming | public | null |
False | Filiecs | t2_6t2m0 | I agree with your general sentiment, but starting your post with 'fuck Unity' for making scripting more accessable diminishes your credibility. Unity is an amazing component-based engine, just because it has a lot of users who don't know the fundamentals of programming doesn't make it bad. | null | 0 | 1546103573 | False | 0 | ect8kz1 | t3_aajb7r | null | null | t1_ecsopcl | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect8kz1/ | 1548229077 | 9 | t5_2fwo | r/programming | public | null |
False | AttackOfTheThumbs | t2_79zad | > being aware of it
Pretty much sums it up. You don't need to be able to re-implement it all (though I recommend it for fun), but you should understand the benefits of one route of the other.
This is a really basic thing, but I am still surprised by how many people don't understand how to choose a sort algorithm, let alone optimize anything. | null | 0 | 1546103692 | False | 0 | ect8pxg | t3_aajb7r | null | null | t1_ect4lki | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect8pxg/ | 1548229138 | 12 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | Did you read my post though? I’m not saying I’m completely clueless about these topics — just that I don’t feel comfortable to say I _know_ them.
For example, I don’t know Node API well but I can look it up in the docs if I need to. I understand the high-level picture (one JS thread, async event loop, libuv for IO) and zoom into details as necessary. If I need some kind of Node ORM I can probably pick it up in a week. I’m familiar with how React works in a Node environment (which is just rendering to a string) and I understand how hydration works with server rendering. Etc.
>algorithms/O(n) notation is necessary for optimizations and it is quite critical for UI frameworks
I’ve done optimizations and fixed perf regressions in React before so I’m familiar with what’s necessary. For example, learning to use a profiler and finding actual hot spots in the code is pretty important.
In React, most of our work is linked list traversals. So I don't really expose myself to a lot of different algorithms. If I needed to, I’d probably need to learn O() characteristics of different sorting or balancing algorithms — but it’s just not something I need to deal with right now. | null | 0 | 1546103764 | False | 0 | ect8syx | t3_aaco1d | null | null | t1_ect7y16 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect8syx/ | 1548229204 | 5 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [deleted] | null | 0 | 1546103865 | False | 0 | ect8x4l | t3_aac4hg | null | null | t1_ect091t | /r/programming/comments/aac4hg/modern_c_lamentations/ect8x4l/ | 1548229256 | 1 | t5_2fwo | r/programming | public | null |
False | stone_henge | t2_hw9z1 | > 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.
Yes, executing commands in UNIX is dangerous if you don't know what they do. IMO it's a fundamentally flawed operating system that persists because "worse is better" in the sense that it's easier to get a wide range of users and admins to sign off on something that is well documented and seems to work for them than it is to design the perfect system. Since I know how to use my clone of choice (GNU and Linux) I still prefer it over other operating systems. As far as I'm concerned, that's the point of a UNIX clone; that it works like UNIX. It can never be to produce a flawless system, because it builds on an inherently flawed core that exists for the sake of interoperability and familiarity.
The beauty of it though is that POSIX doesn't describe the whole system, so nothing stops you from using a utility like fish to improve your user experience.
So no, you don't *agree* that it's nicer, because I never said that it was myself. Correct and nice are not the same thing.
> 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.
For me as a user the reasonable expectation seems to be that it works the way it works on other UNIX systems as mandated by the standard that I've read and can easily refer to if some behavior is unclear. For a beginner not expecting to read a book on the subject before they start using symbolic links, I agree that it isn't intuitive, but this is UNIX, so where do we even start? If you don't RTFM you're gonna snub your toes until they have to amputate your feet.
But then again, maybe my confusion about the way fish implements `cd` came to be only because I haven't RTFM? Nope; looking at the fish 2.4 documentation and comparing it to the current documentation, there is nothing under the `cd` command documentation that specifies either the new behavior or the old behavior.
So we have:
a) a behavior that is at least correct according to one meticulously documented, widely accepted and implemented standard for UNIX shells, and
b) a behavior that was only correct insofar that it worked the way its developers programmed it, and was changed because its developers conceded that this may not have been the right way to do it due to popular demand from users that reasonably expected it to work as all the other shells they've ever used do, and unlike detractors could present a solid, non-emotional basis for their request. See https://github.com/fish-shell/fish-shell/issues/3350
I know that if I'm going to throw the word "correct" around, I'll be aiming at a). | null | 0 | 1546103914 | False | 0 | ect8za1 | t3_aabai1 | null | null | t1_ect47t1 | /r/programming/comments/aabai1/fish_shell_30/ect8za1/ | 1548229283 | 1 | t5_2fwo | r/programming | public | null |
False | talexx | t2_lbeq4 | So I guess I misunderstood you. | null | 1 | 1546103915 | False | 0 | ect8zc0 | t3_aaco1d | null | null | t1_ect8syx | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect8zc0/ | 1548229284 | -1 | t5_2fwo | r/programming | public | null |
False | AttackOfTheThumbs | t2_79zad | This is pretty much why I didn't do games. I found the work with graphics engines so damn tiring. | null | 0 | 1546103917 | False | 0 | ect8zel | t3_aajb7r | null | null | t1_ecspvls | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect8zel/ | 1548229285 | 1 | t5_2fwo | r/programming | public | null |
False | cyanrave | t2_3thxo | These are the reviews where everyone mentally, and sometimes physically, walk right the hell out of.
Opinions are great, but what do they mean for standards that everyone is following? For readability? We have a guy that would not adopt common Java formatting standards and would reformat everyone’s code to *his one true way*... Should he even have a say in a review when he clearly doesn’t listen to anyone anyway? I don’t think so, personally. Yes it’s good to rail against one or two quirky *‘that’s the way we’ve always done it’* standards, but there’s a sane maximum for this behavior. You can’t swim through the sea pushing the whole of it away, but only a little at a time.
I know this comment was a snarky one but this behavior does happen and it seems like something that shouldn’t ever be tolerated, or at best, addressed in a PC way so that person knows they’re ‘off the rails’.
*<rant>*
On the flip side, if you work in an OOP lang and don’t like using objects, please consider that people are abusing OOP with over-engineering. They are constructs for holding values like everything else, pointers with meaning. AOP and some of the complex OOP variants are fun, and can be helpful, but still get away from this simple fact of objects, and complicate the relationship.
If you or your loved ones are abused with talks of ‘The Big Four’ or ‘Uncle Bob says...’ in code reviews, kindly find another place of employment. Code review is a place of growth and camaraderie, not condescension and belittlement. Find teachers instead of salesmen for allies.
Unless the commenter wants to walk you through how to implement a pattern given your situation, kindly say, ‘Thanks we’ll look into that’ and move on.
*</rant>* | null | 0 | 1546103944 | False | 0 | ect90k6 | t3_aaagix | null | null | t1_ecsaqfe | /r/programming/comments/aaagix/why_review_code/ect90k6/ | 1548229299 | 2 | t5_2fwo | r/programming | public | null |
False | AttackOfTheThumbs | t2_79zad | While I agree, I do think it's a question of whether you want to make a game, or make an engine. | null | 0 | 1546103958 | False | 0 | ect9166 | t3_aajb7r | null | null | t1_ecsopcl | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect9166/ | 1548229307 | 8 | t5_2fwo | r/programming | public | null |
False | falconfetus8 | t2_5lnfr | explain to me how automated tests wouldn't catch these bugs? | null | 0 | 1546103962 | False | 0 | ect91cw | t3_aa3qdm | null | null | t1_ecs0gld | /r/programming/comments/aa3qdm/please_do_not_attempt_to_simplify_this_code_keep/ect91cw/ | 1548229309 | 1 | t5_2fwo | r/programming | public | null |
False | EAT_DA_POOPOO | t2_4423r | [Yes, I dun goofed](http://shamebell.com/), I accept my deserved downtoots. | null | 0 | 1546104059 | False | 0 | ect95l1 | t3_aai5ap | null | null | t1_ect7qp3 | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ect95l1/ | 1548229361 | 2 | t5_2fwo | r/programming | public | null |
False | UnknownNam3 | t2_irsc8 | You're right; I have a bad attitude, but it's not easy to change attitudes, and even less easy to learn things this advanced. | null | 0 | 1546104078 | False | 0 | ect96eb | t3_aac4hg | null | null | t1_ecsqk1b | /r/programming/comments/aac4hg/modern_c_lamentations/ect96eb/ | 1548229371 | 1 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | I’m not bragging — in fact the post explicitly addresses that at the end. I also explain the motivation for writing it in the first several paragraphs.
I’d like to learn those things but haven't had a chance to yet. I don’t think somebody learning web stack in 2018 has to beat themselves up for not knowing them all — which is why I thought it’s valuable to write it, and to counter-act that mentality. You can totally learn on the go and zoom in as necessary.
>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.
Nowhere in the post do I argue that it’s better not to know things.
>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).
That’s a pretty bold assumption that just because I'm comfortable admitting I don't know _some_ things, I treat everything as a black box. I bet I know some things you don’t too.
You might find it interesting to write up a list of things _you_ don’t know. | null | 0 | 1546104088 | False | 0 | ect96t4 | t3_aaco1d | null | null | t1_ect77ch | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect96t4/ | 1548229376 | 7 | t5_2fwo | r/programming | public | null |
False | kindall | t2_li0r | The C64 at least had sprites, which, to an Apple II programmer, seemed almost like cheating. (Hell, having screen memory that's laid out in a reasonable, linear fashion seemed almost like cheating.) | null | 0 | 1546104117 | 1546109655 | 0 | ect97z4 | t3_aajb7r | null | null | t1_ecsnbh4 | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect97z4/ | 1548229391 | 9 | t5_2fwo | r/programming | public | null |
False | spacejack2114 | t2_fp92m | They aren't that different as you make them out to be. Native UIs and the DOM are both nested tree structures of UI elements. You can build and append elements through an API in both cases, and this is how more complex web apps are made - *not* by assembling HTML strings. And even with ES5, Javascript was still a better-suited language for GUIs than Java or Objective C.
Declarative UI libraries for web apps however have leapfrogged traditional UI libraries in terms of developer ease of use and productivity. This paradigm is now making its way over in the form of Flutter.
In all cases I think you need to learn a lot of specific tricks to make professional layouts. Recently I was working on a simple GTK app and had a heck of a time making it look right on both a regular HD monitor and a 2K monitor. | null | 0 | 1546104232 | False | 0 | ect9cv9 | t3_aaco1d | null | null | t1_ecsv48y | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect9cv9/ | 1548229450 | 4 | t5_2fwo | r/programming | public | null |
False | hastor | t2_4f4pr | Metoo! | null | 0 | 1546104352 | False | 0 | ect9i0v | t3_aajb7r | null | null | t1_ecsqmtg | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect9i0v/ | 1548229514 | 1 | t5_2fwo | r/programming | public | null |
False | TheRedManFromRussia | t2_ryvp7 | As I said, agree to disagree. I do not want to argue with you about how important/unimportant fundamentals of computer science are with regards to writing a front-end library.
There is no specific algorithm, or asm/C SPECIFIC knowledge that I believe you need. It is the fundamentals of computer science that you lack by your own admission. | null | 0 | 1546104365 | False | 0 | ect9ikl | t3_aaco1d | null | null | t1_ect87a6 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect9ikl/ | 1548229521 | -3 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | If you were more specific I’d know what to prioritize. :-) | null | 0 | 1546104449 | False | 0 | ect9m5e | t3_aaco1d | null | null | t1_ect9ikl | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect9m5e/ | 1548229565 | 9 | t5_2fwo | r/programming | public | null |
False | Sjeiken | t2_spdbn | Really??? In fucking JavaScript? What a fucking disgrace. | null | 0 | 1546104519 | False | 0 | ect9p79 | t3_aajb7r | null | null | t3_aajb7r | /r/programming/comments/aajb7r/how_doom_fire_was_done/ect9p79/ | 1548229603 | -23 | t5_2fwo | r/programming | public | null |
False | spybraek | t2_mijlo | Thanks for writing this, Dan.
About a year ago I began interviewing for front end dev positions abroad. I didn't do so well because I was quite used to just building solutions in projects, rather than theory and the typical things people want to hear at these interviews.
I learned a valuable lesson through my process: I needed to update my knowledge to newer tools, and learn some of the theory as to why certain things behave in JS the way they do. I also relearned CSS, and that paid off huge! (I would place CSS at the top of your list! It is extremely powerful right now!)
The interviews created this feeling that I was really behind and was not good enough... (I did not give up because I am now gainfully employed now as a UI/UX dev).
Reading your honesty assured me that all of us devs should not pretend to know more than we do.
The traditional interview process creates way too exaggerated expectations and poorly assesses if existing skills will adapt quickly. | null | 0 | 1546104521 | False | 0 | ect9pb8 | t3_aaco1d | null | null | t3_aaco1d | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ect9pb8/ | 1548229604 | 2 | t5_2fwo | r/programming | public | null |
False | spacejack2114 | t2_fp92m | I've worked with python on and off over the past year. I haven't touched it for a couple of months now and forgot everything already. It seems like a language built out of special cases for everything that need to be memorized. There was a lot of Googling for "how do I do this in Python..." | null | 0 | 1546105052 | False | 0 | ectac2g | t3_aaco1d | null | null | t1_ecrf8qc | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ectac2g/ | 1548229915 | 0 | t5_2fwo | r/programming | public | null |
False | r_acrimonger | t2_gxtfk | This, and I'm struggling just to get my UI panels to friggin resize properly. | null | 0 | 1546105058 | False | 0 | ectacch | t3_aajb7r | null | null | t3_aajb7r | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectacch/ | 1548229918 | 1 | t5_2fwo | r/programming | public | null |
False | recycled_ideas | t2_bpl7i | He's kind of saying that, but a really huge percentage of this is running tools that are optimised for the way Linux works as compared to how Windows works.
The Windows filesystem behaves completely differently than the Linux file system does. Operations that are really fast on one just aren't on the other.
That's discounting all the permission and other emulation going on here. | null | 0 | 1546105106 | False | 0 | ectaehl | t3_aalc4n | null | null | t1_ect4c03 | /r/programming/comments/aalc4n/windows_file_access_performance_compared_to_linux/ectaehl/ | 1548229945 | 38 | t5_2fwo | r/programming | public | null |
False | int2d | t2_1ywgqli9 | To play devil's advocate here, I'd disagree. source: I personally went down the C++/OpenGL/SDL route via the advice of the 'Adventures in Game Development' folks back in the day.
IMO it would be better to start learning in Unity first. Without an engine, it's way too easy to get bogged down working on your engine rather than working on an actual game... and lack of apparent progress can be very demotivating for someone just starting out.
By using Unity you will get an idea for what a good engine, rendering pipeline, etc. looks like. The point is for you to learn the high level concepts in a lot of areas, so that you get a good overview of what game programming actually is. It's just like how you probably wouldn't learn assembly before C.
Now if you decide that Unity is not flexible enough to support e.g. your new rendering idea then you have a strong reason to write your own engine or try another engine. | null | 0 | 1546105367 | False | 0 | ectaqfs | t3_aajb7r | null | null | t1_ecsopcl | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectaqfs/ | 1548230092 | 16 | t5_2fwo | r/programming | public | null |
False | Popeye_Lifting | t2_an6xeu8 | I'm not saying that you can't have a career without learning anything new, but that complaining about keeping up to date with your language because of kids/personal life... is just not a wise thing to say when your career is one of the fastest moving fields out there. | null | 0 | 1546105601 | False | 0 | ectb1se | t3_aac4hg | null | null | t1_ecs8aks | /r/programming/comments/aac4hg/modern_c_lamentations/ectb1se/ | 1548230233 | 2 | t5_2fwo | r/programming | public | null |
False | divideByNulls | t2_g1ubb1e | Game dev have changed dramatically also. Unity can be sort of simple or as complex as old school game dev. Just differs between the level of game you are making | null | 0 | 1546105691 | False | 0 | ectb68g | t3_aajb7r | null | null | t1_ecsjz8t | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectb68g/ | 1548230288 | 2 | t5_2fwo | r/programming | public | null |
False | Lt_Riza_Hawkeye | t2_yf0lh | I get it. If I template based on an <int x>, and then have some tests in my template that test if (x > 10), then depending on what value of x I instantiate the template with, some branches can be statically eliminated at compile time, reducing code size. But if I instantiate my template twice, my code size doubles, erasing any of the potential gains I had gotten by performing the check at compile time.
I don't care how great (and slow) the compiler is, if I have to ship six different std::vector constructors in my application, startup times/code loading, will be slower, less of my program can fit in the instruction cache, and so on and so forth. | null | 0 | 1546105729 | False | 0 | ectb819 | t3_aac4hg | null | null | t1_ecso32u | /r/programming/comments/aac4hg/modern_c_lamentations/ectb819/ | 1548230310 | 2 | t5_2fwo | r/programming | public | null |
False | jcelerier | t2_nju89 | > "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."
in Python, Lisp or Javascript maybe. In C++, thanks to the safety of static checking, I've sometimes done refactors that spanned > 1k source files in less than a day or two - just go from compile error to compile error. So this is really not a good argument for me. | null | 1 | 1546105749 | False | 0 | ectb8ve | t3_aac4hg | null | null | t1_ect3ruk | /r/programming/comments/aac4hg/modern_c_lamentations/ectb8ve/ | 1548230320 | 0 | t5_2fwo | r/programming | public | null |
False | ACoderGirl | t2_y0a8c | Developers are very expensive. Every hour of dev time that gets added because something was unclear or took more time to figure out or lead to more bugs costs hundreds of dollars. And this can add up. Either someone spends some number of hours to refactor the code or the code becomes even more messy and costs more time down the road. Or devs have to bug each other more often with questions, so we're costing valuable time from multiple people. Code reviews also take longer and are more likely to miss things (and uncaught bugs can be expensive due to lost business).
Then missed deadlines have their own costs. You might lose out on contracts or have to pay contract penalties. Or simply having a delay in getting customers buying your product (can't get by forever on investor's cash).
Let's not forget job satisfaction, either. I *hate* working with messy code. I hate it so much. Honestly, while I love my current job, my biggest criticism is they didn't put enough care into the early stages of the code so now there's many areas that are a huge mess and nobody wants to deal with them. When there's a bug in these areas, I'm just dreading the process of tracking it down. We use Python (which is a relatively cleaner language, too) and one particular flaw is that we never used type annotations or even documented types in most places, so debugging has this huge barrier of not even knowing what a variable holds or if there's paths where it might be different. Personally, I'd be inclined to take a little less pay for a beautifully written and documented code base. At least then I'd be happier to deal with it! This is why Fortran and all the other older language devs can demand so much money, too. Nobody wants to work with those ancient languages, so companies have to pay bank. It's not like devs can't learn the languages. They just don't wanna.
Heck, this current product I'm on actually is C++ (and kinda a mismatch of modern and old style C++), due to being performance critical. It's not to my liking, really. I have to deal with all sorts of annoying problems I never did in Python. The nature of the projects we've been doing with this product (concurrently developed *major* features) means we actually *can't* even refactor it because doing so would make horrifying merge conflicts. It just keeps getting messier and I can only hope we'll be allowed to clean it up after these projects finish. I'm actually in charge of getting 3 of these projects merged in and decided to just merge them all together because dealing with them separately is getting to be too painful. | null | 0 | 1546105832 | 1546106274 | 0 | ectbco4 | t3_aac4hg | null | null | t1_ecrfd78 | /r/programming/comments/aac4hg/modern_c_lamentations/ectbco4/ | 1548230367 | 4 | t5_2fwo | r/programming | public | null |
False | shinazueli | t2_dprsa | Did you miss the part where I said that I normally work in C++?
I've done this in C++.
"Go from compile error to compile error and you'll be finished in a day or two."
Cute. That alone tells me everything I need to know about the scale you're working at.
Me and my 25 million lines of code can just recompile over and over again. I'm sure that won't take forever. | null | 0 | 1546105928 | 1546107891 | 0 | ectbh1a | t3_aac4hg | null | null | t1_ectb8ve | /r/programming/comments/aac4hg/modern_c_lamentations/ectbh1a/ | 1548230450 | 0 | t5_2fwo | r/programming | public | null |
False | bagtowneast | t2_pii4tqi |
>Anyone that advocates for less generality and abstraction has *never* had to pay that debt.
I'm not arguing for less generality and abstraction. I'm arguing against premature generality. | null | 0 | 1546106018 | False | 0 | ectbl50 | t3_aac4hg | null | null | t1_ect3ruk | /r/programming/comments/aac4hg/modern_c_lamentations/ectbl50/ | 1548230500 | 3 | t5_2fwo | r/programming | public | null |
False | WeathermanDan | t2_8fys0 | He’s my great uncle. He’s always had a relaxed demeanor :) | null | 0 | 1546106090 | False | 0 | ectboal | t3_a5kk6b | null | null | t1_ebnf3un | /r/programming/comments/a5kk6b/donald_knuths_24th_annual_christmas_lecture/ectboal/ | 1548230539 | 1 | t5_2fwo | r/programming | public | null |
False | dpkonofa | t2_35893 | Can someone step through this a bit more?
function doFire() {
for(x=0 ; x < FIRE_WIDTH; x++) {
for (y = 1; y < FIRE_HEIGHT; y++) {
spreadFire(y * FIRE_WIDTH + x);
}
}
}
function spreadFire(src) {
firePixels[src - FIRE_WIDTH] = firePixels[src] - 1;
}
Why is the doFire function multiplying by FIRE_WIDTH and adding x and then why is spreadFire subtracting FIRE_WIDTH from the index of the array and then just subtracting 1? How does one come up with that logic? | null | 0 | 1546106101 | False | 0 | ectboqu | t3_aajb7r | null | null | t3_aajb7r | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectboqu/ | 1548230544 | 2 | t5_2fwo | r/programming | public | null |
False | TinderThrowItAwayNow | t2_y45po | Swearing within a discussion is fine. Swearing at the person is pointless, it doesn't accomplish anything, it's an argument fallacy.
Yes, some people can't program, but those people tend to give up after they realize they can't use Word or html isn't programming. Instead, you should be explaining and convincing the programmer why they should care about this or that. They're already out there, you might as well help make them better. Positive reinforcement has always worked better. | null | 0 | 1546106139 | False | 0 | ectbqck | t3_aaco1d | null | null | t1_ecsfwvf | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ectbqck/ | 1548230564 | 5 | t5_2fwo | r/programming | public | null |
False | kvdveer | t2_5hjkc | If only it did. That construct is going to be missing every time you actually need it, just like buffer bounds checks. | null | 0 | 1546106257 | False | 0 | ectbvdc | t3_aai5ap | null | null | t1_ecsmy07 | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ectbvdc/ | 1548230627 | 15 | t5_2fwo | r/programming | public | null |
False | Sedbict | t2_670l7m | Well, you'd probably need to get your hands dirty to really get the hang of the material, but you won't go on using whatever you chose to implement. But yes, just having textbook knowledge is tremendously beneficial next to being completely ignorant. Just the ability to identify a possible solution when the need arises is a skill in and of itself.
> I am still surprised by how many people don't understand how to choose a sort algorithm, let alone optimize anything.
I think part of it is down to people's aversion to algorithms/data structures and math in general. You'll often see people here bashing algorithms as simple "interview material", so the abundance of poorly-optimized code doesn't really come as a surprise. | null | 0 | 1546106385 | False | 0 | ectc123 | t3_aajb7r | null | null | t1_ect8pxg | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectc123/ | 1548230697 | 2 | t5_2fwo | r/programming | public | null |
False | pgrizzay | t2_qvf4k | I've always thought `map2` better describes what an applicative can do, rather than `ap` | null | 0 | 1546106471 | False | 0 | ectc4vh | t3_aai5ap | null | null | t1_ecsyyih | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ectc4vh/ | 1548230744 | 1 | t5_2fwo | r/programming | public | null |
False | MadDoctor5813 | t2_eifbq | You should sign up for the contest. Surely Makefile abuse is the purest form of obfuscated code. | null | 0 | 1546106484 | False | 0 | ectc5ic | t3_aag673 | null | null | t1_ect87mu | /r/programming/comments/aag673/ioccc_2019_begins_official_contest_rules/ectc5ic/ | 1548230752 | 6 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | Haha pointer to resources, thanks dad. Real funny. | null | 0 | 1546106546 | False | 0 | ectc8as | t3_aajb7r | null | null | t1_ect6p1u | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectc8as/ | 1548230786 | 8 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | I was specifically referring to programmers. Unity is great to learn all kinds of stuff, just not game programming / game design in that sense.
It may be engaging to use unity as a beginner, but you're learning the wrong way to do things, you learn hacky code. | null | 0 | 1546106677 | False | 0 | ectcekz | t3_aajb7r | null | null | t1_ecsx01c | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectcekz/ | 1548230865 | 8 | t5_2fwo | r/programming | public | null |
False | GreatSchool | t2_1irdahp2 | Interviews are about finding your ceiling, not your mean. | null | 0 | 1546106684 | False | 0 | ectcewa | t3_aaco1d | null | null | t1_ecs5llh | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ectcewa/ | 1548230869 | 1 | t5_2fwo | r/programming | public | null |
False | TheGreatBugFucker | t2_1xq2lihk | Hey moron:
> How about assembler, and types are "32 bit" and "64 bit" and a few variants thereof, and higher level types such as boolean or string but that's really just other names for the bit types :)
THIS was the context, little moron:
> And I suppose whatever secret language you're using is absolutely perfect.
**READ before posting stupid nonsense.** | null | 0 | 1546106699 | False | 0 | ectcfl3 | t3_a1lbh8 | null | null | t1_ec4pgfr | /r/programming/comments/a1lbh8/announcing_typescript_32/ectcfl3/ | 1548230877 | 1 | t5_2fwo | r/programming | public | null |
False | TheGreatBugFucker | t2_1xq2lihk | Hey moron:
> How about assembler, and types are "32 bit" and "64 bit" and a few variants thereof, and higher level types such as boolean or string but that's really just other names for the bit types :)
THIS was the context, little moron:
> And I suppose whatever secret language you're using is absolutely perfect.
**READ before posting stupid nonsense.** | null | 0 | 1546106705 | False | 0 | ectcfwq | t3_a1lbh8 | null | null | t1_ec4pg8q | /r/programming/comments/a1lbh8/announcing_typescript_32/ectcfwq/ | 1548230882 | 1 | t5_2fwo | r/programming | public | null |
False | TheGreatBugFucker | t2_1xq2lihk | Hey moron:
> How about assembler, and types are "32 bit" and "64 bit" and a few variants thereof, and higher level types such as boolean or string but that's really just other names for the bit types :)
THIS was the context, little moron:
> And I suppose whatever secret language you're using is absolutely perfect.
**READ before posting stupid nonsense.** | null | 0 | 1546106710 | False | 0 | ectcg52 | t3_a1lbh8 | null | null | t1_ec4pg0y | /r/programming/comments/a1lbh8/announcing_typescript_32/ectcg52/ | 1548230885 | 1 | t5_2fwo | r/programming | public | null |
False | TheGreatBugFucker | t2_1xq2lihk | Hey moron:
> How about assembler, and types are "32 bit" and "64 bit" and a few variants thereof, and higher level types such as boolean or string but that's really just other names for the bit types :)
THIS was the context, little moron:
> And I suppose whatever secret language you're using is absolutely perfect.
**READ before posting stupid nonsense.** | null | 0 | 1546106717 | False | 0 | ectcgg7 | t3_a1lbh8 | null | null | t1_ec4pahe | /r/programming/comments/a1lbh8/announcing_typescript_32/ectcgg7/ | 1548230888 | 1 | t5_2fwo | r/programming | public | null |
False | TheGreatBugFucker | t2_1xq2lihk | Hey moron:
> How about assembler, and types are "32 bit" and "64 bit" and a few variants thereof, and higher level types such as boolean or string but that's really just other names for the bit types :)
THIS was the context, little moron:
> And I suppose whatever secret language you're using is absolutely perfect.
**READ before posting stupid nonsense.** | null | 0 | 1546106723 | False | 0 | ectcgr8 | t3_a1lbh8 | null | null | t1_ec4p9hr | /r/programming/comments/a1lbh8/announcing_typescript_32/ectcgr8/ | 1548230892 | 1 | t5_2fwo | r/programming | public | null |
False | _oats | t2_nijpp | In case anybody still doesn't understand what a monad is, I found [this blog post](http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html) a bit ago that finally made them (and Applicatives and Functors) click for me. It uses Haskell examples and physical analogies that I found very helpful. | null | 0 | 1546106813 | False | 0 | ectckrr | t3_aai5ap | null | null | t3_aai5ap | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ectckrr/ | 1548230942 | 9 | t5_2fwo | r/programming | public | null |
False | AyrA_ch | t2_8mz48 | It's difficult to have 1 MB of code that is not just junk though.
You could stretch it with very verbose build instructions.
1. Open Your editor of choice
2. Type `w`
3. Press `shift`
4. Type `Q`
5. Release `shift`
6. ...
The end result is a make file that creates a C source file that has a base64 decoder that decodes and prints "Hello, World!" | null | 0 | 1546106892 | False | 0 | ectcodu | t3_aag673 | null | null | t1_ectc5ic | /r/programming/comments/aag673/ioccc_2019_begins_official_contest_rules/ectcodu/ | 1548231014 | 3 | t5_2fwo | r/programming | public | null |
False | fabiensanglard | t2_5waty | Subtracting FIRE\_WIDTH is how you move y up one unit in a linear array. | null | 0 | 1546106943 | False | 0 | ectcqno | t3_aajb7r | null | null | t1_ectboqu | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectcqno/ | 1548231041 | 4 | t5_2fwo | r/programming | public | null |
False | fabiensanglard | t2_5waty | Looking great. I did not look at the source code but it looks like yours has two phases | null | 0 | 1546107005 | False | 0 | ectctey | t3_aajb7r | null | null | t1_ect340o | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectctey/ | 1548231076 | 5 | t5_2fwo | r/programming | public | null |
False | Sedbict | t2_670l7m | Spectacular work as always! I really envy most teams working on emulators, in terms of their programming/problem-solving ability. | null | 0 | 1546107129 | False | 0 | ectcyws | t3_aaml78 | null | null | t3_aaml78 | /r/programming/comments/aaml78/rpcs3_ps3_emulator_november_2018_progress_report/ectcyws/ | 1548231143 | 35 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | It makes scripting more accessible by making everything else almost entirely obscure, and thats why I personally feel like it's not as good as it could be.
I agree, however, that the way I started my comment was really shit. | null | 0 | 1546107156 | False | 0 | ectd057 | t3_aajb7r | null | null | t1_ect8kz1 | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectd057/ | 1548231158 | 2 | t5_2fwo | r/programming | public | null |
False | dpkonofa | t2_35893 | So the FIRE_WIDTH and FIRE_HEIGHT don’t change as the fire grows? I thought those changed as the fire “spread”... | null | 0 | 1546107202 | False | 0 | ectd268 | t3_aajb7r | null | null | t1_ectcqno | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectd268/ | 1548231183 | 2 | t5_2fwo | r/programming | public | null |
False | HellfireOwner | t2_2juz5fhu | Soon it will be \*all\* workers... | null | 0 | 1546107238 | False | 0 | ectd3ur | t3_aandti | null | null | t3_aandti | /r/programming/comments/aandti/older_workers_pushed_out_of_work_or_forced_into/ectd3ur/ | 1548231204 | 18 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | At FB we use a combination of techniques but the part I'm most familiar is a coding interview. We ask a relatively small question (the solution wouldn't be more than ~30 lines of code). It's not trivia but based on something based on a real problem we've encountered. Then we see how a person gets through solving it (talking together through it), and try to gather signal on their problem solving, communication, and coding skills. | null | 0 | 1546107298 | False | 0 | ectd6mu | t3_aaco1d | null | null | t1_ecseab5 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ectd6mu/ | 1548231238 | 3 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | It's neat, I like it. Textures are a bitch, but other than that it's fast, reliable, and best of all, actually readable code. You can optimize the shit out of it as well, without having to worry about breaking everything quite as much. Documentation is mediocre, but you can just use regular documentation and guess how it would work in C#. The boilerplate code you need to get something going is only a few lines.
I can also recommend Processing.org, its built on java and can do quite a lot of neat things (good for prototyping stuff like algorithms). | null | 0 | 1546107381 | False | 0 | ectdadt | t3_aajb7r | null | null | t1_ecspvls | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectdadt/ | 1548231286 | 1 | t5_2fwo | r/programming | public | null |
False | gaearon | t2_7enqh | My post says that I understand "sockets let computers talk to each other outside the request/response model". I can search for exact API and read or write some communication code.
That doesn't mean I _know_ sockets deeply (e.g. how many of them are available? how are they exposed on OS level? what is the actual transport protocol? etc)
But it also doesn't mean I can't research and learn that on demand. That's what my post was about. | null | 0 | 1546107450 | 1546113948 | 0 | ectddko | t3_aaco1d | null | null | t1_ect6lci | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ectddko/ | 1548231325 | 3 | t5_2fwo | r/programming | public | null |
False | phillipcarter2 | t2_gxfjqq4 | It sounds like you just want to be an asshole with no consequences :) | null | 0 | 1546107470 | False | 0 | ectdeie | t3_aaco1d | null | null | t1_ecsg357 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ectdeie/ | 1548231336 | 2 | t5_2fwo | r/programming | public | null |
False | omni-viral | t2_3chm4v | You know that early pessimization should be avoided as well.
Or you can end up without bottlenecks in your program.
Because every part of it is slow. I've seen quite a few. | null | 0 | 1546107507 | False | 0 | ectdgcu | t3_aac4hg | null | null | t1_ect2ko9 | /r/programming/comments/aac4hg/modern_c_lamentations/ectdgcu/ | 1548231359 | 7 | t5_2fwo | r/programming | public | null |
False | Ukonu | t2_3a3c1 | That's absolutely correct.
The sad part is that if someone had explained it your way to me instead of overzealously trying to explain the category theory first, I would've understand the practicalities and the theory MUCH faster.
Many, if not all, functional programming concepts can be this approachable. The problem is many functional programers are just poor teachers. | null | 0 | 1546107521 | False | 0 | ectdh11 | t3_aaco1d | null | null | t1_ecrsm1l | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ectdh11/ | 1548231367 | 3 | t5_2fwo | r/programming | public | null |
False | Creris | t2_owuu8 | while that is guaranteed, all compilers that I know of(gcc, clang, visual studio's compiler) do have additional space allocated on stack. For instance, on Visual studio, `sizeof(std::function<...>)` is 40 bytes on x86 and 64 on x64, which means that you can store relatively big objects in `std::function`. The downside is that it takes a load of space on the stack | null | 0 | 1546107620 | False | 0 | ectdlrq | t3_aac4hg | null | null | t1_ecsi5xk | /r/programming/comments/aac4hg/modern_c_lamentations/ectdlrq/ | 1548231426 | 1 | t5_2fwo | r/programming | public | null |
False | NotUniqueOrSpecial | t2_3wrgy | Depending on what you're building and how, it's also very likely to be the cost of process start-up in Windows.
Most (practically all) parallel builds work by repeatedly spinning up new instances of the compiler for each parallel instance of compilation.
That's massively more efficient in Linux. | null | 0 | 1546107649 | False | 0 | ectdn7f | t3_aalc4n | null | null | t1_ect6pe5 | /r/programming/comments/aalc4n/windows_file_access_performance_compared_to_linux/ectdn7f/ | 1548231444 | 76 | t5_2fwo | r/programming | public | null |
False | codemonkey14 | t2_xoac1 | Counter argument: long compile times add up a lot more during development. If your code base takes 6 seconds to compile, and a developer being paid $40/hr has to run the compile phase 10 times during the work day while building features, then compile times have cost the business $0.66.
Realistically, a company may have a dozen or more developers working on that technology and compiling/running the code every couple of minutes. So that compile phase turn around time can easily add up to double or triple digit dollars of operating costs per hour during development time. | null | 0 | 1546107779 | False | 0 | ectdtkx | t3_aalgpq | null | null | t1_ect8fpf | /r/programming/comments/aalgpq/it_is_fast_or_it_is_wrong/ectdtkx/ | 1548231523 | 1 | t5_2fwo | r/programming | public | null |
False | [deleted] | None | [deleted] | null | 0 | 1546107823 | False | 0 | ectdvoy | t3_aabai1 | null | null | t1_ecsp7ns | /r/programming/comments/aabai1/fish_shell_30/ectdvoy/ | 1548231549 | 1 | t5_2fwo | r/programming | public | null |
False | DenimDanCanadianMan | t2_9iiuosc | Hi, no offense but I didn't really glean anything from your comment. What you said probably makes sense to people who already speak Haskell, but I don't understand the syntax you're using or half the jargon | null | 0 | 1546107956 | False | 0 | ecte1uf | t3_aai5ap | null | null | t1_ecso2hr | /r/programming/comments/aai5ap/what_is_a_monad_computerphile/ecte1uf/ | 1548231654 | 17 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | OpenGL and SFML is for C++, OpenTK and SFML.Net the bindings (basically) for .NET.
For C# (or NET in general) you got the options
SFML.NET, which is great for 2D games and has really nice audio and is quite easy to learn. But you should he familiar with C#, first, as it's quite important because the only real documentation you will find is on SFML (the C++ "original"), so you will not find many examples of actual C# code.
OpenTK, which is basically a magic library making OpenGL work with C#, already including all the other stuff you need (so no need for glew and whatelse).
So if you have experience in C++, choose either SFML (for 2D) or OpenTK (with some other libraries like SFML or GLEW or whatelse, really not too familiar).
For Java developers, use LWJGL.
For C# devs, use OpenTK if you're into 3D or even 2D, but for fast and pretty simple 2D development i'd choose SFML.Net.
Nice thing about those is that there are up to date nuget packages, so no manual installation required (except for the dlls, i think).
Obviously, take this advice with a good grain of salt, check all options out yourself, look at some code, try to get started with them and see what's best for you. | null | 0 | 1546108040 | False | 0 | ecte5q7 | t3_aajb7r | null | null | t1_ecsst82 | /r/programming/comments/aajb7r/how_doom_fire_was_done/ecte5q7/ | 1548231702 | 1 | t5_2fwo | r/programming | public | null |
False | gnus-migrate | t2_nvuy8 | Sorry I missed this.
You're right, I am assuming that you aren't using the DB as an integration point(i.e. you have a single client). In the case of multiple clients, then it might make more sense to do this for the sake of consistency.
Regarding round tripping to the DB I was thinking of cases where you need to insert rows in multiple tables with the generated ID being the primary key. Generating it client side allows you to batch all the inserts into a single transaction, and results in simpler code since you can construct your queries without needing access to the DB. I'm sure there are ways to do this with a generated ID, but I think they are DB specific.
I am not suggesting creating objects and using them without persisting them first, just removing an unnecessary technical dependency on the DB.
I hope I didn't misunderstand what you were trying to say. | null | 0 | 1546108053 | False | 0 | ecte6av | t3_a8vpy4 | null | null | t1_ecet0fy | /r/programming/comments/a8vpy4/why_did_we_shift_away_from_databasegenerated_ids/ecte6av/ | 1548231708 | 1 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | I think that's not the question here. You need to know how an engine works to be able to use an existing engine to your advantage, and to be able to write good code you need the experience. | null | 0 | 1546108106 | False | 0 | ecte8o4 | t3_aajb7r | null | null | t1_ect9166 | /r/programming/comments/aajb7r/how_doom_fire_was_done/ecte8o4/ | 1548231738 | -2 | t5_2fwo | r/programming | public | null |
False | NotUniqueOrSpecial | t2_3wrgy | > but with symbolic and hard links, the same exact file can have many possible ways to address it
That's not any different than in Windows.
The difference is that Windows ACLs (for all their nightmarish complexity) are a much more robust system than a pair of IDs.
> Not even inodes are unique, as hard links are just (IIUC) pointing different inodes at the same file on disk.
Not quite. The inode is the unique file. [The hardlinks are just directory references to that inode.](https://en.wikipedia.org/wiki/Hard_link#Example) | null | 0 | 1546108108 | False | 0 | ecte8sl | t3_aalc4n | null | null | t1_ect4c03 | /r/programming/comments/aalc4n/windows_file_access_performance_compared_to_linux/ecte8sl/ | 1548231740 | 36 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | Have a look at C# 8.0 code, and see if you still think that way | null | 0 | 1546108155 | False | 0 | ecteaz4 | t3_aajb7r | null | null | t1_ect0jwh | /r/programming/comments/aajb7r/how_doom_fire_was_done/ecteaz4/ | 1548231766 | 1 | t5_2fwo | r/programming | public | null |
False | LPTK | t2_eufy7 | > This is also why I loathe Scala.
What?! It sounds like you haven't used Scala seriously.
import Iterator.{from, range, single, empty}
val triples = from(1).flatMap { z =>
range(1,z).flatMap { x =>
range(x,z).flatMap { y =>
if (x * x + y * y == z * z) single((x, y, z))
else empty
}
}
}
How is the above not at least as readable as, say, the C# version below?
var triples = Enumerable.Range(1, int.MaxValue)
.SelectMany(z => Enumerable.Range(1, z), (z, x) => new {z, x})
.SelectMany(t => Enumerable.Range(t.x, t.z), (t, y) => new {t, y})
.Where(t => t.t.x * t.t.x + t.y * t.y == t.t.z * t.t.z)
.Select(t => (x: t.t.x, y: t.y, z: t.t.z));
And Scala _also_ lets you have a clean LINQ-style version, simply using a `for` comprehension:
val triples = for {
z <- from(1)
x <- range(1,z)
y <- range(x,z)
if x * x + y * y == z * z
} yield (x, y, z)
How is that not clearer than a for loop?
My point is that while you can write ugly, complicated things in any language, Scala **actually lets you write things in a readable way**, much more readable than many other languages out there, especially C++, which forces you towards the ugly side unless you stick with plain loops. | null | 0 | 1546108190 | False | 0 | ectecj7 | t3_aac4hg | null | null | t1_ecrdycm | /r/programming/comments/aac4hg/modern_c_lamentations/ectecj7/ | 1548231785 | 2 | t5_2fwo | r/programming | public | null |
False | Calavar | t2_gm1q8 | This is true. But I'd say that matters more when the big-O is significantly different. A function call is O(1) whether you use std::function or a function pointer. There is a difference in the constant factor, but [it's not](https://stackoverflow.com/a/8908153) [much in](https://github.com/jamboree/CxxFunctionBenchmark) [optimized code](https://www.boost.org/doc/libs/1_52_0/doc/html/function/misc.html#id1617815). In fact, sometimes std::function is [faster than virtual functions](https://probablydance.com/2013/01/13/a-faster-implementation-of-stdfunction/). That's a classic case of premature optimization. | null | 0 | 1546108286 | 1546108851 | 0 | ecteh39 | t3_aac4hg | null | null | t1_ectdgcu | /r/programming/comments/aac4hg/modern_c_lamentations/ecteh39/ | 1548231842 | 1 | t5_2fwo | r/programming | public | null |
False | ludonarrator | t2_gh3ls | That's why they are called Technical Artists rather than say "FX Programmers", in the games industry. | null | 0 | 1546108299 | False | 0 | ectehow | t3_aajb7r | null | null | t1_ecsyzop | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectehow/ | 1548231849 | 12 | t5_2fwo | r/programming | public | null |
False | fabiosantoscode | t2_fyr6x | We are still working on this, but it's a functioning product that you can use to keep your forks up to date, while preserving your own changes.
Soon, you will be able to update all the branches in a repository. Helpful to keep those pull requests up to date!
And you get an e-mail if rebasing or updating the branches fails at any point and you need to intervene.
We currently have a limitation where we can only do rebases every X hours, but we're working on that. | null | 0 | 1546108311 | 1546108660 | 1 | ectei7y | t3_aankii | null | null | t3_aankii | /r/programming/comments/aankii/upforksh_keep_up_to_5_forks_updated_for_free_and/ectei7y/ | 1548231856 | 5 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | I agree that the C++ route is very extreme, so I think just playing with all the different libraries out there (especially more abstract ones like Monogame, SFML, etc) can be a big plus. Of course unity is nice to learn with, but I think knowing how much effort is put into stuff like that and learning to code for games (fast, efficient code, that can be revisited and still understood), is not really taught when you only do scripting.
There's no "best way" to learn stuff like this, it's a rollercoaster, you're going to try a thousand things, give up a few times, try new things, until eventually you come back to something you gave up on, just to find that you're now accomplishing that with ease. | null | 0 | 1546108365 | False | 0 | ectekr4 | t3_aajb7r | null | null | t1_ectaqfs | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectekr4/ | 1548231887 | 2 | t5_2fwo | r/programming | public | null |
False | LPTK | t2_eufy7 | > very powerful language but it's so easy to write unreadable code in it
I agree with that. I think it comes with most "very powerful languages", not just Scala.
But _that does not mean it's impossible to write readable code in it_.
For example see [my other answer here](https://www.reddit.com/r/programming/comments/aac4hg/modern_c_lamentations/ectecj7/).
> Scala is such a good example of this.
So I completely disagree with this. Scala is not a good example of a language like C++, so crippled that providing modern abstractions is "not worth it". In fact, it's quite the opposite. Like Haskell, Scala shines with its easy-to-use abstraction capabilities. | null | 0 | 1546108432 | False | 0 | ectentz | t3_aac4hg | null | null | t1_ecrecnn | /r/programming/comments/aac4hg/modern_c_lamentations/ectentz/ | 1548231925 | 2 | t5_2fwo | r/programming | public | null |
False | seamsay | t2_1zos4clf | :( I thought it was funny... | null | 0 | 1546108660 | False | 0 | ectext0 | t3_aajb7r | null | null | t1_ectc8as | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectext0/ | 1548232049 | 7 | t5_2fwo | r/programming | public | null |
False | LeeHide | t2_tqbvo | It was, don't worry about the h8terz.
Also, why the PascalCase class name and then this_shit_for_functions? | null | 0 | 1546108738 | False | 0 | ectf18i | t3_aajb7r | null | null | t1_ectext0 | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectf18i/ | 1548232091 | 2 | t5_2fwo | r/programming | public | null |
False | larsga | t2_1s7k | I've been writing Scala at work for 3 years now.
It's not specifically about loops, but the whole design of the language and the accumulation of complexity which makes it far too tempting to write complex unreadable code.
I can avoid the bits I don't like and keep it readable, but I work with other people, and I use libraries and frameworks written by other people. | null | 0 | 1546108801 | False | 0 | ectf3y9 | t3_aac4hg | null | null | t1_ectecj7 | /r/programming/comments/aac4hg/modern_c_lamentations/ectf3y9/ | 1548232124 | 1 | t5_2fwo | r/programming | public | null |
False | jtredact | t2_mo87q | Not regardless of outcome, but rather Facebook would ensure success by asking practical frontend questions that they knew were right in his wheel house... regardless of whether or not there is a regular interview track with the questions they asked.
Point is he would not be subject to same "laws" of interviewing as your average nameless applicant. If he wants to believe otherwise, then certainly we aren't going to change his mind. | null | 0 | 1546108890 | False | 0 | ectf7xs | t3_aaco1d | null | null | t1_ecschu2 | /r/programming/comments/aaco1d/things_i_dont_know_as_of_2018/ectf7xs/ | 1548232203 | 0 | t5_2fwo | r/programming | public | null |
False | skeeto | t2_3em9l | Thanks! By phases do you mean the "burner" turning on and off? | null | 0 | 1546108946 | False | 0 | ectfac0 | t3_aajb7r | null | null | t1_ectctey | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectfac0/ | 1548232232 | 4 | t5_2fwo | r/programming | public | null |
False | gnus-migrate | t2_nvuy8 | Nice find! Although in the future you can just create a separate image for each platform which is relatively easy to do and use those for cross compilation instead of having to rely on an untrusted third party image you found on page 2 of your search results. This allows you to better manage the versions of your toolchains as well. | null | 0 | 1546109011 | False | 0 | ectfd8b | t3_aaljp1 | null | null | t3_aaljp1 | /r/programming/comments/aaljp1/jni_crosscompilation_with_docker_a_guy_with_ego/ectfd8b/ | 1548232268 | 1 | t5_2fwo | r/programming | public | null |
False | anechoicmedia | t2_11w2mr | If you don't at least know the fundamental constraints and algorithms of the tools and platforms you are using, you won't be able to reason effectively about their costs. | null | 0 | 1546109107 | False | 0 | ectfhcq | t3_aajb7r | null | null | t1_ect3nb6 | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectfhcq/ | 1548232319 | 6 | t5_2fwo | r/programming | public | null |
False | kirbyfan64sos | t2_lzxoq | Haha yeah, I admittedly stopped following the GitHub repo because I never knew what was actually going on... 😅 | null | 0 | 1546109501 | False | 0 | ectfyvu | t3_aaml78 | null | null | t1_ectcyws | /r/programming/comments/aaml78/rpcs3_ps3_emulator_november_2018_progress_report/ectfyvu/ | 1548232535 | 21 | t5_2fwo | r/programming | public | null |
False | mindcandy | t2_3m9b5 | The sidebar of r/OpenGL has some good tutorials. | null | 0 | 1546109946 | False | 0 | ectgjqo | t3_aajb7r | null | null | t1_ecsp9lv | /r/programming/comments/aajb7r/how_doom_fire_was_done/ectgjqo/ | 1548232823 | 3 | 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.