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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
True | forcedtoregister | null | [MigLayout](http://www.miglayout.com/) helps. I pretty much consider it a part of swing now. | null | 0 | 1316347972 | False | 0 | c2kqmq2 | t3_kje6b | null | t1_c2kqmq2 | t3_kje6b | null | 1427615114 | 6 | t5_2fwo | null | null | null |
True | the_opinion | null | I'm devastated | null | 0 | 1316348220 | False | 0 | c2kqn4z | t3_ki83r | null | t1_c2kqn4z | t1_c2kqf0t | null | 1427615113 | 1 | t5_2fwo | null | null | null |
True | wolf550e | null | Why use zlib? It's not exactly state of the art. Look at Google Snappy for a really fast compressor. Or LZO 2.05 and up, which is a response to Google Snappy. Snappy (used to be known as zippy before it was open sourced) is used in BigTable and ProtocolBuffers (it actually uses a protocol buffer varint as its header).
Notice that zlib uses a checksum of the uncompressed data (a crc32 for gzip format and adler32 for deflate format data). Fast compressors don't have checksums because the crc32 takes up 40% of decompression time of gunzip (when you implement huffman decoding efficiently using lookup tables).
Compression is always about balancing io block latency and cpu cycles. Change the CPU power or the io system and your compression goals change. | null | 0 | 1316348332 | False | 0 | c2kqnbp | t3_kjete | null | t1_c2kqnbp | t3_kjete | null | 1427615116 | 8 | t5_2fwo | null | null | null |
True | mikehaggard | null | >I would also like to clarify that I was not using "modern" in the strictly chronological sense,
Saivo, I've read your posts and you seem to plain and simple have an aversion against Java that's based on nothing but vague emotions.
It's probably something like the *"cool guy on the block that got the chick I digged happened to use Java"*, or *"there was this group of programmers at my university that used Java to build great software, but they wouldn't let me in since I suck at programming"*
So now you feel you must hate Java and you're desperately trying to come up with rational arguments about why Java is bad, but till thus far your so called arguments are a complete joke. | null | 0 | 1316348398 | False | 0 | c2kqnfc | t3_kgq62 | null | t1_c2kqnfc | t1_c2k665z | null | 1427615117 | 1 | t5_2fwo | null | null | null |
True | phaker | null | > What's even more irritating is that there are lots of third-party layout managers, but the ones I tried seem to suck as well.
Have you seen [mig layout](http://www.miglayout.com/)? If not, check out their pdf guide.
I didn't use it much, but from my limited experience it's one of the most pleasant ways to lay out GUI. Not "most pleasant in Swing" (which wouldn't be much, Swing sucks) but one of the most pleasant overall. I actually missed it once or twice when doing stuff in Qt. | null | 0 | 1316348400 | False | 0 | c2kqnfj | t3_kje6b | null | t1_c2kqnfj | t1_c2kqfxp | null | 1427615117 | 4 | t5_2fwo | null | null | null |
True | banuday | null | Actually, polymorphism is heavily used by ORMs to seamlessly track changes to objects and facilitate lazy fetching of associations. For example, Hibernate creates dynamic proxies of entity classes which are code-generated subclasses of the entity class which is aware of its persistent context. This allows Hibernate to intercept calls to setters to mark objects in the session as dirty, so that the session flush will generate the appropriate update statements. All of this is completely transparent to the application because of polymorphism. | null | 0 | 1316348800 | True | 0 | c2kqo3m | t3_ki83r | null | t1_c2kqo3m | t1_c2kqex3 | null | 1427615126 | 2 | t5_2fwo | null | null | null |
True | christophski | null | It depends on the operating system. I haven't tested it on windows, but on linux you can press altgr + e + ' to get é, or altgr + e + ` to get è. | null | 0 | 1316348975 | False | 0 | c2kqodq | t3_kicbo | null | t1_c2kqodq | t1_c2kqhmj | null | 1427615129 | 1 | t5_2fwo | null | null | null |
True | gnuvince | null | I agree completely. What I'm arguing for is that learning assembly not be done in a single step (1. Learn x86 assembly), but instead in steps (1. Learn about machine architecture, 2. Learn basics of assembly with MIPS, 3. Learn x86 assembly). It might just be me, but I feel that the details of any given topic are easier to understand if you already have a good general idea. | null | 0 | 1316350126 | False | 0 | c2kqqbv | t3_khxzd | null | t1_c2kqqbv | t1_c2kqaph | null | 1427615155 | 1 | t5_2fwo | null | null | null |
True | CafeNero | null | yes sure. Firstly I am a researcher in finance and my code is 95%, matlab, 5% C. R us getting traction for good reasons, but it has one shortcoming in my opinion that makes it a no go - it is great for research but not for production. You need a language with a strong testing debugging profiling environment, and libraries written with this in mind. R sounds great so long as its intended user is another R user. Not so much when it needs to go to the IT team who manage the servers, the front office who don't code, the middle office that expect it to generate reports. | null | 0 | 1316350160 | False | 0 | c2kqqdq | t3_khx5g | null | t1_c2kqqdq | t1_c2kny3a | null | 1427615155 | 3 | t5_2fwo | null | null | null |
True | banuday | null | > Isn't structural subtyping the same as duck-typing?
I wouldn't say that it is precisely the same, more like an approximation within the confines of a object system where the interfaces are hard-wired. For example, in Ruby which is *truly* duck-typed, structural subtyping couldn't definitely infer that an object can accept a message because class definitions are open and while the object may not have the method at "compile-time", the method can be added dynamically at runtime. Structural subtyping is much more restricted because it can only be applied at compile time.
> I'll refine my sentence anyway, only allowing hard-wiring of interfaces at class-design time makes for a very weak system.
Yes, that is true of languages with weaker type systems (i.e. Java) vs stronger type systems (i.e. Scala). But that is a type system issue, completely orthogonal to OOP. Structural subtyping allows expression of something like dynamic method dispatch, quintessentially OOP, in a statically typed language.
Wasn't that what this thread was originally about, OOP vs Generic Programming? | null | 0 | 1316350207 | True | 0 | c2kqqgy | t3_kikut | null | t1_c2kqqgy | t1_c2kqgfx | null | 1427615157 | 3 | t5_2fwo | null | null | null |
True | dchestnykh | null | * Snappy is written in C++.
* LZO is GPL/commercial.
* zlib is everywhere.
Plus, both Snappy and LZO are fast, yes, but they are not as good as zlib in compression ratio. Between Snappy, zlib, and LZMA, zlib provides a pretty good balance between speed and compression for his needs. | null | 0 | 1316350378 | True | 0 | c2kqqry | t3_kjete | null | t1_c2kqqry | t1_c2kqnbp | null | 1427615161 | 18 | t5_2fwo | null | null | null |
True | Zandt88 | null | Brilliant. Asserting polarity with magnetic attraction and repulsion. | null | 0 | 1316350731 | False | 0 | c2kqrde | t3_kj1na | null | t1_c2kqrde | t3_kj1na | null | 1427615168 | 1 | t5_2fwo | null | null | null |
True | novabyte | null | IIRC MigLayout has been considered for inclusion into the Java stdlib a couple of times. It definitely makes GUI layouts easier to manage. I also like DesignGridLayout although there were a few bugs last time I used it and it hasn't seen any updates in a while. | null | 0 | 1316351132 | False | 0 | c2kqs3s | t3_kje6b | null | t1_c2kqs3s | t1_c2kqmq2 | null | 1427615178 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | People should write their own layout managers more often. It's not that hard and kind of fun actually. | null | 0 | 1316351180 | False | 0 | c2kqs7b | t3_kje6b | null | t1_c2kqs7b | t3_kje6b | null | 1427615179 | 3 | t5_2fwo | null | null | null |
True | henk53 | null | Good one... sad this still hasn't been included in the JDK. | null | 0 | 1316351200 | False | 0 | c2kqs8p | t3_kje6b | null | t1_c2kqs8p | t1_c2kqmq2 | null | 1427615180 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Who on earth says that? Nobody I've ever heard of. Swing is terrible. | null | 0 | 1316351296 | False | 0 | c2kqsgj | t3_kje6b | null | t1_c2kqsgj | t1_c2kqi1k | null | 1427615182 | 3 | t5_2fwo | null | null | null |
True | uriel | null | Vector is deprecated in Go, don't use it, use slices instead.
And yes, generics would be a nice addition if somebody can come up with a design that doesn't harm the very valuable properties the language has already, in practice one very rarely misses generics, and the simplicity and clarity of the language and the main implementation is extremely refreshing. | null | 0 | 1316351717 | False | 0 | c2kqt8t | t3_kikut | null | t1_c2kqt8t | t1_c2kozw7 | null | 1427615194 | 1 | t5_2fwo | null | null | null |
True | uriel | null | Go is being used in production already [by quite a few organizations](http://go-lang.cat-v.org/organizations-using-go). | null | 0 | 1316351783 | False | 0 | c2kqtdv | t3_kikut | null | t1_c2kqtdv | t1_c2kjngm | null | 1427615195 | 1 | t5_2fwo | null | null | null |
True | aw2551 | null | I remember native Java running [chips](http://www.javaworld.com/javaworld/jw-11-1998/jw-11-idgns-javachip.html) being talked about. | null | 0 | 1316351838 | False | 0 | c2kqthx | t3_kjf91 | null | t1_c2kqthx | t3_kjf91 | null | 1427615196 | 12 | t5_2fwo | null | null | null |
True | uriel | null | With multiple inheritance and metaclasses you can write infinitely more convoluted code than with GOTO.
Add in exceptions that are basically the equivalent of COME FROM, and you have a recipe for some huge mountain of rotting spaghetti. | null | 0 | 1316352061 | False | 0 | c2kqtzv | t3_k6jko | null | t1_c2kqtzv | t1_c2hz42x | null | 1427615203 | 1 | t5_2fwo | null | null | null |
True | Taladar | null | > first to file
I propose referring to that as "force to file" since that is essentially what it will result in. It forces even those of us who would rather remove the patent system today than tomorrow to file patents. What an insane concept. | null | 0 | 1316352314 | False | 0 | c2kquia | t3_khvyw | null | t1_c2kquia | t1_c2khhzc | null | 1427615210 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316352352 | False | 0 | c2kqulb | t3_kj1na | null | t1_c2kqulb | t1_c2kn3oa | null | 1427615213 | 2 | t5_2fwo | null | null | null |
True | Taladar | null | So we are back to "I don't want to live on this planet anymore"? | null | 0 | 1316352412 | False | 0 | c2kqupn | t3_khvyw | null | t1_c2kqupn | t1_c2kiuci | null | 1427615214 | 2 | t5_2fwo | null | null | null |
True | tgehr | null | If it could, it would not be desirable in my opinion, because what is a template argument and what is not has quite big semantic implications, eg template arguments are computed at compile time, so it is nice to have. Also, it can even be shorter in some cases, because if there is only one argument, the parens can be left out, eg
Vector!int v;
To answer your question, because it is ambiguous semantically.
int delegate() foo(int x=5)(int xx){
return (int xxx){return x+xx+xxx;};
}
This declares a template function that returns a function without parameters that sums up the template parameter x with the runtime parameter xx and adds the result it to its own argument xxx. x has a default value, which means it can be left out, together with the parens.
assert(foo(3)(2)==10 && foo!()(3)(2)==10);
assert(foo!(3)(2)(1)==6 && foo!3(2)(1)==6);
Leaving away the template arguments is desirable in many cases, eg when you want to transparently replace a function implementation with a templated one.
| null | 0 | 1316352927 | False | 0 | c2kqvsh | t3_kikut | null | t1_c2kqvsh | t1_c2kkuht | null | 1427615235 | 1 | t5_2fwo | null | null | null |
True | wolf550e | null | A pure C port, using Google's own code. It is a bit faster than the original:
https://github.com/zeevt/csnappy
If you submit bug reports I'll fix them.
It's BSD licensed, copyright by Google. Any of it I wrote I'll donate to them if they want.
Benchmarks:
http://driverdev.linuxdriverproject.org/pipermail/devel/2011-April/015577.html
Versus zlib, Snappy costs you three times less cpu time to decompress.
The objective is to save IO latency or bandwidth. Is your io cost per 64kb RAID stripe, 4kb fs block, 1.5kb network packet? How many of those can you avoid by compression, and how many milliseconds of cpu will it cost you? How many requests/second are you serving? | null | 0 | 1316353323 | False | 0 | c2kqwmw | t3_kjete | null | t1_c2kqwmw | t1_c2kqqry | null | 1427615237 | 23 | t5_2fwo | null | null | null |
True | tgehr | null | Well, it would shift the decision of what is a template parameter and what is not from the parsing stage to the semantic stage. Furthermore, the parser would have to allow types as function arguments, like this:
foo(int***)(1);
Therefore, it would make both parsing and semantic analysis somewhat slower, but I am not sure it would be conceivable.
| null | 0 | 1316353602 | False | 0 | c2kqx9e | t3_kikut | null | t1_c2kqx9e | t1_c2kl7ir | null | 1427615246 | 2 | t5_2fwo | null | null | null |
True | tgehr | null | Yes, his point was, that there are cases where it is semantically ambiguous, it could not even be resolved by the binding stage in those cases. | null | 0 | 1316353742 | False | 0 | c2kqxjz | t3_kikut | null | t1_c2kqxjz | t1_c2kpjo7 | null | 1427615249 | 1 | t5_2fwo | null | null | null |
True | abattle | null | Snappy has been on my list of compressors to test out. However, and as I've already mentioned in the article, due to the reliance on NTFS sparse files, unless at least 64 Kbytes of reduction is achieved in data-size, there would be 0 byte reduction in file size.
I'll still try it. But first I wanted to see realistically how well the scheme works regardless of performance. Now I'll try to improve the performance regardless of the compressor, then try different compressors to see which gives the best balance. However as dchestnykh already said, zlib does provide a pretty balanced approach. | null | 0 | 1316353847 | False | 0 | c2kqxtc | t3_kjete | null | t1_c2kqxtc | t1_c2kqnbp | null | 1427615254 | 7 | t5_2fwo | null | null | null |
True | Wonnk13 | null | ok, wow. that makes a lot of sense. In that case i guess i would go with python too. | null | 0 | 1316354138 | False | 0 | c2kqyhx | t3_khx5g | null | t1_c2kqyhx | t1_c2kqqdq | null | 1427615263 | 3 | t5_2fwo | null | null | null |
True | andralex | null | The problem is, Vector was just an example of a multitude of containers. The huge problem with slices is dogfood-related - they are "magic" because the language features proposed to programmers were not enough for expressing a simple abstraction. Reserving "special" features for the language is a terrible way to go about programming language design. | null | 0 | 1316354150 | False | 0 | c2kqyit | t3_kikut | null | t1_c2kqyit | t1_c2kqa42 | null | 1427615263 | 5 | t5_2fwo | null | null | null |
True | dchestnykh | null | THANK YOU! I searched the whole internet yesterday looking for C implementation, but all I could find is a C interface to Google's C++. I'll check it out.
As for OP's objective, I think it was saving disk space at a reasonable drop in speed. | null | 0 | 1316354245 | False | 0 | c2kqyqt | t3_kjete | null | t1_c2kqyqt | t1_c2kqwmw | null | 1427615266 | 7 | t5_2fwo | null | null | null |
True | tgehr | null | > Pop quiz, without knowing anything about C, does the expression
> C::value_type refer to a member function, an inner class, an inner
> typedef, or a member function pointer or a static constant integer?
> Answer: You don't know, because it is impossible to know.
Why would you need to know before the template is instantiated? | null | 0 | 1316354311 | False | 0 | c2kqyw9 | t3_kikut | null | t1_c2kqyw9 | t1_c2kmn09 | null | 1427615269 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316354443 | False | 0 | c2kqz7l | t3_ki83r | null | t1_c2kqz7l | t1_c2kqkhj | null | 1427615272 | 1 | t5_2fwo | null | null | null |
True | wolf550e | null | If you feel you need entropy coding, you may want to use the LZ engine from Snappy with a good huffman coder (everyone says arithmetic coders are always slower) and no checksum. That should give you the compression ratio of zlib but significantly faster.
Zlib was just not written with modern CPUs in mind. | null | 0 | 1316354456 | False | 0 | c2kqz8s | t3_kjete | null | t1_c2kqz8s | t1_c2kqxtc | null | 1427615272 | 3 | t5_2fwo | null | null | null |
True | andralex | null | Yah, it's a simple fact. Not worth riling over it. | null | 0 | 1316354527 | False | 0 | c2kqzex | t3_kikut | null | t1_c2kqzex | t1_c2koofg | null | 1427615278 | 3 | t5_2fwo | null | null | null |
True | davvblack | null | I love this quote. | null | 0 | 1316354745 | False | 0 | c2kqzxf | t3_kjhvo | null | t1_c2kqzxf | t3_kjhvo | null | 1427615281 | 4 | t5_2fwo | null | null | null |
True | tgehr | null | for _, v := range g.Neighbors(p.v) {
d.visit(v, p.depth+1, p) // assumes all vertex distances to be equal to 1
}
Ergo, his 'shortest path' implementation does not require Dijkstras algorithm at all. A simple breadth first search is both easier and more efficient. For the example to make sense, the Graph interface would have to be able to specify vertex distances. | null | 0 | 1316354763 | False | 0 | c2kqzz0 | t3_kikut | null | t1_c2kqzz0 | t3_kikut | null | 1427615282 | 4 | t5_2fwo | null | null | null |
True | Svenstaro | null | Thanks for the heads-up. | null | 0 | 1316354783 | False | 0 | c2kr00s | t3_kjebe | null | t1_c2kr00s | t1_c2kq8g1 | null | 1427615282 | 2 | t5_2fwo | null | null | null |
True | andralex | null | The syntax A(list1)(list2) cannot be parsed without symbol table information. We believe that requiring symbol tables during parsing is a mistake (that e.g. has exacted an enormous toll on C++) so we are using A!(list1)(list2) for instantiation. The advantage of using "!" as a binary operator is that when you have a single argument you don't need the parens, which makes for very terse syntax. For example, to!int("123") is a function call that returns 123.
I think retrofitting "<" and ">" as parens is a terrible mistake, which I discuss in TDPL and [here](http://drdobbs.com/high-performance-computing/217801225?pgno=2). Less-than and greater-than don't pair! | null | 0 | 1316354943 | False | 0 | c2kr0e9 | t3_kikut | null | t1_c2kr0e9 | t1_c2kkqif | null | 1427615287 | 5 | t5_2fwo | null | null | null |
True | Bjartr | null | [Java issues](http://www.google.com/search?rlz=1C1CHFX_enUS449US449&gcx=c&ix=c1&sourceid=chrome&ie=UTF-8&q=java+issues#q=java+issues&hl=en&rlz=1C1CHFX_enUS449US449&prmd=imvns&sa=X&ei=EPt1TuraIOT30gGOwKS1BQ&ved=0CC0QpwUoBg&source=lnt&tbs=cdr:1%2Ccd_min%3A1998%2Ccd_max%3A1%2F1%2F1999&tbm=&bav=on.2,or.r_gc.r_pw.r_cp.&fp=23fe161d3effd669&biw=1440&bih=799) from 1998 | null | 0 | 1316354945 | False | 0 | c2kr0ef | t3_kjf91 | null | t1_c2kr0ef | t3_kjf91 | null | 1427615287 | -2 | t5_2fwo | null | null | null |
True | mrargh | null | Except in this case it's IE following the specs and. The rest not. Thanks for playing though. | null | 0 | 1316355072 | False | 0 | c2kr0q3 | t3_kicbo | null | t1_c2kr0q3 | t1_c2klise | null | 1427615291 | 2 | t5_2fwo | null | null | null |
True | bobbarnes1981 | null | not a programmer but definitely a computer geek. | null | 0 | 1316355185 | False | 0 | c2kr113 | t3_kjhvo | null | t1_c2kr113 | t3_kjhvo | null | 1427615295 | 29 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316355412 | False | 0 | c2kr1lb | t3_kjhvo | null | t1_c2kr1lb | t3_kjhvo | null | 1427615302 | 125 | t5_2fwo | null | null | null |
True | floyd431 | null | Yep ... Swing has a lot of power, which means that there are lots of ways to do the same thing. Having said that, I get frustrated reading novice programmer's code because it so often makes simple things seem complicated.
I don't see the problem with nested layouts ... a lot of my applications start with BorderLayout and then nest FlowLayout or BoxLayout inside the BorderLayout's sections ... frequently the nestings go three or four layers deep, but when done logically I don't find it hard to read.
(I've also got a lot of applications that use GridBagLayout ... I've got a love/hate relationship with that one; it can do anything, but it's easy to get confused).
Check out http://www.swixml.org/ -- it's a nice way to make your swing code readable. | null | 0 | 1316355456 | False | 0 | c2kr1oo | t3_kje6b | null | t1_c2kr1oo | t1_c2kqi1k | null | 1427615304 | 1 | t5_2fwo | null | null | null |
True | Bibblejw | null | One similar one:
"The trouble with making something completely foolproof is that you always underestimate the ingenuity of complete fools"
Also Mostly Harmless, but I may have got the wording slightly off. | null | 0 | 1316355470 | False | 0 | c2kr1q1 | t3_kjhvo | null | t1_c2kr1q1 | t1_c2kqzxf | null | 1427615304 | 23 | t5_2fwo | null | null | null |
True | dallen | null | Snap Circuits do it really well too | null | 0 | 1316355510 | False | 0 | c2kr1ts | t3_kj1na | null | t1_c2kr1ts | t1_c2kn7al | null | 1427615306 | 1 | t5_2fwo | null | null | null |
True | xixor | null | http://dilbert.com/strips/comic/1994-06-08/ | null | 0 | 1316355619 | False | 0 | c2kr23z | t3_kjhvo | null | t1_c2kr23z | t3_kjhvo | null | 1427615309 | 9 | t5_2fwo | null | null | null |
True | dallen | null | I got the Snap Circuits Jr kit for my kids last year (7 and 5). They really had a lot of fun with it. I'd definitely recommend it or any of the Snap Circuit kits | null | 0 | 1316355737 | False | 0 | c2kr2ex | t3_kj1na | null | t1_c2kr2ex | t1_c2kog5e | null | 1427615314 | 1 | t5_2fwo | null | null | null |
True | webby_mc_webberson | null | This is my favourite Hitchhiker's Guide to the Galaxy quote. It doesn't only apply to programming though, it applies to *everything* technical. | null | 0 | 1316355776 | False | 0 | c2kr2ic | t3_kjhvo | null | t1_c2kr2ic | t3_kjhvo | null | 1427615315 | 16 | t5_2fwo | null | null | null |
True | dallen | null | The bottom-up approach to learning programming begins with a basic understanding of logic gates and circuits before moving onto machine language. This is exactly how I learned programming | null | 0 | 1316355875 | False | 0 | c2kr2rm | t3_kj1na | null | t1_c2kr2rm | t1_c2kn3oa | null | 1427615318 | 1 | t5_2fwo | null | null | null |
True | Stormflux | null | ... as anyone who's ever had to repair a Mac can attest to. | null | 0 | 1316355881 | False | 0 | c2kr2sc | t3_kjhvo | null | t1_c2kr2sc | t3_kjhvo | null | 1427615318 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Programmers may have a difficult time accepting this but believe it or not, logic and thought does not originate from programming. It is programming that originates from thought as does many other things.
* programming &sub; thought
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
Oh yea, almost forgot: </touch-of-sarcasm> | null | 0 | 1316355926 | False | 0 | c2kr2wc | t3_kjhvo | null | t1_c2kr2wc | t3_kjhvo | null | 1427615321 | 42 | t5_2fwo | null | null | null |
True | chengiz | null | Forget the bulletpoints at the right of this subreddit - yeah, there - but this quote is *not even a programming quote*. | null | 0 | 1316356346 | False | 0 | c2kr424 | t3_kjhvo | null | t1_c2kr424 | t3_kjhvo | null | 1427615344 | 13 | t5_2fwo | null | null | null |
True | mishagale | null | Actually, he was at least an amateur programmer. In *Last Chance To See*, he describes writing a program to calculate the volume of a [Megapode](http://en.wikipedia.org/wiki/Megapode) nest. | null | 0 | 1316356374 | False | 0 | c2kr454 | t3_kjhvo | null | t1_c2kr454 | t1_c2kr113 | null | 1427615337 | 45 | t5_2fwo | null | null | null |
True | wolf550e | null | I don't believe NTFS compression can find any redundancy in data that was compressed with zlib setting=6. If NTFS achieves gains when storing compressed data, it is by storing 4kb blocks instead of 64kb blocks. If you stored compressed chunks in individual files which were not NTFS-compressed, they would be stored in 4kb blocks and the sum of the space used on disk for all files would be the same as the space on disk of the single NTFS-compressed file containing the same data. I don't know whether the lookup by filename or offset in a NTFS-compressed file would be faster. | null | 0 | 1316356404 | False | 0 | c2kr484 | t3_kjete | null | t1_c2kr484 | t3_kjete | null | 1427615338 | 2 | t5_2fwo | null | null | null |
True | BlatantFootFetishist | null | Interesting article, but "easy threading" doesn't really exist, of course. Humans don't have the intellectual capacity to create single-threaded apps that don't have bugs, let alone multi-threaded apps, which are an order of magnitude more complex. | null | 0 | 1316356640 | False | 0 | c2kr4w8 | t3_kjebe | null | t1_c2kr4w8 | t3_kjebe | null | 1427615346 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | > Our society doesn't incentivize people to teach, because it's not directly profitable
that does not make the slightest bit of sense. There are many things that are not directly profitable that make plenty of money. Think capital goods. Why can people earn a living building factories or indeed, programming computers? Because those programs and factories are in turn used in profitable enterprises. We need to start looking at education as a capital good, literally an investment. Education needs more capitalism. Capitalism by the parents who should take care that their offspring learns something useful so that it will later be able to earn it's living. Capitalism in schools so that there is competition and the continuous improvement that goes along with it. Finally, capitalism in financing of education so that it will end up being cost (AND) effective. | null | 0 | 1316356696 | False | 0 | c2kr51w | t3_kgbzq | null | t1_c2kr51w | t1_c2k1j1w | null | 1427615349 | 1 | t5_2fwo | null | null | null |
True | danharaj | null | Not programming. | null | 0 | 1316356829 | False | 0 | c2kr5g3 | t3_kjhvo | null | t1_c2kr5g3 | t3_kjhvo | null | 1427615354 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | He was definitely an early adopter, which in the UK in the early 1980s meant at least typing in programs copied from INPUT magazine and learning to code your local flavour of BASIC. | null | 0 | 1316356907 | False | 0 | c2kr5oa | t3_kjhvo | null | t1_c2kr5oa | t1_c2kr454 | null | 1427615356 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | since when does the market provision scarcity? From the POV of state-run anything you could make the same argument about, well, anything. "What if you have 10000 customers wanting to buy 500 pieces of bread". That's simply not a problem in an established market economy. You think in terms of ivy league schools. But why? Because schooling across the board plain sucks. So, forming an elite or concentrating efforts becomes important (see the elite uni initative in Germany). In market terms that doesn't matter because once the free market takes hold there won't be only dozen good schools in one country, there will be one in every city or even villages. Just like with retailers or groceres ... | null | 0 | 1316356996 | False | 0 | c2kr5xm | t3_kgbzq | null | t1_c2kr5xm | t1_c2k31t6 | null | 1427615359 | 1 | t5_2fwo | null | null | null |
True | jseigh | null | Provisional patents are cheap relative to regular patent costs. However when you file for the regular patent based on the provisional patent you can't expand or add to the claims. If you let the provisional patent expire without filing on it, it doesn't count as publication or prior art of that idea. Someone else could file and get a patent application on that idea.
My understanding of them anyway. The new law may have made changes in this area.
| null | 0 | 1316357002 | False | 0 | c2kr5y3 | t3_khvyw | null | t1_c2kr5y3 | t1_c2kkz6h | null | 1427615359 | 1 | t5_2fwo | null | null | null |
True | wolf550e | null | The filesystem page cache probably stores data compressed by NTFS in uncompressed state. But in his implementation, if I request only two wikipedia articles, which happen to be in different "chunks", again and again, he will waste heat on zlib decompressing the same data again and again.
If his app is a web app, I would render each page, zlib compress it, store it as an individual file to save as many 4kb blocks of storage as possible, and serve it as-as ([sendfile](http://linux.die.net/man/2/sendfile)) using http compression. Then the client would have to decompress it instead of the server. And the code to do all that is already there in a caching proxy. | null | 0 | 1316357065 | False | 0 | c2kr64b | t3_kjete | null | t1_c2kr64b | t1_c2kqyqt | null | 1427615361 | 3 | t5_2fwo | null | null | null |
True | TKN | null | ISTR there was a somewhat similar scene _Dirk Gently's Holistic Detective Agency_ too. | null | 0 | 1316357104 | False | 0 | c2kr690 | t3_kjhvo | null | t1_c2kr690 | t1_c2kr454 | null | 1427615363 | 3 | t5_2fwo | null | null | null |
True | bobbarnes1981 | null | I stand corrected. | null | 0 | 1316357394 | False | 0 | c2kr728 | t3_kjhvo | null | t1_c2kr728 | t1_c2kr454 | null | 1427615374 | 2 | t5_2fwo | null | null | null |
True | 4ad | null | What other containers? Every container implemented with slices can hold any kind of data.
The stated problem simply does not exist. Go interfaces are very different than pick-your-favorite-language interfaces and solve every problem you might solve with generics in other language.
Generic containers, abstract algorithms that operate on many kinds of data, all these work as expected because of the way Go interfaces work. And you don't even have to do anything special, it just works without even thinking about it. I think calling Go interfaces as such was a bad idea because people just assume they are the same old stuff and don't bother studying the new model at all!
It would be great if people studied the language as presented instead of trying to map knowledge gained from other languages. The language is useful because it's different. It also would be great if people focused on problems and not on mechanisms for solving those problems in different languages.
It would be even better if people tried to used the language before complaining some feature does not exist.
| null | 0 | 1316357591 | False | 0 | c2kr7mw | t3_kikut | null | t1_c2kr7mw | t1_c2kqyit | null | 1427615382 | 0 | t5_2fwo | null | null | null |
True | dagbrown | null | I'd hardly call Douglas Adams a non-programmer.
But that's not even close to the best quote from that book. Here's my favorite, in which he debunks all of the people who dismiss astrology as being crap:
> In astrology the rules happen to be about
stars and planets, but they could be about ducks and drakes for
all the difference it would make. It's just a way of thinking about
a problem which lets the shape of that problem begin to emerge.
The more rules, the tinier the rules, the more arbitrary they are,
the better. It's like throwing a handful of fine graphite dust on a
piece of paper to see where the hidden indentations are. It lets
you see the words that were written on the piece of paper above
it that's now been taken away and hidden. The graphite's not
important. It's just the means of revealing their indentations. So
you see, astrology's nothing to do with astronomy. It's just to do
with people thinking about people."
That one bit made me realize a whole lot about people--and about problem solving, and a bunch of other things--that I had never seen before. Douglas Adams was a genius at showing you things that were in front of you all the time, but seeing them in a completely fresh light that totally changes the way you see them. | null | 0 | 1316358044 | False | 0 | c2kr8y6 | t3_kjhvo | null | t1_c2kr8y6 | t3_kjhvo | null | 1427615400 | 12 | t5_2fwo | null | null | null |
True | Taladar | null | It is an easy mistake to make though, thinking that logic and thought are exclusive to programming I mean. Just consider how illogical and thoughtless many aspects of our society are designed. | null | 0 | 1316358192 | False | 0 | c2kr9cx | t3_kjhvo | null | t1_c2kr9cx | t1_c2kr2wc | null | 1427615404 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316358440 | False | 0 | c2kra2z | t3_kjhvo | null | t1_c2kra2z | t1_c2kr2sc | null | 1427615421 | -1 | t5_2fwo | null | null | null |
True | mishagale | null | Perhaps thinking of *The Salmon of Doubt*, where Dirk programmed a computer to speech-synthesise a list of names, to try and find out the name of a dog? At least, I think it was *Salmon*, I do remember that the dog was named Kierkegaard. | null | 0 | 1316358480 | False | 0 | c2kra7s | t3_kjhvo | null | t1_c2kra7s | t1_c2kr690 | null | 1427615416 | 4 | t5_2fwo | null | null | null |
True | hamcake | null | That is so cool. Makes it into a game!
Looks like Makershed is [selling them for $99](http://www.makershed.com/ProductDetails.asp?ProductCode=MKGK19) | null | 0 | 1316358635 | False | 0 | c2kraoi | t3_kj1na | null | t1_c2kraoi | t1_c2kpxvr | null | 1427615423 | 1 | t5_2fwo | null | null | null |
True | EdgarVerona | null | I agree with your statement that education should be seen as an investment: however, how would the introduction of more capitalism help that? The concept of seeing education as an investment is in no way tied to a specific economic system. People can "invest" in something for personal improvement, for the benefit of those around them, for the knowledge they gain in how to resolve problems themselves: all of these concepts are separate and unrelated to Capitalism.
I also agree that continuous improvement via competition would be a potentially beneficial concept, but how would we avoid a situation where those who cannot afford to participate in a privatized system become a permanent underclass?
Furthermore, why is it presumed that continuous improvement is a result of competition via Capitalism? There are many forms of competition, and many potential motivations for a process to be continuously improved.
One of the biggest problems I see is that we often take as assumed that the motivation for action provided by Capitalism is the only worthwhile motivating force: Capitalism is the hammer, and every problem looks like a nail. If a system isn't working, it needs more Capitalism: but shouldn't we stop and question whether it's actually the correct tool for the job? | null | 0 | 1316358645 | False | 0 | c2krapl | t3_kgbzq | null | t1_c2krapl | t1_c2kr51w | null | 1427615423 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | From a non-programmer? Get fucked, mate. | null | 0 | 1316358680 | False | 0 | c2kratc | t3_kjhvo | null | t1_c2kratc | t3_kjhvo | null | 1427615424 | -4 | t5_2fwo | null | null | null |
True | EdgarVerona | null | Thanks! (as Zoidberg would say: "hooray, I'm useful! I'm having a wonderful time!" ;) ) | null | 0 | 1316358711 | False | 0 | c2krax0 | t3_ki83r | null | t1_c2krax0 | t1_c2kp289 | null | 1427615426 | 2 | t5_2fwo | null | null | null |
True | mikehaggard | null | I've heard this a lot. Many times when some web framework uses XML templating there are people crying about how XML is ant-Java and that it should be like Swing.
Or the other way around, when some web framework does allow pages to be defined programmatically (doesn't Wicket do this, I'm not sure, but at least GWT does), how cool it is that it's just like Swing etc... | null | 0 | 1316358801 | False | 0 | c2krb8n | t3_kje6b | null | t1_c2krb8n | t1_c2kqsgj | null | 1427615430 | 2 | t5_2fwo | null | null | null |
True | deimosthenes | null | Yeah, I'm pretty sure that was in Salmon. | null | 0 | 1316358872 | False | 0 | c2krbgw | t3_kjhvo | null | t1_c2krbgw | t1_c2kra7s | null | 1427615433 | 1 | t5_2fwo | null | null | null |
True | lucygucy | null | > It does, actually,
I've owned a copy from new, and I looked for that for ages. I've read it from cover to cover. I couldn't find it, I can find out how to do file reads and writes, but not the actual opening bit. Perhaps I've got an earlier edition?
> Please don't be such a dick about that book
Getting a copy was a waste of a my money as a young kid. From memory, it's massively incomplete, teaches you poor C++ and is pretty badly organised.
There are good books out of Sam's Press, but I don't consider it one of them. | null | 0 | 1316359005 | False | 0 | c2krbx5 | t3_khf6j | null | t1_c2krbx5 | t1_c2kfs94 | null | 1427615443 | 1 | t5_2fwo | null | null | null |
True | stillalone | null | This is why my coffee is always cold. | null | 0 | 1316359220 | False | 0 | c2krclx | t3_kjhvo | null | t1_c2krclx | t1_c2kr1lb | null | 1427615447 | 30 | t5_2fwo | null | null | null |
True | WooParadog | null | This actually applies to almost everything, especially relationships.. | null | 0 | 1316359232 | False | 0 | c2krcni | t3_kjhvo | null | t1_c2krcni | t3_kjhvo | null | 1427615448 | 4 | t5_2fwo | null | null | null |
True | andralex | null | >What other containers? Every container implemented with slices can hold any kind of data.
That's a rather naive belief. No non-contiguous container can be implemented to offer the same genericity as slices: linked lists, all trees, graphs, Bloom filters, deques, skip lists...
>The stated problem simply does not exist. Go interfaces are very different than pick-your-favorite-language interfaces and solve every problem you might solve with generics in other language.
That's quite untrue. You may want to refer to a few examples I gave in another post on this page.
>Generic containers, abstract algorithms that operate on many kinds of data, all these work as expected because of the way Go interfaces work. And you don't even have to do anything special, it just works without even thinking about it. I think calling Go interfaces as such was a bad idea because people just assume they are the same old stuff and don't bother studying the new model at all!
I have studied Go very closely before I gave a [talk](http://www.youtube.com/watch?v=RlVpPstLPEc) at Google where it was expected I'd get detailed questions about it.
>It would be great if people studied the language as presented instead of trying to map knowledge gained from other languages.
That I definitely agree with.
>It would be even better if people tried to used the language before complaining some feature does not exist.
I always refrain from bringing that argument up. It is disingenuous and virtually non-falsifiable (as you can't realistically ask someone to spend six months before discussing some issue). A good language must provide a compelling proposition for whatever its fundamental areas are, as early as day one. | null | 0 | 1316359446 | False | 0 | c2krdce | t3_kikut | null | t1_c2krdce | t1_c2kr7mw | null | 1427615457 | 5 | t5_2fwo | null | null | null |
True | azakai | null | > Dart is still a dynamically typed language in the vein of JavaScript. It should get some speed advantage from avoiding things that turned out to be just plain dumb decisions in JavaScript, but for the most part, its runtime performance will be limited by the same factors that limit JavaScript, Python, Ruby, etc. Its performance should be acceptable for most web UI stuff, but not really up to heavy computational tasks.
JS is already just 3-5X slower than C++. In a year it will be even faster. When JS gets to 2X slower than C++, is there a need for something like NaCl? (And what speed range will Dart fill - 1.5X slower than C++?)
> As for portability, of course if it catches on in Chrome, other browsers will consider it... you know, the same way every other web standard out there came into being.
Many web standards began through cross-browser collaboration, for example WebGL, which is very much unlike the process of NaCl. But there are examples both ways.
| null | 0 | 1316359476 | False | 0 | c2krdgn | t3_kitgf | null | t1_c2krdgn | t1_c2kq2to | null | 1427615460 | -1 | t5_2fwo | null | null | null |
True | kamatsu | null | Most languages don't support dependent types :/ But yes, Go's lack of parametric polymorphism is ridiculous. | null | 0 | 1316359526 | False | 0 | c2krdll | t3_kikut | null | t1_c2krdll | t1_c2kqgsa | null | 1427615460 | 6 | t5_2fwo | null | null | null |
True | therapy | null | That used to be true, but no longer is.
NaCl now relies on the Pepper plugin API, which exists only in Chrome. You can't even run it via a plugin in other browsers.
| null | 0 | 1316359580 | False | 0 | c2krdse | t3_kitgf | null | t1_c2krdse | t1_c2kq7mz | null | 1427615463 | 5 | t5_2fwo | null | null | null |
True | Durinthal | null | [](/sotrue) Which is why I just tend to laugh at my friends when they say they're buying a Mac because they don't want to worry about having it break like a PC. | null | 0 | 1316359599 | False | 0 | c2krduo | t3_kjhvo | null | t1_c2krduo | t1_c2kr2sc | null | 1427615464 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316359678 | False | 0 | c2kre50 | t3_kjete | null | t1_c2kre50 | t1_c2kr484 | null | 1427615467 | 1 | t5_2fwo | null | null | null |
True | therapy | null | > This is nice for lightweight stuff, but it's silly to pretend that running via JavaScript will be comparable to native code in execution speed. Entirely aside from the interpreter issue (solved by JITs), JavaScript is just fundamentally not designed as a high performance language.
If you write code in JS that **can** be optimized just like C++, then a JS engine could run it just as fast as native code. For example, RPython is a subset of Python that runs as fast as C++: PyPy compiles it to C++. The exact same thing can be true with JS, here is an experiment with a benchmark,
http://mozakai.blogspot.com/2010/07/experiments-with-static-javascript-as.html
so you could compile a C++ library to JS, and a JS engine could run it at native speed. JS engines have not gotten to that point yet, but they will.
> I wonder how you obtained your ability to see into the future. Seriously, it certainly isn't a slam dunk that Native Client will catch on. Probably much better than 50% chance it won't. But it's a bit premature to dismiss the possibility.
I can't be 100% certain, you are right. But given the degree of objection from all other browser vendors, it seems extremely unlikely.
| null | 0 | 1316359791 | False | 0 | c2krej0 | t3_kitgf | null | t1_c2krej0 | t1_c2kq3mp | null | 1427615472 | 1 | t5_2fwo | null | null | null |
True | therapy | null | > There isn't a single widely used web technology out there that wasn't first implemented as a browser-specific extension before it caught on and was copied elsewhere.
Often yes, but also often the situation is that multiple vendors work on the standard, while implementing it, and they eventually converge. For example, web workers, WebGL, etc. That sort of process is much likelier to lead to standardization I think.
| null | 0 | 1316359931 | False | 0 | c2kreza | t3_kitgf | null | t1_c2kreza | t1_c2kq1vf | null | 1427615478 | 4 | t5_2fwo | null | null | null |
True | kamatsu | null | Honestly, *who the fuck cares*. | null | 0 | 1316360054 | False | 0 | c2krfdl | t3_kjjzd | null | t1_c2krfdl | t3_kjjzd | null | 1427615483 | -1 | t5_2fwo | null | null | null |
True | azakai | null | Yes, that's very true.
| null | 0 | 1316360087 | False | 0 | c2krfhb | t3_kitgf | null | t1_c2krfhb | t1_c2kq3so | null | 1427615485 | 1 | t5_2fwo | null | null | null |
True | andralex | null | I'm interested in furthering D's grok of dependent types. It already has support for dependent types as long as the dependee values are known during compilation. What it currently lacks is types dynamically dependent upon a variable. That would be difficult to implement, so I wonder what the practical applications would be. | null | 0 | 1316360186 | False | 0 | c2krft0 | t3_kikut | null | t1_c2krft0 | t1_c2krdll | null | 1427615489 | 7 | t5_2fwo | null | null | null |
True | tgehr | null | > What other containers? Every container implemented with slices can hold any kind of data.
1. Please elaborate. How can a container propagate the genericity that the underlying slice provides?
2. Not every container can be implemented with slices.
>Generic containers, abstract algorithms that operate on many kinds of data, all these work as expected because of the way Go interfaces work. And you don't even have to do anything special, it just works without even thinking about it.
You still have to implement the respective interfaces. Go saves you from explicitly specifying that you do. | null | 0 | 1316360296 | False | 0 | c2krg6s | t3_kikut | null | t1_c2krg6s | t1_c2kr7mw | null | 1427615495 | 2 | t5_2fwo | null | null | null |
True | alecco | null | > you may want to use the LZ engine from Snappy with a good huffman coder [...] That should give you the compression ratio of zlib but significantly faster
Not really. Snappy uses a tiny lookup table of 16K entries and no hash chains. This way it mostly fits in L1. DEFLATE lookup implementations usually have ~4x that size. It matters for finding matches and avoiding hash collisions. Also with the sliding window there're costs of re-adjusting the hash table and chains.
LZO and Snappy are in a nice L1 sweetspot and gzip/zlib in a nice L2 sweetspot. Apples to oranges. | null | 0 | 1316360331 | False | 0 | c2krgbc | t3_kjete | null | t1_c2krgbc | t1_c2kqz8s | null | 1427615495 | 2 | t5_2fwo | null | null | null |
True | kamatsu | null | Er, are you sure we're talking about the same thing? As far as I was aware, D had no support for dependent types. C++'s notion of a "dependent type" is not the same term as that used in PLs theory.
Otherwise, by all means, show me a length-indexed list GADT parameterised by your standard numeric types and I'll believe you. | null | 0 | 1316360378 | False | 0 | c2krghf | t3_kikut | null | t1_c2krghf | t1_c2krft0 | null | 1427615499 | 2 | t5_2fwo | null | null | null |
True | jimbelk | null | Um, although Douglas Adams was not a professional programmer, he certainly had some experience with computer programming. Here are some Douglas Adams quotes that pertain directly to programming:
* "I am rarely happier than when spending an entire day programming my computer to perform automatically a task that it would otherwise take me a good ten seconds to do by hand."
* "If you really want to understand something, the best way is to try and explain it to someone else. That forces you to sort it out in your mind. And the more slow and dim-witted your pupil, the more you have to break things down into more and more simple ideas. And that’s really the essence of programming. By the time you’ve sorted out a complicated idea into little steps that even a stupid machine can deal with, you’ve learned something about it yourself." | null | 0 | 1316360448 | False | 0 | c2krgq6 | t3_kjhvo | null | t1_c2krgq6 | t3_kjhvo | null | 1427615501 | 44 | t5_2fwo | null | null | null |
True | ivosaurus | null | > There is a race between mankind and the universe. Mankind is trying to build bigger, better, faster, and more foolproof machines. The universe is trying to build bigger, better, and faster fools. So far the universe is winning.
Ol' Albert E | null | 0 | 1316360465 | False | 0 | c2krgs7 | t3_kjhvo | null | t1_c2krgs7 | t1_c2kr1q1 | null | 1427615503 | 12 | t5_2fwo | null | null | null |
True | alecco | null | For database compression you are better off with smart use of delta encoding, RLE and other basic methods applied carefully to different parts of the page data. | null | 0 | 1316360487 | False | 0 | c2krguw | t3_kjete | null | t1_c2krguw | t3_kjete | null | 1427615504 | 1 | t5_2fwo | null | null | null |
True | henk53 | null | Yeah, those Java chips were indeed the talk of the day then...
Btw, Javaworld goes way back and it actually covers JavaOne '98 as well, but since they've updated their look considerably since frames were all the rage, it doesn't look quite as retro as the one I submitted :P | null | 0 | 1316360497 | False | 0 | c2krgvz | t3_kjf91 | null | t1_c2krgvz | t1_c2kqthx | null | 1427615504 | 3 | t5_2fwo | null | null | null |
True | philh | null | Would your friends have the knowledge and inclination to repair a PC if they had one? | null | 0 | 1316360509 | False | 0 | c2krgxe | t3_kjhvo | null | t1_c2krgxe | t1_c2krduo | null | 1427615504 | 1 | t5_2fwo | null | null | null |
True | ohwelp | null | If I could amend, one of Douglas's characters said that, not the narrator. | null | 0 | 1316360545 | False | 0 | c2krh2d | t3_kjhvo | null | t1_c2krh2d | t1_c2kr8y6 | null | 1427615511 | 3 | t5_2fwo | null | null | null |
True | abeliangrape | null | These permutations are called involutions. To see the reason for this recurrence consider what happens to the element labelled n. If it gets mapped to itself, then the first n-1 elements form an involution and there's f(n-1) ways of doing this. Otherwise, n gets mapped to some i between 1 and n-1 inclusive. Of course, this element needs to get mapped back to n, so the remaining n-2 elements form an involution after relabeling. There are (n-1) ways to choose i and f(n-2) ways to choose the involution, which gives you a total of (n-1)f(n-2) possibilities. Now we add the two up to get f(n)=f(n-1)+(n-1)f(n-2). | null | 0 | 1316360547 | False | 0 | c2krh2q | t3_kj03o | null | t1_c2krh2q | t1_c2knzqw | null | 1427615511 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316360664 | False | 0 | c2krhi1 | t3_kjhvo | null | t1_c2krhi1 | t1_c2krclx | null | 1427615512 | -24 | t5_2fwo | null | null | 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.