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 | jkff | null | It depends on the language too. There certainly exist optimizations whose applicability depends on undecidable properties whose programmer-supplied proof can nevertheless be verified by the compiler. Then it depends on the language, not the implementation, whether the programmer has sufficient power to enable these optimizations.
I'm of course talking about type checking, memory management and general semantic properties of the language (e.g. purity, safety, lack of aliasing etc). | null | 0 | 1316326874 | False | 0 | c2kpibo | t3_kii9z | null | t1_c2kpibo | t1_c2kmgsv | null | 1427614584 | 1 | t5_2fwo | null | null | null |
True | lnxaddct | null | For those looking to learn more applications of this, there's more information about this sequence [here on the online encyclopedia of integer sequences](http://oeis.org/search?q=1%2C1%2C2%2C4%2C10%2C26%2C76%2C232%2C764&sort=&language=english&go=Search).
Note that for n < 2, f(n) = 1. | null | 0 | 1316326884 | False | 0 | c2kpict | t3_kj03o | null | t1_c2kpict | t1_c2knzqw | null | 1427614585 | 3 | t5_2fwo | null | null | null |
True | apullin | null | 1) Compilers are horrible. All of them. Try using MPLAB, and you'll see what I mean.
2) Chip vendors need to release some sort of XML description of their parts, and then someone needs to make an Eagle compatibility library with that, so I don't have to spend a whole day drawing an labeling packages.
3) There should be a free RTOS that is actually free, and doesn't sell their documentation as a book. | null | 0 | 1316326977 | False | 0 | c2kpinv | t3_kj1na | null | t1_c2kpinv | t3_kj1na | null | 1427614594 | -3 | t5_2fwo | null | null | null |
True | stridera | null | Sure, but there needs to be some knowledge showing how the code relates to the circuits. For example, I'm also a strong coder but would love to know more about electronics. My friend wants to make a hoola-hoop with flashing lights in it. It seems simple, but I have no clue where to start. Even a board like this (which would be overkill I'm sure) doesn't help me figure out the first step. Even the little bits doesn't help me figure out the resistors/etc needed to do something, just that little parts, premade by someone who knows what they're doing, will make something. How do you take the next step? | null | 0 | 1316327041 | False | 0 | c2kpium | t3_kj1na | null | t1_c2kpium | t1_c2knp6k | null | 1427614588 | 3 | t5_2fwo | null | null | null |
True | Rotten194 | null | Schrodinger's intranet | null | 0 | 1316327075 | False | 0 | c2kpiye | t3_kghid | null | t1_c2kpiye | t1_c2k8ije | null | 1427614590 | 2 | t5_2fwo | null | null | null |
True | therapy | null | It's open source, yes. But it isn't a standard, and it looks like no other browser vendor is interested in it. | null | 0 | 1316327250 | False | 0 | c2kpjgi | t3_kitgf | null | t1_c2kpjgi | t1_c2kp7ak | null | 1427614601 | 1 | t5_2fwo | null | null | null |
True | simonask | null | > How do you decide which it is?
The *parser* does not need to know. This information is strictly unneeded until the binding stage. | null | 0 | 1316327313 | False | 0 | c2kpjo7 | t3_kikut | null | t1_c2kpjo7 | t1_c2kmncn | null | 1427614599 | 1 | t5_2fwo | null | null | null |
True | simonask | null | Oh but it is. There's nothing context-sensitive about it. The *parser doesn't need to know what `foo` is*. It doesn't need to know if it's a template instantiation or a function call. This information is unneeded until a later stage of compilation (likely the binding stage).
You do not need semantic analysis to reliably parse something like this. Not more than is *already being done* in the type check stage, anyhow. | null | 0 | 1316327513 | False | 0 | c2kpka0 | t3_kikut | null | t1_c2kpka0 | t1_c2knnsk | null | 1428193767 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Well, I'm not saying it's not possible and nobody should try it, just wanted to say that there might be [more appropriate kit](http://www.radioshack.com/product/index.jsp?productId=2102914). | null | 0 | 1316327665 | False | 0 | c2kpkp8 | t3_kj1na | null | t1_c2kpkp8 | t1_c2kp67e | null | 1427614611 | 0 | t5_2fwo | null | null | null |
True | simonask | null | > You are right, but if the compiler interpreted it that way it would crowd out the actual meaning of a default argument.
What's the problem, again? :)
If there is a problem, this syntax would be equally concise:
void sort<C, Compare = std::less<C::value_type>>(C& container);
> Nope, what you did there is valid C++, but it is an overloaded function not a specialization.
Yes, of course I realize that. There is absolutely no reason the two should be different. There is no guessing needed.
> 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.
You don't *need* to know, that's the point. At least not until the template is instantiated. Until then, assume it's a type in places where it makes sense. Give a compiler error if it turns out it's something else than you expected.
Jeeze, these compilers are awfully whiny… | null | 0 | 1316327776 | False | 0 | c2kpl1e | t3_kikut | null | t1_c2kpl1e | t1_c2kmn09 | null | 1427614616 | 0 | t5_2fwo | null | null | null |
True | audaxxx | null | Thx, that was what I meant. I like ORMs. | null | 0 | 1316328253 | False | 0 | c2kpmhm | t3_ki83r | null | t1_c2kpmhm | t1_c2koaza | null | 1427614634 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | > Very strict language(haskell) are hard to use because they tend to get in the way
How does it get in your way? | null | 0 | 1316328712 | False | 0 | c2kpntc | t3_kikut | null | t1_c2kpntc | t1_c2kp3up | null | 1427614655 | 2 | t5_2fwo | null | null | null |
True | jutct | null | All hash algorithms don't use salt. Thats up to the discretion of the programmer. | null | 0 | 1316329003 | False | 0 | c2kpona | t3_khtwb | null | t1_c2kpona | t1_c2kieft | null | 1427614665 | 1 | t5_2fwo | null | null | null |
True | kamatsu | null | I thought Concepts were more like typeclasses. | null | 0 | 1316329210 | False | 0 | c2kpp80 | t3_kikut | null | t1_c2kpp80 | t1_c2km29g | null | 1427614670 | 2 | t5_2fwo | null | null | null |
True | kamatsu | null | You can actually implement structural subtyping as a library in Haskell, see HList. | null | 0 | 1316329244 | False | 0 | c2kppb0 | t3_kikut | null | t1_c2kppb0 | t1_c2kmf0q | null | 1427614672 | 2 | t5_2fwo | null | null | null |
True | audaxxx | null | session.query(User).filter(User.name.like('%ed')).order_by(User.id)
* http://www.sqlalchemy.org/docs/core/tutorial.html
* http://www.sqlalchemy.org/docs/orm/tutorial.html
It is not integrating SQL in the language but translating domain specific code to and from SQL. LINQ goes the other way around. | null | 0 | 1316329279 | False | 0 | c2kppe4 | t3_ki83r | null | t1_c2kppe4 | t1_c2kp23b | null | 1427614672 | 1 | t5_2fwo | null | null | null |
True | ascii | null | I guess I did. Yes, you could definitely say that having to use interfaces represent a failure of the structural typing model. The programmer _usually_ doesn't have to have the foresight of declaring an interface. Declaring interfaces (like in the sort situation) is for when you're using a very small part of a type with a large interface and want to make it extra easy to emulate the type in question. Most of the time, interfaces are just a waste of time in structural porgramming, and that's when it really shines. | null | 0 | 1316329571 | False | 0 | c2kpq72 | t3_kikut | null | t1_c2kpq72 | t1_c2kn758 | null | 1427614692 | 2 | t5_2fwo | null | null | null |
True | audaxxx | null | That was my point. Even though originally the term ORM may be only meant for relational <-> oop translations, translating relational data to monadic combinators is about the same.
About objects in Haskell: http://homepages.cwi.nl/~ralf/OOHaskell/
So if you really want OOP, you can of course also program OOP in Haskell ;) | null | 0 | 1316329642 | False | 0 | c2kpqdq | t3_ki83r | null | t1_c2kpqdq | t1_c2ko0q7 | null | 1427614687 | 1 | t5_2fwo | null | null | null |
True | jdk | null | She looks like [Eliza Dushku](http://en.wikipedia.org/wiki/Eliza_Dushku). | null | 0 | 1316330191 | False | 0 | c2kprsr | t3_kj1na | null | t1_c2kprsr | t3_kj1na | null | 1427614704 | -1 | t5_2fwo | null | null | null |
True | nixonrichard | null | I've done educational classes with mindstorms as well as amtel/TI based microcontrollers.
The biggest difference is mindstorms are going to cost you $200 per student and the student learns something less useful, whereas a straight microcontroller project will cost you $40 per student and the student learns something far more valuable.
I used to think the mindstorms were better because they're easier to use . . . way off. Kids are frickin' smart. It's scary. You give them a 30 minute tutorial on using an arduino-based microcontroller and they're off to the races. | null | 0 | 1316330365 | False | 0 | c2kps9f | t3_kj1na | null | t1_c2kps9f | t1_c2kn7al | null | 1427614713 | 23 | t5_2fwo | null | null | null |
True | mongreldog | null | Grow up moron. Most people here are sick of you're immature and inane statements. We want to hear informed and reasoned comments.
Maybe when you do grow up, we may let you sit at the grown-ups table where we expect at least some level of intelligent conversion between mature idividuals with knowledge of how the world really works. | null | 0 | 1316330750 | False | 0 | c2kpt6k | t3_kii9z | null | t1_c2kpt6k | t1_c2kjemu | null | 1427614723 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Just one simple example: Remember how they advertised their Windows NT ? And then Vista? They have always talked like the next versions is the best, but then we all know how sucks they are. Or take a look at Windows 8's Metro UI. Is it revolutionary, or a piece of crap? | null | 0 | 1316330904 | False | 0 | c2kptji | t3_kip3s | null | t1_c2kptji | t1_c2kpen7 | null | 1427614730 | -16 | t5_2fwo | null | null | null |
True | ulber | null | If you are referring to the "run silverlight as a metro app with little changes" thing, then luckily they don't have to keep any promise as **this is already true**. This is stuff that you can try out in the developer preview. | null | 0 | 1316330931 | False | 0 | c2kptm9 | t3_kip3s | null | t1_c2kptm9 | t1_c2kjzet | null | 1427614733 | 9 | t5_2fwo | null | null | null |
True | elperroborrachotoo | null | Maybe - either it was very small, or very big; anyway, I shrugged and decided not to look around for more than a second or so. | null | 0 | 1316331406 | False | 0 | c2kpusg | t3_kikut | null | t1_c2kpusg | t1_c2km1rg | null | 1427614743 | 2 | t5_2fwo | null | null | null |
True | elperroborrachotoo | null | Be careful, it's a very powerful curse! Not "power beyond comprehension of mere humans", but, say, about 12 bulldozers. | null | 0 | 1316331557 | False | 0 | c2kpv4u | t3_kikut | null | t1_c2kpv4u | t1_c2klyep | null | 1427614747 | 9 | t5_2fwo | null | null | null |
True | [deleted] | null | No. I'm not talking about it. I'm talking about the whole UI redesign. It simply sucks.
The only product from Microshit that I think is good for production use is Visual Studio. And must be either Professional or Ultimate. Express sucks too. | null | 0 | 1316331628 | False | 0 | c2kpvba | t3_kip3s | null | t1_c2kpvba | t1_c2kptm9 | null | 1427614751 | -14 | t5_2fwo | null | null | null |
True | anacrolix | null | No it's not. The formatting is retarded and it's mostly the same. | null | 0 | 1316331912 | False | 0 | c2kpvz8 | t3_ki52y | null | t1_c2kpvz8 | t1_c2knt7o | null | 1427614765 | 0 | t5_2fwo | null | null | null |
True | ulber | null | I have my reservations about that too. The touch experience will probably be great, but they still have to make it work with a mouse and keyboard (awkward in the developer preview). | null | 0 | 1316332014 | False | 0 | c2kpw8l | t3_kip3s | null | t1_c2kpw8l | t1_c2kpvba | null | 1427614762 | 1 | t5_2fwo | null | null | null |
True | djkrugger | null | I'm sure that if you read a bit or research some finished projects, you can figure it out, led circuits are fairly simple and repetitive, also you can find physical wiring diagrams instead of schematics.
It's crazy, but after 22 years in electronics you forget that not everybody knows how to wire some things.
If you want to start experimenting try r/electronics or r/arduino | null | 0 | 1316332232 | False | 0 | c2kpwr4 | t3_kj1na | null | t1_c2kpwr4 | t1_c2kpium | null | 1427614769 | 1 | t5_2fwo | null | null | null |
True | ibisum | null | [I learned Electronics with Denshi blocks. I wish these things had evolved to be embraced more widely in the Arduino scene..](http://en.wikipedia.org/wiki/Denshi_block) in Japan, they've got University-scale versions of Denshi systems, but they're not easily available outside of Japan, alas.
I still have my [EX150](http://en.wikipedia.org/wiki/Gakken_EX-System) and have been considering making a next-gen Denshi block design with a makerbot .. | null | 0 | 1316332706 | True | 0 | c2kpxvr | t3_kj1na | null | t1_c2kpxvr | t3_kj1na | null | 1427614785 | 3 | t5_2fwo | null | null | null |
True | FredFredrickson | null | Well, for people using tablets under Win8, I don't think it'll hurt much. They will want to preserve battery life and won't miss lack of plugins anyway. For everyone else, I guess desktop mode will be the way to go. | null | 0 | 1316332717 | False | 0 | c2kpxwq | t3_kgb4h | null | t1_c2kpxwq | t1_c2k4nvs | null | 1427614785 | 1 | t5_2fwo | null | null | null |
True | anacrolix | null | I strongly agree. Computers usually bring more problems than they solve. Employ them with prejudice. | null | 0 | 1316332994 | False | 0 | c2kpyhx | t3_ki52y | null | t1_c2kpyhx | t1_c2kjylz | null | 1427614791 | 1 | t5_2fwo | null | null | null |
True | ibisum | null | I loved Capsela, and was always pretty disappointed I couldn't easily (i.e. without resorting to a hot-glue gun) interface them with my Denshi blocks .. | null | 0 | 1316333055 | False | 0 | c2kpyn6 | t3_kj1na | null | t1_c2kpyn6 | t1_c2knpxl | null | 1427614793 | 2 | t5_2fwo | null | null | null |
True | ibisum | null | >WTF does this have to do with programming?
Do it the right way, no programming required. Do it the wrong way (i2C bit-banging, blah blah), some programming required.
| null | 0 | 1316333152 | False | 0 | c2kpyvf | t3_kj1na | null | t1_c2kpyvf | t1_c2kn3oa | null | 1427614796 | -1 | t5_2fwo | null | null | null |
True | incident_report | null | blackcomb, never forget. | null | 0 | 1316333263 | False | 0 | c2kpz45 | t3_kip3s | null | t1_c2kpz45 | t1_c2kjtp7 | null | 1427614799 | 3 | t5_2fwo | null | null | null |
True | saynte | null | Of course, if NaCl catches on, then any other browser *could* implement it, I think most/all of the tooling and code is open-source.
So the situation is not so bad: either the experiment fails and it dies in Chrome, or it succeeds and everyone else can take advantage of it too. | null | 0 | 1316333469 | False | 0 | c2kpzla | t3_kitgf | null | t1_c2kpzla | t1_c2kpjgi | null | 1427614805 | 2 | t5_2fwo | null | null | null |
True | DoWhile | null | That N-in-1 electronics kit brings back memories. | null | 0 | 1316333497 | False | 0 | c2kpzno | t3_kj1na | null | t1_c2kpzno | t1_c2kno1n | null | 1427614806 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316333819 | False | 0 | c2kq0c1 | t3_khhdj | null | t1_c2kq0c1 | t1_c2kix0c | null | 1427614816 | 1 | t5_2fwo | null | null | null |
True | cirquelar | null | My 7 year old wants to do electronics projects (apparently he needs to build a shrink ray like yesterday!), but he not ready for the concepts (electronics, that is, not molecular minimization), much less the soldering. We fooled around on a bread board for a small project (water filtration plant...don't ask), which was great, but it was still me doing it mostly and him watching. This would seem to be a good medium for him...but $130 is a bit of a show stopper. Something closer to $50 might be more manageable. Or maybe selling a smaller kit with only a few components and limited projects would be better to start. Maybe if they can up their volume the price will reduce... | null | 0 | 1316333834 | False | 0 | c2kq0dd | t3_kj1na | null | t1_c2kq0dd | t3_kj1na | null | 1427614816 | 1 | t5_2fwo | null | null | null |
True | mephitix | null | Ah, thanks for the clarification - I was wrong here; even though this is a simplistic example where the 'value.trim()' statement is executed in both branches the coverage reporter should not report 100% coverage... | null | 0 | 1316333850 | False | 0 | c2kq0ei | t3_khhdj | null | t1_c2kq0ei | t1_c2kcci1 | null | 1427614822 | 0 | t5_2fwo | null | null | null |
True | generic_0 | null | Awesome begging the question fallacy there, quanganht. | null | 0 | 1316333856 | False | 0 | c2kq0f6 | t3_kip3s | null | t1_c2kq0f6 | t1_c2kptji | null | 1427614822 | 8 | t5_2fwo | null | null | null |
True | redrover | null | It's nice to be able to compose hardware like this. Piping data from one module to another. | null | 0 | 1316333923 | False | 0 | c2kq0kl | t3_kj1na | null | t1_c2kq0kl | t3_kj1na | null | 1427614819 | 1 | t5_2fwo | null | null | null |
True | entropy2421 | null | i loved that thing, i often wish i still had it but i can't bear spending 50$ to get another. | null | 0 | 1316334089 | False | 0 | c2kq0wr | t3_kj1na | null | t1_c2kq0wr | t1_c2kpzno | null | 1427614825 | 1 | t5_2fwo | null | null | null |
True | Sc4Freak | null | Any "fresh alternative" to the Win32 API without COM would look exactly like the old Win32 API. You'd still be using handles, pointers, and calling plain old C functions.
C++ doesn't define a standard ABI, which makes it impossible to use C++ objects in an interface to a library. That's why COM exists, and that's how WinRT exposes a clean object-oriented interface to C++ developers. If not COM, how else would they do it?
And if you don't like the C++/CX extensions, then just turn them off and use plain old COM in standard ISO C++ like you always have! | null | 0 | 1316334327 | False | 0 | c2kq1f9 | t3_kgs75 | null | t1_c2kq1f9 | t1_c2k4era | null | 1427614834 | 2 | t5_2fwo | null | null | null |
True | robinwholikesjava | null | See also:
* http://www.carfey.com/blog/java-concurrency-part-5-queues/
* http://www.carfey.com/blog/java-concurrency-part-5-–-countdownlatch/
| null | 0 | 1316334331 | False | 0 | c2kq1fj | t3_kjdse | null | t1_c2kq1fj | t3_kjdse | null | 1427614834 | 3 | t5_2fwo | null | null | null |
True | cdsmith | null | "Not a standard" has to be the worst argument there is against trying something new. 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. Unlike ActiveX, which was deeply rooted in COM, there is no *reason* native client couldn't be implemented by other browsers. If it solves important problems, it will be. | null | 0 | 1316334531 | False | 0 | c2kq1vf | t3_kitgf | null | t1_c2kq1vf | t1_c2kpjgi | null | 1427614837 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | > Hampering market entry is a pretty fantastic way to make your half-assed product look better.
Can you cite any real world examples? | null | 0 | 1316334562 | False | 0 | c2kq1xj | t3_khvyw | null | t1_c2kq1xj | t1_c2koq3r | null | 1427614839 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316334651 | False | 0 | c2kq23s | t3_kicbo | null | t1_c2kq23s | t1_c2kkaeb | null | 1427614839 | 1 | t5_2fwo | null | null | null |
True | masklinn | null | > Any browser could implement it.
Yeah, they just have to port google's implementation code bug for bug. | null | 0 | 1316334811 | False | 0 | c2kq2fk | t3_kitgf | null | t1_c2kq2fk | t1_c2kp7ak | null | 1427614844 | 0 | t5_2fwo | null | null | null |
True | cdsmith | 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.
Native client, on the other hand, is intended to be directly targeted by highly optimizing compilers. Maybe there will be necessary compromises that cost you a bit of that performance, but it would take a lot of mistakes before it's comparable to Dart.
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. | null | 0 | 1316334996 | False | 0 | c2kq2to | t3_kitgf | null | t1_c2kq2to | t1_c2koqlp | null | 1427614848 | 2 | t5_2fwo | null | null | null |
True | robinwholikesjava | null | Cool, but *planning* to move from PG 8.2 to 8.3 in 2011???
[sarcasm] Isn't that a little too modern? Perhaps PG 6 would the safer choice! [/sarcasm] | null | 0 | 1316335370 | False | 0 | c2kq3kv | t3_kjdej | null | t1_c2kq3kv | t3_kjdej | null | 1427614858 | 3 | t5_2fwo | null | null | null |
True | cdsmith | null | > You can write in other languages than JS on the web right now, by compiling them to JS.
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.
> only in Chrome (and will never be added anywhere else).
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. | null | 0 | 1316335392 | False | 0 | c2kq3mp | t3_kitgf | null | t1_c2kq3mp | t1_c2kooxr | null | 1427614862 | 1 | t5_2fwo | null | null | null |
True | cdsmith | null | > PNaCl will give some amount of portability, but will likely trade that off against losing some speed. Just like JIT powered languages do.
Of course, the key is figuring out the magnitude of "some speed" there. If the speed lost by going through LLVM is a an order of magnitude lower, then there's still a pretty clear benefit to doing it that way. | null | 0 | 1316335474 | False | 0 | c2kq3so | t3_kitgf | null | t1_c2kq3so | t1_c2kor76 | null | 1427614861 | 1 | t5_2fwo | null | null | null |
True | Otis_Inf | null | I don't know whether Hibernate supports it, NHibernate certainly does. | null | 0 | 1316335983 | False | 0 | c2kq4rd | t3_ki83r | null | t1_c2kq4rd | t1_c2kmscy | null | 1427614875 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | >My guess? 0%. 'cause it's obvious they wouldn't eschew VS. That's just plain stupid.
Yea that's my guess too. Which is why I claim that they don't use it and therefore can't love it. How can you love something you don't use? Or how can you claim to love something you don't use?
| null | 0 | 1316336400 | False | 0 | c2kq5i7 | t3_kgl4f | null | t1_c2kq5i7 | t1_c2kke8s | null | 1427614884 | 0 | t5_2fwo | null | null | null |
True | slyf | null | Oh wow, this is a really really great idea. | null | 0 | 1316337358 | False | 0 | c2kq76o | t3_kj1na | null | t1_c2kq76o | t3_kj1na | null | 1427614905 | 1 | t5_2fwo | null | null | null |
True | xon_xoff | null | There is one big difference that I can see, which is that PNaCl will be able to support an explicit malloc/free model instead of forcing a GC to attain memory safety. This makes porting C/C++ code into PNaCl easier. Speed-wise, though, I think it would lose against a VM with vector instruction support and an alignment-savvy GC. The silly part is that PNaCl essentially will be doing what the OS should be doing, which is to allow applications to create and control fully sandboxed child processes.
| null | 0 | 1316337572 | False | 0 | c2kq7kj | t3_kitgf | null | t1_c2kq7kj | t1_c2koloh | null | 1427614911 | 4 | t5_2fwo | null | null | null |
True | stesch | null | > it only runs in Chrome
When the project started I tried the plugin for Firefox. | null | 0 | 1316337613 | False | 0 | c2kq7mz | t3_kitgf | null | t1_c2kq7mz | t1_c2kostv | null | 1427614911 | 3 | t5_2fwo | null | null | null |
True | Taladar | null | One annoying thing about QtConcurrent::map(...) and other functions with similar signatures in there is that they all return QVector, no matter which container you pass in. | null | 0 | 1316338127 | False | 0 | c2kq8g1 | t3_kjebe | null | t1_c2kq8g1 | t3_kjebe | null | 1427614922 | 5 | t5_2fwo | null | null | null |
True | afiefh | null | Could you provide a link to those mysterious Models you talk about? I never heard about it. | null | 0 | 1316338315 | False | 0 | c2kq8s6 | t3_ki83r | null | t1_c2kq8s6 | t1_c2kiibv | null | 1427614937 | 1 | t5_2fwo | null | null | null |
True | jessta | null | Seriously? ok.
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. The pure functional thing means that you can't do IO in certain places without fixing up all the types around it.
No mutable state means that problems best expressed as mutations have to be expressed in a round about way.
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.
| null | 0 | 1316338837 | False | 0 | c2kq9kt | t3_kikut | null | t1_c2kq9kt | t1_c2kpntc | null | 1427614943 | 2 | t5_2fwo | null | null | null |
True | 4ad | null | Don't use Vector in Go! It's obsolescent, it will be removed soon, being there in the documentation is only confusing.
Use slices instead, they do everything Vector used to do, and more. And you can create a slice of whatever type.
| null | 0 | 1316339191 | False | 0 | c2kqa42 | t3_kikut | null | t1_c2kqa42 | t1_c2kozw7 | null | 1427614947 | 1 | t5_2fwo | null | null | null |
True | Andomar | null | I'm not arguing: as I posted, I've never won an argument against ORM. Rationality seems to be on the ORM side.
I'm sharing my experience that ORM ends up hurting in the long run. Your comment suggests you have heard that from more people. Perhaps this is one of those things you can only learn from experience. | null | 0 | 1316339403 | False | 0 | c2kqaef | t3_ki83r | null | t1_c2kqaef | t1_c2ko4xd | null | 1427614949 | 3 | t5_2fwo | null | null | null |
True | generic_0 | null | On one hand, MIPS is nice for an intro to the basics of assembly programming (I learned it in a computer architecture course in college), but I think that understanding some of the ways x86 works is more important than pedagogical simplicity. There are a *ton* of x86 instructions, but only a few (<40) that you really need to know well for the most part. And if you ever want to do any reverse engineering or hacking around with binary code, it's crucial to understand basics about how x86 handles tasks such as function calling with stack frames or conventions for commonly used registers. | null | 0 | 1316339607 | False | 0 | c2kqaph | t3_khxzd | null | t1_c2kqaph | t1_c2kl1am | null | 1427614952 | 1 | t5_2fwo | null | null | null |
True | Taladar | null | Why use an SQL database at all for something that would fit a document database or even just a filesystem much better than s relational datastore? | null | 0 | 1316340952 | False | 0 | c2kqcla | t3_kjete | null | t1_c2kqcla | t3_kjete | null | 1427614976 | 1 | t5_2fwo | null | null | null |
True | the_opinion | null | And? That's not eliminating the need for it. I for one can't be bothered to write SQL where a simple method call will achieve the same thing. SQL has it's place, of course, but what's the point in it when all you want is, for example, every column of a single row of a table that maps exactly to a domain object? Wasteful | null | 0 | 1316341098 | False | 0 | c2kqct3 | t3_ki83r | null | t1_c2kqct3 | t1_c2kne7v | null | 1427614978 | 0 | t5_2fwo | null | null | null |
True | the_opinion | null | I don't | null | 0 | 1316341217 | False | 0 | c2kqcyx | t3_ki83r | null | t1_c2kqcyx | t1_c2klm67 | null | 1427614982 | 0 | t5_2fwo | null | null | null |
True | skew | null | > Obviously the time the students took was not fixed, otherwise they could not possibly have different averages.
The experiment design gave all students the same amount of time to work on the parser, and measured the test pass rate of the parser at the end, and the time during the project where they first had a working *lexer*.
The experimental result was that after working at the same task for the same amount of time, that static and dynamic typing groups had roughly equally functional parsers, but the dynamic typing group tended to have finished the lexing subproblem earlier.
> My hobby does not extend to 'pay the ACM $15 to download one paper' to check a fine point which you seem to be obtusely trying to convey by any method other than saying it.
The hobby I was referring to was
> As well, one of my own hobbies is tracking predictions, and it no longer surprises me to see people engaging in what is obviously hindsight bias, or privileging their hypotheses, or retroactively reinterpreting what they had written, or just ignoring things. The easiest person to fool is oneself.
You seem to enjoy claiming that others are being wrong more than trying to be less wrong yourself. Wasn't switching between the bayesian "Small evidence is still evidence." and frequentist "The pass-rate was not statistically significant" as let you argue against others should have been a red flag. Take care to avoid
http://lesswrong.com/lw/he/knowing_about_biases_can_hurt_people/
As for access, there's one link already in this thread, and another [here](http://www.cs.washington.edu/education/courses/cse590n/10au/hanenberg-oopsla2010.pdf) (from the first page of google hits). | null | 0 | 1316341268 | False | 0 | c2kqd1n | t3_k7o9e | null | t1_c2kqd1n | t1_c2kocu5 | null | 1427614984 | 1 | t5_2fwo | null | null | null |
True | deong | null | Ah, thanks for the info. | null | 0 | 1316341395 | False | 0 | c2kqd7v | t3_khvyw | null | t1_c2kqd7v | t1_c2koka4 | null | 1427614988 | 1 | t5_2fwo | null | null | null |
True | Koreija | null | > The current codebase I'm working with has over a GB of source code
I think you answered the question for yourself. If your "GB of source code" doesn't consist of multiple programs with specified interfaces and protocols then with a probability bordering on certainty there is sth. horribly wrong with this project. It's obviously no critical software, so I assume that you just wrapped up multiple projects into one. | null | 0 | 1316341449 | False | 0 | c2kqdas | t3_khkyd | null | t1_c2kqdas | t1_c2kn5j9 | null | 1427614990 | 2 | t5_2fwo | null | null | null |
True | Poita_ | null | I was turned off too when I first looked at it, but trust me when I say that you quickly get over it. It's really not that much of a change and the benefits it brings are tremendous. | null | 0 | 1316341457 | False | 0 | c2kqdb6 | t3_kikut | null | t1_c2kqdb6 | t1_c2kkqif | null | 1427614990 | 2 | t5_2fwo | null | null | null |
True | johnwaterwood | null | Personally I think having a fork/join implementation available in the standard Java library opens huge posibilities.
Not all algorithms are expressable in f/j, but many are and the scaling on a single system (using all cores) is really good. | null | 0 | 1316341460 | False | 0 | c2kqdbe | t3_kjdt6 | null | t1_c2kqdbe | t3_kjdt6 | null | 1427614990 | 2 | t5_2fwo | null | null | null |
True | the_opinion | null | From what I can see, Squeryl attempts to avoid SQL by providing a Scala DSL that directly encapsulates SQL. So whatever SQL you might want to write, can be written in Scala instead. Not entirely sure what the point is, since anybody who wants to write a complex SQL query presumably already knows how to. But at least it's an ORM layer that seemingly actually does eliminate the 'need' for SQL. | null | 0 | 1316341608 | False | 0 | c2kqdj2 | t3_ki83r | null | t1_c2kqdj2 | t1_c2kl2jq | null | 1427614993 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Refactoring is a difficult story with XCode.
On XC4 I love the obj-c refactoring capabilities. The C refactoring is OK. And the C++ refactoring SUCKS (as it's non existent).
But to be honest: Refactoring won't bring me to a IDE whose UI is ugly and slow. (I even wouldn't switch if that IDE was free.)
I guess the market for AppCode is all those Java developers who want to write iPhone apps. | null | 0 | 1316341799 | False | 0 | c2kqdso | t3_khqu6 | null | t1_c2kqdso | t1_c2kd9gb | null | 1427614996 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | oh god someone shot it in the head with an arrow Q_Q | null | 0 | 1316342388 | False | 0 | c2kqel4 | t3_khtwb | null | t1_c2kqel4 | t1_c2kdvyb | null | 1427615007 | 1 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | Database records are mapped to application records: JavaBeans in Java, other record-like structures in other languages (if there were an ORM in C it would map to structs). This has nothing to do with object-oriented (= polymorphic, encapsulated) programming. | null | 0 | 1316342643 | False | 0 | c2kqex3 | t3_ki83r | null | t1_c2kqex3 | t1_c2knz3q | null | 1427615009 | 2 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | you're doing it wrong. | null | 0 | 1316342714 | False | 0 | c2kqf0t | t3_ki83r | null | t1_c2kqf0t | t1_c2kqcyx | null | 1427615010 | 1 | t5_2fwo | null | null | null |
True | Bamafan | null | > For simple queries of the 'get me a couple of objects with names like 'aaa' , or 'look up the information of customer number x', an ORM makes things cleaner. But IME, most ORM's try to do to much, and fail.
Bingo. | null | 0 | 1316342760 | False | 0 | c2kqf2h | t3_ki83r | null | t1_c2kqf2h | t1_c2kjc6l | null | 1427615010 | 2 | t5_2fwo | null | null | null |
True | iLiekCaeks | null | >LDT support was removed with x64 versions of Windows
Because the hardware (64 bit x86 CPUs) don't support this segmentation stuff anymore. To be precise, segmentation is totally crippled on 64 bit. | null | 0 | 1316343071 | False | 0 | c2kqfhw | t3_kitgf | null | t1_c2kqfhw | t1_c2knndr | null | 1427615014 | 2 | t5_2fwo | null | null | null |
True | iLiekCaeks | null | I guess the original idea was that you could run heavily (compiler) optimized native code in the browser. This could include hand optimized assembler routines, which are essential for high performance stuff, such as for example video decoders. Try writing a fast video decoder in JavaScript, or these utterly retarded C++ -> JS converters. | null | 0 | 1316343341 | False | 0 | c2kqfw8 | t3_kitgf | null | t1_c2kqfw8 | t1_c2kmf7r | null | 1427615022 | 2 | t5_2fwo | null | null | null |
True | bitchessuck | null | This article nicely demonstrates what's wrong with Swing. Layout is a total mess and the layout managers are either very limited (like BorderLayout) or too flexible and complicated (like GridBagLayout).
Widget layout is much easier to understand and to use in most other toolkits. I mostly know GTK, Wx and Qt, but in all of them it's pure joy compared to Swing. 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.
Well, maybe it's just me, but so far Swing is definitely the worst UI toolkit I've seen. | null | 0 | 1316343368 | False | 0 | c2kqfxp | t3_kje6b | null | t1_c2kqfxp | t3_kje6b | null | 1427615026 | 2 | t5_2fwo | null | null | null |
True | mikehaggard | null | Would be cool if various collection utility methods (Sort!) would start using fork join automatically! | null | 0 | 1316343438 | False | 0 | c2kqg1c | t3_kjdt6 | null | t1_c2kqg1c | t1_c2kqdbe | null | 1427615021 | 3 | t5_2fwo | null | null | null |
True | abattle | null | Usage is up to the user. The article is about a database engine modification, not an application of Sqlite. | null | 0 | 1316343723 | False | 0 | c2kqgee | t3_kjete | null | t1_c2kqgee | t1_c2kqcla | null | 1427615026 | 13 | t5_2fwo | null | null | null |
True | matthieum | null | Isn't structural subtyping the same as duck-typing ? (what C++ templates and go interfaces support)
I know there is a difference between Go's and Haskell's approach to interfaces, since Go uses duck-typing while Haskell requires you to declare you allow your data type to be used with a particular interface....
I'll refine my sentence anyway, *only* allowing hard-wiring of interfaces at class-design time makes for a very weak system.
In C++ for example it's "amusing" to mix inheritance + templates in a manner similar to your Scala example:
struct SetTextInterface {
virtual void setText(std::string text) = 0;
virtual ~SetTextInterface() {}
};
template <typename T>
struct SetTextAdapter: SetTextInterface {
SetTextAdapter(T& t): _data(t) {}
virtual void setText(std::string text) { _data.setText(text); }
T& _data;
};
You can then provide methods which operates on interfaces (cutting down compilation time), and yet be able to pass about any class that support the methods you want, thanks to our little adapter. | null | 0 | 1316343754 | False | 0 | c2kqgfx | t3_kikut | null | t1_c2kqgfx | t1_c2km0iy | null | 1427615037 | 1 | t5_2fwo | null | null | null |
True | scook0 | null | > First to invent only changes what happens when two or more people who all would otherwise qualify for a patent are claiming overlapping inventions.
If two people create overlapping non-identical inventions, and one of them gets a patent, does that prevent the other inventor from using the overlapping part of his own invention? | null | 0 | 1316343809 | False | 0 | c2kqgiu | t3_khvyw | null | t1_c2kqgiu | t1_c2kk9jp | null | 1427615028 | 2 | t5_2fwo | null | null | null |
True | Taladar | null | The article is about making a Wikipedia desktop client, I should have clarified that I was talking about that particular use. | null | 0 | 1316343852 | False | 0 | c2kqgl7 | t3_kjete | null | t1_c2kqgl7 | t1_c2kqgee | null | 1427615028 | 0 | t5_2fwo | null | null | null |
True | matthieum | null | I agree, Go is very limited because it does not support Parametric or Dependent Types. | null | 0 | 1316343985 | False | 0 | c2kqgsa | t3_kikut | null | t1_c2kqgsa | t1_c2knaqk | null | 1427615031 | 4 | t5_2fwo | null | null | null |
True | donkey_lz | null | I hate git with a passion but it's just so ubiquitous that it should probably belong in a recommendation for a newbie.
Part of my hatred comes from being used to Mercurial. When I switched jobs, I had to start using git (which is what we use where I work now) and suddenly every non-trivial operation began to require minutes of sifting through manpages and painful repairing because of various gotchas. On the plus side, it does give you far more fine-grained control. On the minus side, I usually just want to do version control for my code, not run a small country.
I think that in the interest of mental sanity of programmers worldwide, git should be cast back into the chasms from where it came, but in the meantime, it's the tool that people are most likely to encounter, so they should definitely be familiar with it. | null | 0 | 1316344126 | False | 0 | c2kqgzz | t3_khkyd | null | t1_c2kqgzz | t1_c2kb13s | null | 1427615034 | 1 | t5_2fwo | null | null | null |
True | abattle | null | No, it only mentions that project because that's where the idea came from. The article is about Sqlite compression. If you're interested you can check out WikiDesk, it's not as simple as you might think. | null | 0 | 1316344176 | False | 0 | c2kqh2p | t3_kjete | null | t1_c2kqh2p | t1_c2kqgl7 | null | 1427615035 | 6 | t5_2fwo | null | null | null |
True | mikehaggard | null | What do you think about SWT??? Have you used it? | null | 0 | 1316344225 | False | 0 | c2kqh55 | t3_kje6b | null | t1_c2kqh55 | t1_c2kqfxp | null | 1427615037 | 1 | t5_2fwo | null | null | null |
True | Poddster | null | altgr+that key will get you the letter. But, they're never printed on the keys because no one cares enough to. | null | 0 | 1316344554 | False | 0 | c2kqhmj | t3_kicbo | null | t1_c2kqhmj | t1_c2kjrev | null | 1427615043 | 1 | t5_2fwo | null | null | null |
True | donkey_lz | null | > Without a CS degree you are not able to write efficent and correct programs or even a specification. All you get is UML crap, bloaty software, OOP and lots of errors.
I beg to differ. I don't have a CS degree and I'm quite able to write a specification, a correct program and I think they're quite efficient, too, given that they can achieve a fair lot of stuff in the couple of KB of memory the MSP430s give me.
> But with degree you're not interested in boring everday problems of a typical programmer job.
How about non-boring ones? Where I work, we do fairly interesting embedded systems projects, certainly not what I'd call boring. I lost count of how many candidates with CS degrees were turned down at the interview because they didn't know what a stack frame was or couldn't write a trivial interrupt handler.
We've got a truckload of source code, carefully divided and organized because a RTOS, a wireless communication stack, the USB stack *and* the user applications have to run in 8-32 KB of RAM. The last thing I need is a colleague who can explain me the intricacies of the halting problem but introduces race conditions all over the code because he's not sure how preemptive kernels work. | null | 0 | 1316344658 | False | 0 | c2kqhrj | t3_khkyd | null | t1_c2kqhrj | t1_c2kd2t6 | null | 1427615045 | 1 | t5_2fwo | null | null | null |
True | Poddster | null | what an abuse of stackoverflow. | null | 0 | 1316344658 | False | 0 | c2kqhrk | t3_kicbo | null | t1_c2kqhrk | t3_kicbo | null | 1427615045 | -5 | t5_2fwo | null | null | null |
True | mikehaggard | null | Funny thing, people always say that web frameworks should be like Swing. But does anyone actually like Swing? | null | 0 | 1316344840 | False | 0 | c2kqi1k | t3_kje6b | null | t1_c2kqi1k | t1_c2kqfxp | null | 1427615048 | 0 | t5_2fwo | null | null | null |
True | gefahr | null | Are there any ORMs (in any language) that use compile time info / static analysis / etc. to determine what to load? | null | 0 | 1316345079 | False | 0 | c2kqie4 | t3_ki83r | null | t1_c2kqie4 | t1_c2kjnxo | null | 1427615052 | 3 | t5_2fwo | null | null | null |
True | gligoran | null | It's nice and all, but these kinds of projects are popping up all over KickStarter. | null | 0 | 1316345163 | False | 0 | c2kqij0 | t3_kj1na | null | t1_c2kqij0 | t3_kj1na | null | 1427615054 | 2 | t5_2fwo | null | null | null |
True | AcronymsConfuseMe | null | Oxygen Rotation Mechanism | null | 0 | 1316345585 | False | 0 | c2kqj4a | t3_ki83r | null | t1_c2kqj4a | t1_c2klb4h | null | 1427615061 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | What a bullshit know nothing article rife with straw men and lame conclusions.
>The most obvious problem with ORM as an abstraction is that it does not adequately abstract away the implementation details. The documentation of all the major ORM libraries is rife with references to SQL concepts. Some introduce them without indicating their equivalents in SQL, while others treat the library as merely a set of procedural functions for generating SQL.
His notion of "adequate" is apprentsly "perfect". Of course it's rife with SQL concepts you idiot. ORM is an abstraction over SQL. How the hell else is the documentation supposed to explain what it's doing?
>The whole point of an abstraction is that it is supposed to simplify. An abstraction of SQL that requires you to understand SQL anyway is doubling the amount you need to learn:
The purpose of an ORM isn't to learn less it's to do less work. It's to make your life easier by not hand crafting database specific SQL and scattering your code with it.
I could go on and on but really this is a complete shit of an article written by a person who doesn't know what the fuck he is talking about. | null | 0 | 1316346512 | False | 0 | c2kqkhj | t3_ki83r | null | t1_c2kqkhj | t3_ki83r | null | 1427615079 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | >Completely disagree with all the negative comments here. Assuming you are writing non-trivial applications, it is highly likely you've bumped into the corners cases that aren't handled very well by ORM "solutions".
So what? You stop using the ORM because you bumped into a corner case? That seems dumb.
>One or two of these corner cases will blow through all the alleged time savings you gain by using an ORM.
I call bullshit on this one. You will run into a corner case one or twice a year if you are lucky. The ORM lightens your load every day.
| null | 0 | 1316346942 | False | 0 | c2kql5j | t3_ki83r | null | t1_c2kql5j | t1_c2kiq6k | null | 1427615089 | 1 | t5_2fwo | null | null | null |
True | aardvark179 | null | The JVM actually specifies quite closely what characters are allowed in identifiers, see Character.isJavaIdentifierStart and isJavaIdentifierPart for details. It has in the past been a little lax in enforcing these rules at the JVM level, but 7 has tightened this up a little. | null | 0 | 1316347223 | False | 0 | c2kqlji | t3_kicbo | null | t1_c2kqlji | t1_c2kjnaq | null | 1427615093 | 2 | 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.