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 | [deleted] | null | [deleted] | null | 0 | 1316365978 | False | 0 | c2ks24b | t3_kjhvo | null | t1_c2ks24b | t1_c2krhqv | null | 1427615841 | 1 | t5_2fwo | null | null | null |
True | miishuu | null | When I was first learning to code I wrote a program to recursively search for a file and delete it. It looked something like this:
if (condition)
print(file);
file.delete();
Clearly that didnt go very well when I started at C:/, curly braces have been mandatory ever since. | null | 0 | 1316366254 | False | 0 | c2ks3ad | t3_kjjzd | null | t1_c2ks3ad | t3_kjjzd | null | 1427615857 | 2 | t5_2fwo | null | null | null |
True | tanishaj | null | True, but you do not need an ORM to write DRY code which is what it sounds like you are talking about.
In C#/.NET, which you mention, you can for example write a layer with methods that take a SQL string and some parameters and return a scalar, an IDataRecord (database row), or IEnumerable<IDataRecord> as appropriate. You can put all your connection (connection string), timing, and logging logic into this layer. Nice and DRY.
Of course, you still just have a result set that you need to loop over as you say. It is just that now you can do that in a different layer of your code. The code where the loop resides does not even need to know how to talk to the database (just IDataRecord). It could even be an a different assembly.
The layer that loops over the IDataRecords can build proper business objects that can be used by the rest of your application. A nice 'repository' pattern perhaps? You should be able to replace all of this with an ORM without changing the interface to your business logic at all. Why should it care if you are using an ORM or just writing the SQL yourself and looping over datasets? And if you have proper tests, it should even be safe to do it.
I guess my point is that proper separation of concerns and writing DRY code does not require an ORM. Other than that, I am not making an argument one way or the other. | null | 0 | 1316366397 | False | 0 | c2ks3wo | t3_ki83r | null | t1_c2ks3wo | t1_c2kn236 | null | 1427615865 | 2 | t5_2fwo | null | null | null |
True | jzwinck | null | Wrong link? | null | 0 | 1316366647 | False | 0 | c2ks4w4 | t3_kjm5r | null | t1_c2ks4w4 | t3_kjm5r | null | 1427615880 | 2 | t5_2fwo | null | null | null |
True | emptythecache | null | I like Picasso's "Computers are useless. They can only give you answers." | null | 0 | 1316366796 | False | 0 | c2ks5ix | t3_kjhvo | null | t1_c2ks5ix | t3_kjhvo | null | 1427615887 | 1 | t5_2fwo | null | null | null |
True | goacon93 | null | FWIW, banana technology has "stopped working" in the past, and it may do so again in the future:
- http://en.wikipedia.org/wiki/Yes,_We_Have_No_Bananas
- http://en.wikipedia.org/wiki/Cavendish_banana#History_of_cultivation | null | 0 | 1316366832 | False | 0 | c2ks5ol | t3_kjhvo | null | t1_c2ks5ol | t1_c2kross | null | 1427615889 | 11 | t5_2fwo | null | null | null |
True | korran | null | I don't really see the problem with a platform vendor using proprietary extensions to a language to create a proprietary API. You only need to use this stuff on the edges of your application, which are already going to be tied closely to windows.
This is pretty much the same as what Apple did with Objective C++. I have no trouble writing cross platform C++ applications that dip into Objective C++ when they need to interface with the operating system. | null | 0 | 1316366990 | True | 0 | c2ks6dd | t3_kjja4 | null | t1_c2ks6dd | t1_c2krxvw | null | 1427615897 | 20 | t5_2fwo | null | null | null |
True | datn | null | Not to mention Richard's program "Anthem". | null | 0 | 1316366996 | False | 0 | c2ks6ea | t3_kjhvo | null | t1_c2ks6ea | t1_c2krkqn | null | 1427615898 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | * Some seem to think this reddit is for "links that programmers might find interesting or funny". No. It's for programming links. Programming. Programming. Programming.
Yep, you got it. | null | 0 | 1316367068 | False | 0 | c2ks6pj | t3_kjhvo | null | t1_c2ks6pj | t1_c2krygl | null | 1427615901 | -2 | t5_2fwo | null | null | null |
True | yacoob | null | I think you got the link wrong. You surely meant [this one](http://www.goodreads.com/quotes/show/325051), right? :) | null | 0 | 1316367083 | False | 0 | c2ks6rp | t3_kjhvo | null | t1_c2ks6rp | t3_kjhvo | null | 1427615901 | 2 | t5_2fwo | null | null | null |
True | mr_curmudgeon | null | The categorization of languages seems a little suspect to me.
* No lisps at all? Not even an acknowledgment that lisp exists?
* The only ML derivative, F#, is in the moderate-but-poor category?
* (I agree that C# is more functional than Java) but so much so that it is in a different category?
* Haskell and Clean are somehow "practical?" Maybe I do not understand some exotic sense of the word "practical" here. | null | 0 | 1316367229 | False | 0 | c2ks7dt | t3_kjkxj | null | t1_c2ks7dt | t3_kjkxj | null | 1427615910 | 38 | t5_2fwo | null | null | null |
True | amaranth1 | null | Why link to wayback machine? The current link still works. | null | 0 | 1316367239 | False | 0 | c2ks7fe | t3_ki52y | null | t1_c2ks7fe | t3_ki52y | null | 1427615911 | 3 | t5_2fwo | null | null | null |
True | dnew | null | > Go does not support inheritance
I hadn't realized that, but then thinking back on how one declares structures/functions, I can see how it should have been obvious. :-) | null | 0 | 1316367269 | False | 0 | c2ks7ji | t3_kikut | null | t1_c2ks7ji | t1_c2ks1ti | null | 1427615912 | 2 | t5_2fwo | null | null | null |
True | dotwaffle | null | Heh, Citadell, Granny's Garden, Thrust... All good stuff ;)
There's even a BBC Micro demoscene, such as the recent Sunrise party entry, [BeebNyan](http://www.pouet.net/prod.php?which=57734) ;) | null | 0 | 1316367564 | False | 0 | c2ks8r0 | t3_kjhvo | null | t1_c2ks8r0 | t1_c2ks24b | null | 1427615928 | 1 | t5_2fwo | null | null | null |
True | agottem | null | They were given an opportunity to design a new API from the ground up. I'm just curious: would you prefer that API be designed with proprietary extensions, or would you rather they create an API that conforms to the standard for the language they are targeting? | null | 0 | 1316367976 | False | 0 | c2ksagv | t3_kjja4 | null | t1_c2ksagv | t1_c2ks6dd | null | 1427615954 | 7 | t5_2fwo | null | null | null |
True | palam_rect | null | Its just a beginners tutorial that will teach how to add attribute "autocomplete" to input element. | null | 0 | 1316367993 | False | 0 | c2ksaj8 | t3_kjfx6 | null | t1_c2ksaj8 | t3_kjfx6 | null | 1427615955 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316368129 | False | 0 | c2ksb3l | t3_kjhvo | null | t1_c2ksb3l | t3_kjhvo | null | 1427615958 | 1 | t5_2fwo | null | null | null |
True | wolf550e | null | LZNT1 used by NTFS is a type of LZ77. After huffman coding, it can't find 3 byte long matches within the 64k window.
Just do the experiment of comparing:
sum([round_up_to_4k(compressed_length) for each chunk_of_64k_uncompressed_data])
(you can do this without writing to files by analyzing the file you have or logging while writing to db)
with:
size of ntfs compressed file containing all compressed chunks
and report whether they're equal. I guess they are, because I guess NTFS writes the compressed chunks on memory page boundaries and so "wastes" an average of 2kb per chunk. Like regular files waste an average of 2kb each on a 4kb per block filesystem.
BTW, AFAIK, Linux ext fs can have 4kb sized sparse holes.
Edit: thinko. Round up to 4kb. | null | 0 | 1316368160 | True | 0 | c2ksb8g | t3_kjete | null | t1_c2ksb8g | t1_c2krz2u | null | 1427615960 | 2 | t5_2fwo | null | null | null |
True | adolfojp | null | Putting that on dropbox is not a great idea. | null | 0 | 1316368174 | False | 0 | c2ksba0 | t3_kjkxj | null | t1_c2ksba0 | t3_kjkxj | null | 1427615961 | 13 | t5_2fwo | null | null | null |
True | TheSisko972 | null | Linux is not a flavor of "the UNIX kernel." Also, what "different paradigm" is git using that the Linux kernel is not? | null | 0 | 1316368190 | False | 0 | c2ksbcs | t3_kjhvo | null | t1_c2ksbcs | t1_c2krtmk | null | 1427615962 | 5 | t5_2fwo | null | null | null |
True | ceiimq | null | What the author means by "practical" is that using a functional style in Haskell or Clean is more practical that in the other languages listed.
The reason he considers ML languages to be poor at FP would be because they're strict by default (*Why Functional Programming Matters*, which the author refers to, identifies higher-order functions and lazy evaluation as the two types of glue that make functional programming composable) and because they're impure, which means types don't tell you as much as you'd like about how programs can be composed together.
The complete omission of lisps is surprising, but it'd only be half tongue-in-cheek to say that only the lisp crowd considers classical lisps (Clojure being a pretty different business) to be functional languages. Traditional lisps are about metaprogramming first, and then a style of imperative programming that just happens to have higher-order functions. | null | 0 | 1316368280 | True | 0 | c2ksbqx | t3_kjkxj | null | t1_c2ksbqx | t1_c2ks7dt | null | 1427615967 | 21 | t5_2fwo | null | null | null |
True | ridgerat | null | This should be the first sentence of any style guide. | null | 0 | 1316368479 | False | 0 | c2ksck4 | t3_kjjzd | null | t1_c2ksck4 | t1_c2krk07 | null | 1427615977 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316368567 | False | 0 | c2kscwn | t3_kjhvo | null | t1_c2kscwn | t1_c2ks8r0 | null | 1427615982 | 1 | t5_2fwo | null | null | null |
True | agottem | null | So, what you're saying is that you can't think of any improvements you'd make to the Win32 API? | null | 0 | 1316368571 | False | 0 | c2kscxe | t3_kgs75 | null | t1_c2kscxe | t1_c2kq1f9 | null | 1427615982 | 1 | t5_2fwo | null | null | null |
True | nCrazed | null | msdn still claiming that chromium doesn't support HTML5 -_- | null | 0 | 1316368838 | False | 0 | c2kse00 | t3_kjja4 | null | t1_c2kse00 | t3_kjja4 | null | 1427615997 | 19 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316368955 | 1377639834 | 0 | c2kseh3 | t3_kjhvo | null | t1_c2kseh3 | t1_c2kross | null | 1427616012 | 1 | t5_2fwo | null | null | null |
True | edahs | null | I reference this quote frequently. | null | 0 | 1316369043 | False | 0 | c2kseu2 | t3_kjhvo | null | t1_c2kseu2 | t3_kjhvo | null | 1427616009 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | I have found I have to be *very* explicit whenever I'm engaging programmers with asbergers--*cough*--I mean redditors. | null | 0 | 1316369257 | False | 0 | c2ksfps | t3_kjhvo | null | t1_c2ksfps | t1_c2krmqf | null | 1427616019 | 3 | t5_2fwo | null | null | null |
True | rob132 | null | That link is NSFL. | null | 0 | 1316369265 | False | 0 | c2ksfqy | t3_kjhvo | null | t1_c2ksfqy | t1_c2kseh3 | null | 1427616020 | 1 | t5_2fwo | null | null | null |
True | jtdc | null | The stars predict tomorrow you'll wake up, do a bunch of stuff, and then go back to sleep. | null | 0 | 1316369328 | False | 0 | c2ksg0l | t3_kjhvo | null | t1_c2ksg0l | t1_c2kroip | null | 1427616026 | 6 | t5_2fwo | null | null | null |
True | andralex | null | I agree. Turing completeness, however, imparts it considerable additional power. | null | 0 | 1316369387 | False | 0 | c2ksg91 | t3_kikut | null | t1_c2ksg91 | t1_c2ks1wr | null | 1427616028 | 0 | t5_2fwo | null | null | null |
True | donkey_lz | null | > Really? I wonder where you got your knowledge about discrete mathematics or logics. There are only few autodidacts in that area.
Munched on a few good books and sat through a discrete mathematics course back in university. I actually enjoyed it and love the sense of structure it gave me, although I rarely have to use it per se.
> Same here. We had obligatory basic courses on electrical engineering, circuit technique, processor and hardware architecture, operating systems... That's all undergraduate level, from calculating pipeline hazards with pencil and paper up to writing services for L4.
Are we still talking about CS, not CpE? None of the kids who came to our interviews knew how to handle an oscilloscope and they most certainly did not have compulsory electrical engineering or circuit theory classes. One of them knew something about circuits but it was all graphs and systems theory -- he choked on a simple common gate amplifier and didn't know what an ADC was. | null | 0 | 1316369398 | False | 0 | c2ksgav | t3_khkyd | null | t1_c2ksgav | t1_c2kroli | null | 1427616030 | 1 | t5_2fwo | null | null | null |
True | kirakun | null | Do you even know what Torvalds wrote and what language git was written in? | null | 0 | 1316369419 | False | 0 | c2ksgdp | t3_kjhvo | null | t1_c2ksgdp | t1_c2ksbcs | null | 1427616030 | -1 | t5_2fwo | null | null | null |
True | grauenwolf | null | Back in 1998 my big issues were:
* Lack of properties
* Lack of events
* A broken date/time class
* A clumsy UI toolkit that made it hard to layout controls in a pleasing fashion
Sadly these are still problems... | null | 0 | 1316369462 | False | 0 | c2ksgkk | t3_kjf91 | null | t1_c2ksgkk | t3_kjf91 | null | 1428193748 | 9 | t5_2fwo | null | null | null |
True | kdeforche | null | If you ignore the fact that unlike .NET and Java, NaCl didn't require the reinvention of a new programming language, and require that all software is being rewritten for the new platform.
"Porting" C/C++ code is a big word: you can simply build most libraries, although you will need to take care for APIs (and syscalls) which are not allowed by the sandbox, and will probably need to do some work to access the functionality from within a web page. | null | 0 | 1316369486 | False | 0 | c2ksgog | t3_kitgf | null | t1_c2ksgog | t1_c2koloh | null | 1427616035 | 3 | t5_2fwo | null | null | null |
True | kamatsu | null | I disagree, effective totality checking along with coinduction give near-equal power without any of the inconsistency problems. | null | 0 | 1316369527 | False | 0 | c2ksguk | t3_kikut | null | t1_c2ksguk | t1_c2ksg91 | null | 1427616039 | 4 | t5_2fwo | null | null | null |
True | grauenwolf | null | Try object orienated programming instead, it is more compatible with tea. | null | 0 | 1316369592 | False | 0 | c2ksh4g | t3_kjhvo | null | t1_c2ksh4g | t1_c2krhut | null | 1427616043 | 4 | t5_2fwo | null | null | null |
True | skealoha86 | null | [Hmm...](http://www.iplawalert.com/2011/09/articles/patent-1/america-invents-act-introduces-firsttofile-to-the-united-states/)
> Moreover, 35 U.S.C. §102, as revised, provides a unique protection for inventors that publish or publicly disclose their invention less than one year before filing their patent application. Under this new standard, third party patent application filings or publications that occur after the inventor’s publication or public disclosure will not be invalidating prior art.
Your point that the third party can't patent an idea that they didn't invent only holds true if the inventor publishes their idea... and then files a patent within a year of publishing. Am I reading this wrong? | null | 0 | 1316369829 | False | 0 | c2ksi5p | t3_khvyw | null | t1_c2ksi5p | t1_c2kk9jp | null | 1427616053 | 0 | t5_2fwo | null | null | null |
True | ambiturnal | null | Who could possibly need a boat with a hull speed greater than four knots?
In the future, every household will have a yacht in their living room.
There are two types of programmers- those who program for sport and those who program for fish. | null | 0 | 1316370032 | False | 0 | c2ksj1f | t3_kjhvo | null | t1_c2ksj1f | t1_c2krsrn | null | 1427616062 | 3 | t5_2fwo | null | null | null |
True | grauenwolf | null | Real astrology is like climatology, it uses impossibly complex calculations to predict events that are decades into the future. And by the time the predictions are proven, true or otherwise, the scientists have already moved to other academic pursuits and new ones have taken their place.
Fake astrology is like TV weather men. They look out the window and tell you the obvious while being vauge enough to cover for mistakes. | null | 0 | 1316370182 | False | 0 | c2ksjn1 | t3_kjhvo | null | t1_c2ksjn1 | t1_c2kroip | null | 1427616070 | 0 | t5_2fwo | null | null | null |
True | JimH10 | null | You must live a *very* quiet life. | null | 0 | 1316370328 | False | 0 | c2ksk9u | t3_kjhvo | null | t1_c2ksk9u | t1_c2ksfqy | null | 1427616078 | 1 | t5_2fwo | null | null | null |
True | tgehr | null | >Strong static typing means that getting a value to the type you need it in can require a bit of screwing around and sometimes isn't really do-able.
Getting the right type is just adding an explicit function call instead of relying on implicit behavior. And that is do-able pretty well. Overall you save more typing by not writing out all those type signatures than you lose by typing out conversions.
> The pure functional thing means that you can't do IO in certain places without fixing up all the types around it.
That is wrong. Arbitrary pure functions can actually 'perform IO' because of Haskells purity and its laziness in particular.
> No mutable state means that problems best expressed as mutations have to be expressed in a round about way.
Haskell provides you all the means to write imperative-style code and to do that well. Use monads and the do notation if mutation is the best abstraction.
> Satisfying the compiler makes your program more provably correct but this often means convincing the compiler that what you already know to be true is in fact true which gets in your way.
The other side of the coin is, you save time debugging, because what type checks is often correct as well. | null | 0 | 1316370339 | False | 0 | c2kskb9 | t3_kikut | null | t1_c2kskb9 | t1_c2kq9kt | null | 1427616079 | 1 | t5_2fwo | null | null | null |
True | RedAero | null | Is programming engineering anyway? | null | 0 | 1316370484 | False | 0 | c2ksky2 | t3_kjhvo | null | t1_c2ksky2 | t1_c2krsrn | null | 1427616087 | 1 | t5_2fwo | null | null | null |
True | abattle | null | > it can't find 3 byte long matches within the 64k window
That seals it for me. You convinced me it almost certainly couldn't save a single byte.
> they're equal. I guess they are
Yes. That's what I think as well. I expect them to be equal, which explains what's happening.
Btw, isn't LZ77 the predecessor of deflate, which itself is actually LZ-Adler, no?
While the 64kb sparse hole unit might be explained by efficiently/overhead, I find it hard to understand why the NTFS wouldn't compress clusters larger than 4kb. They don't think there'd be any gain? When there isn't just write uncompressed data and move on. Why not? | null | 0 | 1316370673 | False | 0 | c2kslq9 | t3_kjete | null | t1_c2kslq9 | t1_c2ksb8g | null | 1427616098 | 1 | t5_2fwo | null | null | null |
True | shobble | null | The paragraph preceding this quote is also highly appropriate:
"*all mechanical or electrical or quantum-mechanical or hydraulic or even wind, steam or piston-driven devices, are now required to have a certain legend emblazoned on them somewhere. It doesn't matter how small the object is, the designers of the object have got to find a way of squeezing the legend in somewhere, because it is their attention which is being drawn to it rather than necessarily that of the user's.*"
The legend here being the original quote posted. | null | 0 | 1316370752 | False | 0 | c2ksm21 | t3_kjhvo | null | t1_c2ksm21 | t3_kjhvo | null | 1427616102 | 1 | t5_2fwo | null | null | null |
True | ekimt27 | null | Once again you are stuck in the here and now. You arent seeing this as progressive. I'll see you in the future. | null | 0 | 1316370768 | False | 0 | c2ksm4q | t3_kejwo | null | t1_c2ksm4q | t1_c2ko3mk | null | 1427616103 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316370924 | False | 0 | c2ksmt3 | t3_kjhvo | null | t1_c2ksmt3 | t3_kjhvo | null | 1427616113 | 1 | t5_2fwo | null | null | null |
True | MarcuBot | null | The C++ WinRT stuff is just plain old c++.cli rebranded. | null | 0 | 1316370981 | False | 0 | c2ksn24 | t3_kjja4 | null | t1_c2ksn24 | t1_c2ksagv | null | 1427616116 | -5 | t5_2fwo | null | null | null |
True | MyrddinE | null | Because different people contributed to different parts, and a Wikifreak hasn't gone through and made the separate parts consistent yet. | null | 0 | 1316371049 | False | 0 | c2ksnd0 | t3_kgfhb | null | t1_c2ksnd0 | t1_c2kangj | null | 1427616120 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | Auto-formatters will fix the indentation. I suggest always using them. | null | 0 | 1316371051 | False | 0 | c2ksnde | t3_kjjzd | null | t1_c2ksnde | t1_c2krnvh | null | 1428193746 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | Vertical space matters. Taking four lines to express something that should be expressed in one or two is a bad thing when you are trying to scan the code.
For VB I would use one line because the Then keyword stands out so well.
Since the C family of languages are not so blessed, two lines are fine by me. | null | 0 | 1316371227 | False | 0 | c2kso3n | t3_kjjzd | null | t1_c2kso3n | t3_kjjzd | null | 1427616135 | 1 | t5_2fwo | null | null | null |
True | xon_xoff | null | The hardware doesn't support it in 64-bit mode. It is still fully supported for 64-bit operating systems running 32-bit user code, which is the situation we're talking about here.
| null | 0 | 1316371509 | False | 0 | c2ksp9o | t3_kitgf | null | t1_c2ksp9o | t1_c2kqfhw | null | 1427616144 | 2 | t5_2fwo | null | null | null |
True | virt_vera | null | What "claims" are you talking about? Slowness?
The guy is using a version of NetBSD *at least 10 years old*.
Which is what we were talking about.
Are you claiming NetBSD had fine-grained kernel threading back THEN?
| null | 0 | 1316371574 | False | 0 | c2kspjb | t3_kejfs | null | t1_c2kspjb | t1_c2kiif4 | null | 1427616148 | 1 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | Runtime code generation is not polymorphism (at least not in the usual sense) and it doesn't disprove that ORMs map records to records. | null | 0 | 1316371574 | False | 0 | c2kspjd | t3_ki83r | null | t1_c2kspjd | t1_c2kqo3m | null | 1427616148 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | From wikipedia :
> Engineering is the discipline, art, skill and profession of acquiring and applying scientific, mathematical, economic, social, and practical knowledge, in order to design and build structures, machines, devices, systems, materials and processes **that safely realize improvements to the lives of people.**
So, apparently, no :-) | null | 0 | 1316371765 | False | 0 | c2ksqbw | t3_kjhvo | null | t1_c2ksqbw | t1_c2ksky2 | null | 1427616158 | 2 | t5_2fwo | null | null | null |
True | phunphun | null | Do you know how extensively the Linux Kernel uses the [OOP](https://lwn.net/Articles/444910/) [paradigm](https://lwn.net/Articles/446317/)? | null | 0 | 1316371838 | False | 0 | c2ksqmi | t3_kjhvo | null | t1_c2ksqmi | t1_c2ksgdp | null | 1427616163 | 0 | t5_2fwo | null | null | null |
True | bigboehmboy | null | If I understand correctly, the script that took 48 days to run was generating all possible puzzles and solving them in the minimum number of steps, not solving a single puzzle. | null | 0 | 1316371906 | False | 0 | c2ksqx2 | t3_khf6j | null | t1_c2ksqx2 | t1_c2kd2qk | null | 1428193745 | 2 | t5_2fwo | null | null | null |
True | awj | null | I've never heard of one. It seems like a difficult and error-prone task.
Possibly this is an area where profiling would be a better approach: give queries a unique tag at their call site then track usage from there so you can figure out the columns used. That way you don't have to worry about exposing templating systems to this analysis or forcing the user through access contortions to get their column name usage. | null | 0 | 1316371928 | False | 0 | c2ksr03 | t3_ki83r | null | t1_c2ksr03 | t1_c2kqie4 | null | 1427616174 | 2 | t5_2fwo | null | null | null |
True | Durahk | null | If SIGSEGV was uncatchable, things like gdb would never work. | null | 0 | 1316371964 | False | 0 | c2ksr51 | t3_khip6 | null | t1_c2ksr51 | t1_c2kil8r | null | 1427616169 | 5 | t5_2fwo | null | null | null |
True | ahtnos | null | That's why you don't use tea; you use Java… | null | 0 | 1316372041 | False | 0 | c2ksrhk | t3_kjhvo | null | t1_c2ksrhk | t1_c2krhut | null | 1427616174 | 4 | t5_2fwo | null | null | null |
True | andralex | null | You had me at coind... coinduction. We'd love to have someone with your background improve D's type system. You're gladly invited to chime in at [digitalmars.D](news://news.digitalmars.com/digitalmars.D). | null | 0 | 1316372042 | False | 0 | c2ksrhz | t3_kikut | null | t1_c2ksrhz | t1_c2ksguk | null | 1427616174 | 6 | t5_2fwo | null | null | null |
True | banuday | null | Hibernate is using CGLIB/Javassist to generate at runtime a *new class* which is a *subclass* of the entity class (which is why auto-reloading containers and Hibernate don't play well together, as Hibernate will chew up permgen space). At call sites, the entity class is specified at compile time, but the object instance of the generated subclass can be passed to the call site at runtime. That is the textbook definition of polymorphism.
Also, lazy loading of associations requires an active object, as field access will trigger an SQL query. A record is data and cannot have behavior (otherwise it is essentially an object). | null | 0 | 1316372267 | True | 0 | c2kssi9 | t3_ki83r | null | t1_c2kssi9 | t1_c2kspjd | null | 1427616187 | 2 | t5_2fwo | null | null | null |
True | MaikB | null | One thing he said is something I concluded for myself a few years ago. If the objective is to write a fast piece of code in a very short amount of time, C++ is my goto language.
I wasted a lot of time trying to make matlab/python code run faster instead of writing a C/C++/Fortran module to do the job, without butchering the expressiveness for the sake of performance. If the algorithms is sound and hence the implementation final it's also pleasant to have the compiler do static code analysis. Out of the three languages mentioned above, C++ turned out to take the lowest amount of time to write something that works and is fast. If I should point my finger on why, I'd say RAII and the STL.
After I made this conclusion I also wasted a lot of time implementing algorithms in static languages, mostly C++, that turned out to be not thought out well enough. These days I sketch ideas in python before I implement them in a static language.
So, if you know what you want, C++ is a pleasant language to write your algorithm down. OTOH, if you're not sure about the what and how, it's gonna screw you over :P. I strongly recommend to always use a dynamic and a static language together to minimize the amount of time it takes to get the job done. | null | 0 | 1316372629 | False | 0 | c2ksu3g | t3_kjja4 | null | t1_c2ksu3g | t3_kjja4 | null | 1427616208 | 44 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316372753 | False | 0 | c2ksum1 | t3_k7vpw | null | t1_c2ksum1 | t1_c2i6jd8 | null | 1427616216 | 1 | t5_2fwo | null | null | null |
True | abattle | null | Either way I'd like to have some form of error-detection, to avoid crashing in case of corruption. Whether checksum is done by the compressor or not is secondary.
> everyone says arithmetic coders are always slower
This used to be the case back in the day (at least a decade ago.) It'd be interesting to see what modern architectures can do in practice. I bet the difference isn't nearly what it used to be. Although I can see that huffman with preset tables would be hard to beat in performance, I should expect the arithmetic coder to make up more than the difference in compression ratio. | null | 0 | 1316373102 | False | 0 | c2ksw2b | t3_kjete | null | t1_c2ksw2b | t1_c2kqz8s | null | 1427616237 | 1 | t5_2fwo | null | null | null |
True | banuday | null | > I have never had to get a banana to work.
Okay, but how to keep those fuckers from going brown before you can eat them? | null | 0 | 1316373124 | False | 0 | c2ksw5k | t3_kjhvo | null | t1_c2ksw5k | t1_c2kross | null | 1427616239 | 1 | t5_2fwo | null | null | null |
True | skulgnome | null | The difference between instance specification in Go and Haskell is that Haskell has a syntax for making it explicit. Go is still finicky as all hell about what set of functions make a thing fit an interface, so you end up grouping the functions together. | null | 0 | 1316373275 | False | 0 | c2kswrw | t3_kikut | null | t1_c2kswrw | t1_c2kqgfx | null | 1427616247 | 2 | t5_2fwo | null | null | null |
True | korran | null | Ideally, I prefer an API that conforms to the language standard. However, with C++ things are not so simple.
Microsoft could have standardized their C++ ABI, and used that for WinRT. This would be a huge undertaking. The memory layout of the STL classes would have to be rigidly defined for the next 20 years, preventing future improvements and optimizations in the C++ runtime. This decision would also be almost catastrophic to implementors of other languages (in particular the CLR), who would need to reimplement a good chunk of the C++ runtime in order to bind to the native API. (Imagine what it takes to bind to a method that takes std::vector<std::string> as one of its arguments)
In comparison, WinRT has a relatively simple ABI, designed to be consumed easily by many different languages.
If you were really determined, you could probably access WinRT exclusively through the low-level COM interfaces using standard C++. This would be quite the painful experience, probably quite similar to using Win32/COM today. :) I'd rather use C++/CX, get my platform-specific code written as quickly as possible, and then spend the extra time on the parts of my application that actually solve problems. | null | 0 | 1316373304 | True | 0 | c2kswww | t3_kjja4 | null | t1_c2kswww | t1_c2ksagv | null | 1427616258 | 20 | t5_2fwo | null | null | null |
True | s73v3r | null | As long as you document it properly, it should come out that you created it first. Now, whether or not most people do the proper amount of documentation (which for patents, can be quite a lot), is another story. | null | 0 | 1316373654 | False | 0 | c2ksyfm | t3_khvyw | null | t1_c2ksyfm | t1_c2khhzc | null | 1427616269 | 2 | t5_2fwo | null | null | null |
True | s73v3r | null | Most other countries don't recognize software patents, however. | null | 0 | 1316373720 | False | 0 | c2ksyq3 | t3_khvyw | null | t1_c2ksyq3 | t1_c2kiuci | null | 1427616272 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Okay, nice quote once I saw it. But the layout of the site made me think the white box was a text advertisement to be skipped and so I sent my eyes down the page to the first thing that looked like a quote and I got this:
>You must be a registered user to use this feature. Log in using the form to the left, or register as a new user.
I thought, *well, okay*, I guess that's a decent programming quote. | null | 0 | 1316373728 | False | 0 | c2ksyrl | t3_kjhvo | null | t1_c2ksyrl | t3_kjhvo | null | 1427616272 | 1 | t5_2fwo | null | null | null |
True | ehird | null | Hmm? You might be mistaking my comment for a serious one. | null | 0 | 1316373803 | False | 0 | c2ksz30 | t3_kfvm7 | null | t1_c2ksz30 | t1_c2koeze | null | 1427616274 | 2 | t5_2fwo | null | null | null |
True | ggggbabybabybaby | null | Maybe that's because you buy iced coffees. | null | 0 | 1316373839 | False | 0 | c2ksz7x | t3_kjhvo | null | t1_c2ksz7x | t1_c2krclx | null | 1427616275 | 3 | t5_2fwo | null | null | null |
True | krl | null | Hey, DNA is programming too. | null | 0 | 1316373856 | False | 0 | c2kszab | t3_kjhvo | null | t1_c2kszab | t1_c2kr2wc | null | 1427616276 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Ah, a very common moment for EE students. "That RF circuit was transmitting just a few seconds ago. I'm serious professor! You have to believe!" | null | 0 | 1316373863 | False | 0 | c2kszbi | t3_kjhvo | null | t1_c2kszbi | t3_kjhvo | null | 1427616276 | 1 | t5_2fwo | null | null | null |
True | s73v3r | null | It doesn't remove prior art at all. If the invention is documented elsewhere before they actually file, then that still counts as prior art. | null | 0 | 1316373866 | False | 0 | c2kszby | t3_khvyw | null | t1_c2kszby | t1_c2kevsw | null | 1427616276 | 2 | t5_2fwo | null | null | null |
True | harlows_monkeys | null | Yeah, you are misreading.
Normally under the new law anything published before you file your patent application can be used as prior art against you.
What that part of 35 USC 102 is saying is that there is an exception--if you yourself publish up to a year before you file your patent application, anyone else's publication between the time of your publication and your patent application no longer counts as prior art.
If you don't publish, and a third party who somehow became aware of your invention tries to patent it, then you are right that this particular section of 35 USC 102 won't preclude them from getting a patent. You didn't publish so your invention is not part of the prior art.
However, to get a patent you have to satisfy ALL the requirements of patentability. One of those is that you invented the thing you are trying to patent. | null | 0 | 1316373875 | False | 0 | c2kszdi | t3_khvyw | null | t1_c2kszdi | t1_c2ksi5p | null | 1427616276 | 2 | t5_2fwo | null | null | null |
True | malfy | null | Hahahahaha. Perfect timing :P | null | 0 | 1316373888 | False | 0 | c2kszfn | t3_khf6j | null | t1_c2kszfn | t1_c2kgtb6 | null | 1427616278 | 1 | t5_2fwo | null | null | null |
True | s73v3r | null | No, that still couldn't happen, as the prior art still exists, and the source code would have been posted BEFORE the company claims they started work on it. | null | 0 | 1316373909 | False | 0 | c2kszj0 | t3_khvyw | null | t1_c2kszj0 | t1_c2kik4q | null | 1427616279 | 2 | t5_2fwo | null | null | null |
True | joedev_net | null | This checks out, because this is exactly what I'm planning on doing. | null | 0 | 1316373922 | False | 0 | c2kszlc | t3_kjhvo | null | t1_c2kszlc | t1_c2ksg0l | null | 1427616280 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | No, its native c++; generates native code.
There are three interfaces to WinRT:
* The new extended COM interface (native code)
* The cli/.net inteface
* The javascipt interface
But c++.cli (via the cli/.net interface) might be possible, too. | null | 0 | 1316374001 | False | 0 | c2kszww | t3_kjja4 | null | t1_c2kszww | t1_c2ksn24 | null | 1427616284 | 9 | t5_2fwo | null | null | null |
True | s73v3r | null | They have far more resources to spend on lawyers and not necessarily miss them than smaller businesses. | null | 0 | 1316374031 | False | 0 | c2kt00y | t3_khvyw | null | t1_c2kt00y | t1_c2khusy | null | 1427616286 | 1 | t5_2fwo | null | null | null |
True | thebigslide | null | Thank you thank you thank you.
The last thing I want to be worrying about when I'm attempting to add "product_sku_group.id > %d" to where_clause_array, is whether table_product_sku_group is being left joined in from_clause_head or if it's one of the members of from_clause_array. | null | 0 | 1316374115 | False | 0 | c2kt0f8 | t3_ki83r | null | t1_c2kt0f8 | t1_c2kljfj | null | 1428193742 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316374143 | True | 0 | c2kt0jy | t3_kjhvo | null | t1_c2kt0jy | t1_c2ksgdp | null | 1427616292 | 1 | t5_2fwo | null | null | null |
True | s73v3r | null | The thing with trade secrets is that they never have to be released into the public. With patents, although the company can hamper competitors for a while, eventually that knowledge gets passed into the public domain. Perhaps if patents had a shorter duration, then they would be more of an acceptable tradeoff. | null | 0 | 1316374293 | False | 0 | c2kt18n | t3_khvyw | null | t1_c2kt18n | t1_c2khzkm | null | 1427616302 | 1 | t5_2fwo | null | null | null |
True | emptythecache | null | That dude is a prick. I hate that I have to pretend the Ender's Game series wasn't written by him in order to keep loving it. | null | 0 | 1316374298 | False | 0 | c2kt19e | t3_kjhvo | null | t1_c2kt19e | t1_c2ksmt3 | null | 1427616302 | 1 | t5_2fwo | null | null | null |
True | TheSisko972 | null | Kirakun, luv, they are both written in C. So what's the "different paradigm" that you're talking about, muffin? | null | 0 | 1316374399 | False | 0 | c2kt1oo | t3_kjhvo | null | t1_c2kt1oo | t1_c2ksgdp | null | 1427616309 | 1 | t5_2fwo | null | null | null |
True | s73v3r | null | Patents have one very good aspect to them, and that's the fact that the knowledge that is patented does make it's way to the public domain. Doing away with the patent system altogether means that knowledge is going to be locked away inside the large companies that can afford to do that research. | null | 0 | 1316374410 | False | 0 | c2kt1qq | t3_khvyw | null | t1_c2kt1qq | t1_c2kl014 | null | 1427616310 | 1 | t5_2fwo | null | null | null |
True | harlows_monkeys | null | Generally no. There is a thing called "prior user" rights. This was covered before the new law under [35 USC 273](http://www.uspto.gov/web/offices/pac/mpep/documents/appxl_35_U_S_C_273.htm). Here's an excerpt from that:
It shall be a defense to an action for infringement under
section 271 of this title with respect to any subject matter
that would otherwise infringe one or more claims for a
method in the patent being asserted against a person, if
such person had, acting in good faith, actually reduced the
subject matter to practice at least 1 year before the effective
filing date of such patent, and commercially used the subject
matter before the effective filing date of such patent.
So basically if you reduced the invention to practice at least a year before the guy with the patent filed, and you started using your invention commercially before he filed, you get to continue. The rest of 35 USC 273 fills in the details and places some limits, but that's the gist of it.
The new law expands prior use rights, but I'm not familiar with the details. | null | 0 | 1316374579 | False | 0 | c2kt2gi | t3_khvyw | null | t1_c2kt2gi | t1_c2kqgiu | null | 1427616318 | 3 | t5_2fwo | null | null | null |
True | neitz | null | I honestly do not believe it is due to the static typing but rather the verbosity of the languages that is not conducive to quick prototyping. | null | 0 | 1316374620 | False | 0 | c2kt2m8 | t3_kjja4 | null | t1_c2kt2m8 | t1_c2ksu3g | null | 1427616319 | 27 | t5_2fwo | null | null | null |
True | the_opinion | null | I have. I got it there in a lunchbox | null | 0 | 1316374635 | False | 0 | c2kt2of | t3_kjhvo | null | t1_c2kt2of | t1_c2kross | null | 1427616320 | 1 | t5_2fwo | null | null | null |
True | the_opinion | null | And 'Reason' | null | 0 | 1316374721 | False | 0 | c2kt31u | t3_kjhvo | null | t1_c2kt31u | t1_c2ks6ea | null | 1427616324 | 1 | t5_2fwo | null | null | null |
True | s73v3r | null | >Doesn't first-to-file eliminate prior art as a means of invalidating a patent unless that prior art was patented?
Of course not. Just because something is out there and not patented doesn't mean that anyone can scoop it up. The prior art still exists that would cause the patent to be invalidated. | null | 0 | 1316374725 | False | 0 | c2kt32f | t3_khvyw | null | t1_c2kt32f | t1_c2kh6ff | null | 1427616324 | 2 | t5_2fwo | null | null | null |
True | s73v3r | null | Part of that is that they were woefully unfunded. They quite simply could not afford to pay people who actually have industry knowledge to evaluate patents. I remember hearing one of the provisions in the bill, not sure if it made it's way in to the final version, that said the Patent office would get to keep the fees they collect for filing patents, rather than having them go to the general fund. That should help in allowing them to hire more qualified people. | null | 0 | 1316374838 | False | 0 | c2kt3j5 | t3_khvyw | null | t1_c2kt3j5 | t1_c2khcgq | null | 1427616331 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | That was a crappy quote.
For a writer, that was really poorly worded. | null | 0 | 1316374908 | False | 0 | c2kt3tx | t3_kjhvo | null | t1_c2kt3tx | t3_kjhvo | null | 1427616335 | 1 | t5_2fwo | null | null | null |
True | jephthai | null | One thing that amazed me when I graduated with my computer science degree is how few in the software development world have a real educational background in CS. By my experience, these seminar ethics classes might cover 50% or less of "people who write software for a living." | null | 0 | 1316374947 | False | 0 | c2kt406 | t3_khtwb | null | t1_c2kt406 | t1_c2ke192 | null | 1427616337 | 1 | t5_2fwo | null | null | null |
True | s73v3r | null | >Considering there is a 1 year period before filing where prior art is not considered,
WRONG. Prior art is *always* considered. The difference applies to the case of when they have two entities that claim to have invented the same thing. Before, they each had to prove when they invented it. Now the first to file gets it. However, if a third party has invented something that could be considered prior art, and publicized it without getting a patent, then neither would get it. | null | 0 | 1316374974 | False | 0 | c2kt44i | t3_khvyw | null | t1_c2kt44i | t1_c2kikfd | null | 1427616339 | 1 | t5_2fwo | null | null | null |
True | banuday | null | Use [Scala](http://drsimplestuff.blogspot.com/2011/02/parallel-collections-in-scala.html)! (Braces for downvotes) | null | 0 | 1316375016 | False | 0 | c2kt4a8 | t3_kjdt6 | null | t1_c2kt4a8 | t1_c2kqg1c | null | 1427616341 | 4 | t5_2fwo | null | null | null |
True | sltkr | null | Oh, now I re-read it, I think you're right! That is very impressive! (The "so far" is a bit confusing; it seems to suggest he is trying arbitrary puzzles instead of searching through the entire space of possible puzzles.)
So the claim is that this puzzle is the most difficult one (in 4x4, at least)? | null | 0 | 1316375074 | True | 0 | c2kt4jm | t3_khf6j | null | t1_c2kt4jm | t1_c2ksqx2 | null | 1427616344 | 1 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | "Should you use Windows or Java?"
This question was heatedly debated in ~1998. Seriously. Although the one was an operating system and the other a programming language (not a platform at that time) people liked to discuss that topic (which was probably brought up by Sun marketing). | null | 0 | 1316375121 | False | 0 | c2kt4q6 | t3_kjf91 | null | t1_c2kt4q6 | t3_kjf91 | null | 1427616346 | 6 | 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.