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 | ffrinch | null | No, the problem is that csnappy's project page description doesn't use the "C implementation" bigram. If it did, Google probably would have picked it up.
If you'd happened to search for "snappy pure c" instead, you would've found it. | null | 0 | 1316392649 | False | 0 | c2kv4af | t3_kjete | null | t1_c2kv4af | t1_c2kuu2y | null | 1427617283 | 1 | t5_2fwo | null | null | null |
True | mistoroboto | null | Opinions aren't right or wrong. | null | 0 | 1316392680 | False | 0 | c2kv4er | t3_kjja4 | null | t1_c2kv4er | t1_c2kv243 | null | 1427617285 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | This has yet to be seen. Only when someone can get WinRT working with clang or Mingw can MS really make this claim. I'm not holding my breath on that. | null | 0 | 1316392709 | False | 0 | c2kv4ij | t3_kjja4 | null | t1_c2kv4ij | t1_c2ktq7a | null | 1427617286 | -4 | t5_2fwo | null | null | null |
True | [deleted] | null | Visual Studio is not the only C++ compiler for Windows, and that's the issue I have with this.
WinRT is basically a way to force Visual Studio for all Windows UI development, instead of being able to use Mingw or clang. | null | 0 | 1316392762 | False | 0 | c2kv4q0 | t3_kjja4 | null | t1_c2kv4q0 | t1_c2kuknr | null | 1427617289 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Very nice post!
Another loaded word related to "expressiveness" is "power". For instance, if we look at how some language, say, Basic, is interpreted, we have the syntax with various predefined constructs, like `if condition then ...` which gets parsed into an AST that can be represented as `(if (condition) (...))`, which then is evaluated, node by node.
Now if we consider a language that works directly on this deeper level of ASTs, and allows us to make our own special words like `if`, indistinguishable from the built-in ones, then this language (that would be a dialect of Lisp) would be more "powerful" than Basic.
If we don't stop there and look at the AST evaluation loop and squint just right (also, imagine that it's just that, a simplest possible evaluation loop), then we might notice that the way it treats composite expressions is not something entirely fundamental. I mean, we have this monolithic recursive function, "go over all subexpressions, if one is an atom, then evaluate it and push the result on a special stack, else recurse and similarly push the result, then call the bottom item of the stack with the rest as arguments".
We can decompose/transform into a simple loop as follows: read the next word, if it's an opening parenthesis then create a special substack, else evaluate/call it and push the result, unless it's a closing parenthesis, in which case evaluate the current substack and push the result on the previous substack.
This way, if we give the program full access to all our special variables, the parentheses themselves would become ordinary words, and we can simplify our loop to "read and execute the next word".
There are further gory details required to make this fly, and along the way we would get rid of the loop altogether, kind of making each word implicitly tail-recursive, extremely roughly speaking; I can direct everyone interested to [this literate implementation](http://git.annexia.org/?p=jonesforth.git;a=tree).
The point here is that we just performed another more or less identical step up the power hierarchy. First we moved from the Basic syntax to a Lisp dialect implementing a DSL with Basic semantics but also allowing us to implement a lot of other things, thanks to reserved words now being reified. Then we moved to a Forth dialect implementing a Lisp-like DSL, but similarly giving us more power to implement even more different things, thanks to the very structure of our program now being reified.
Was it worth it? Does this additional "power" translate directly into "being better (for writing useful programs)"? I, personally, don't think so, it doesn't, at least not unconditionally. It's _very_ inconvenient, and to make it more convenient you'll have to implement a lot of abstractions from the "less powerful" levels, which would leak and interact with each other poorly unless you put a lot of thought into them. | null | 0 | 1316392897 | False | 0 | c2kv5b8 | t3_kjw0j | null | t1_c2kv5b8 | t3_kjw0j | null | 1427617297 | 9 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316392925 | False | 0 | c2kv5fw | t3_kjja4 | null | t1_c2kv5fw | t1_c2kv3mx | null | 1427617299 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316392999 | False | 0 | c2kv5qh | t3_k42i7 | null | t1_c2kv5qh | t3_k42i7 | null | 1427617303 | 1 | t5_2fwo | null | null | null |
True | joe24pack | null | that surely will not get us anywhere. | null | 0 | 1316393001 | False | 0 | c2kv5qt | t3_kjw0j | null | t1_c2kv5qt | t1_c2kutrr | null | 1427617303 | 8 | t5_2fwo | null | null | null |
True | Forbizzle | null | People that bicker like this online must have been absolute nightmares in the classroom.
Lose the ego, make less assertions, and talk through others opinions rather than just enforcing your own. | null | 0 | 1316393084 | False | 0 | c2kv62q | t3_kjw0j | null | t1_c2kv62q | t3_kjw0j | null | 1427617307 | 8 | t5_2fwo | null | null | null |
True | joe24pack | null | Arguments 140 characters at a time; it's sure to be a thorough, well reasoned debate. | null | 0 | 1316393117 | False | 0 | c2kv68b | t3_kjw0j | null | t1_c2kv68b | t3_kjw0j | null | 1427617309 | 55 | t5_2fwo | null | null | null |
True | ezekiel | null | Maybe no wide-ranging statistics, but...
It took me at least 15 years of programming to end up having discovered half of "pure functional programming" concepts on my own just by figuring out what helped and what hurt small and large software worked on by all kinds of development teams.
Since that point, I have tested the array of functional programming concepts, weighed them against other 1990-2011 ideas, and reached the same conclusions as in this article:
**Pure-functional programming is the Silver Bullet**.
By "pure", I mean referentially transparent in the sense of no side effects (including no global variables), no changing a functions arguments, and usually the function must return a fresh value (not an object instance harvested from or assembled from the arguments).
Also, I require that each function do exactly one thing and its name clearly reflects that. If there is no clear name, the function is designed wrong.
In Java and C#, I stretch the concept to allow for a few very carefully defined specific side-effect functions (like WriteFile or SavePerson) that break the side-effect rule in a safe, obvious way.
I claim the following:
* Shorter total development time
* First release to QA is usually the same code that is released to users
* QA finds very few bugs
* First release works
* Follow-on added features are quick and simple for any developer
* Little need for massive frameworks and libraries
* Faster execution time and quicker user response time
Not statistical but real nonetheless. | null | 0 | 1316393143 | False | 0 | c2kv6c3 | t3_kjkxj | null | t1_c2kv6c3 | t1_c2kul4p | null | 1428193734 | 7 | t5_2fwo | null | null | null |
True | gecko | null | Not only can you do this; they walked through exactly what's required, with a demo. The session was something like "Under the covers with the C++ WinRT implementation," if you have access to BUILD sessions. The additional syntax is comically easy to totally ignore if you want to. You just end up doing a lot of HRESULT checks, instead of having exceptions. | null | 0 | 1316393160 | False | 0 | c2kv6ee | t3_kjja4 | null | t1_c2kv6ee | t1_c2kswww | null | 1427617311 | 5 | t5_2fwo | null | null | null |
True | drewfer | null | Yes and I know it's probably paranoid, but I've spent the last 20ish years watching MS do things to undermine open standards. It's not easy to take such things at face value. | null | 0 | 1316393227 | False | 0 | c2kv6oe | t3_kjja4 | null | t1_c2kv6oe | t1_c2kv3mx | null | 1427617319 | 0 | t5_2fwo | null | null | null |
True | comex | null | Under this definition, the most powerful language is the Unix shebang, as it simplifies the loop to "feed the raw text contents of the file into some arbitrary program" :) | null | 0 | 1316393253 | False | 0 | c2kv6sb | t3_kjw0j | null | t1_c2kv6sb | t1_c2kv5b8 | null | 1427617316 | 5 | t5_2fwo | null | null | null |
True | comex | null | > So I would say a language is expressive if it allows or enables the programmer to be expressive. Languages that restrict expression are not expressive.
This is not the only definition of expressive: one might also say that a language is more expressive if it allows the programmer to be expressive *with less code*, since that means the same amount of code can express more. Thus, although Haskell cannot express as much as Perl, it requires vastly less code to express various concepts, so one might say it is more expressive. | null | 0 | 1316393320 | False | 0 | c2kv724 | t3_kjw0j | null | t1_c2kv724 | t3_kjw0j | null | 1427617328 | 13 | t5_2fwo | null | null | null |
True | ssylvan | null | The API isn't a C++ API, it's a C++/C#/Javascript/WhateverWeMayHaveInTheFuture API. C++ needed extensions to deal with that. If all you ever wanted was C++, then there wouldn't be an issue.
Writing a platform for an OS isn't the same as writing a language-specific library. If you have half a billion users, then a small number of platform-specific extensions to improve the lives of all the developers targeting those users doesn't seem like a massive deal to me. | null | 0 | 1316393321 | True | 0 | c2kv726 | t3_kjja4 | null | t1_c2kv726 | t1_c2kusdi | null | 1427617328 | 2 | t5_2fwo | null | null | null |
True | ssylvan | null | I would be surprised if they weren't free to support the extensions. And if not, I guess part of the cost of using Mingw is that you have to manually deal with the COM stuff. | null | 0 | 1316393420 | False | 0 | c2kv7h6 | t3_kjja4 | null | t1_c2kv7h6 | t1_c2kv4q0 | null | 1427617325 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316393830 | False | 0 | c2kv95w | t3_kjhvo | null | t1_c2kv95w | t1_c2kr2wc | null | 1427617347 | 1 | t5_2fwo | null | null | null |
True | ZMeson | null | I often follow a similar approach, avoiding creating new classes. However, I still use C++ because:
* You can write non-OOP imperative code in C++. There is no requirement to use OOP.
* You actually get stricter typing in C++ over C. Some implicit casts in C require explicit casts in C++. (ex: void* cannot be implicitly casted to other pointer types)
* I prefer to use C++-style casts over C-style casts because they are easier to search for.
* In C++, I get to use smart pointers to help make memory management easier. I can also use RAII for non-memory resource cleanup.
* In C++, I get the STL. If I need to write my own algorithm, I can do so easily and generically in C++ using templates. In C, writing generic code is much more of a pain.
So while I may write C-like imperative code, I still take advantage of many of the features exclusive to C++. | null | 0 | 1316393993 | False | 0 | c2kv9u7 | t3_kjja4 | null | t1_c2kv9u7 | t1_c2kthhk | null | 1427617356 | 21 | t5_2fwo | null | null | null |
True | ssylvan | null | They're explicilty supporting the open standards in this case though, so what's the issue? | null | 0 | 1316394041 | False | 0 | c2kva1g | t3_kjja4 | null | t1_c2kva1g | t1_c2kv6oe | null | 1427617359 | 3 | t5_2fwo | null | null | null |
True | TheSuperficial | null | I didn't even look at the framework yet, but +1 for the fact that you **immediately** (in the first sentence) anticipated & answered the question "why done another [C++ test framework]"? | null | 0 | 1316394175 | False | 0 | c2kvalp | t3_kjs7u | null | t1_c2kvalp | t3_kjs7u | null | 1427617375 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Yes, as a matter of fact it is, you fuckin eek rammer nazi. | null | 0 | 1316394342 | False | 0 | c2kvbba | t3_kjhvo | null | t1_c2kvbba | t1_c2kro0a | null | 1427617376 | 1 | t5_2fwo | null | null | null |
True | artsrc | null | Documentation like this: http://download.oracle.com/javase/6/docs/api/java/lang/String.html says: "Strings are constant; their values cannot be changed after they are created." Are you saying this documentation is not useful?
A class without setters is second rate expression of immutability. Neither the development environment nor other programmers will instantly know that none of your other methods mutate instances.
By your logic you could argue that you can assertions of variable types are as expressive as static typing.
| null | 0 | 1316394700 | False | 0 | c2kvcof | t3_kjw0j | null | t1_c2kvcof | t1_c2kuyre | null | 1427617394 | 10 | t5_2fwo | null | null | null |
True | jphilippe_b | null | So in your opinion only IE9 and Safari are decent browser ? | null | 0 | 1316395252 | False | 0 | c2kvf0f | t3_kjja4 | null | t1_c2kvf0f | t1_c2kusik | null | 1427617423 | 2 | t5_2fwo | null | null | null |
True | dhpye | null | AWT originally provided *Write Once, Look Like Ass Everywhere*
To rectify the issues of AWT, Swing provided native implementations (*Write Once, Test Everywhere*)
After biting itself in its own ass twice from opposite directions, Sun let the mantle pass to Eclipse.
| null | 0 | 1316395647 | False | 0 | c2kvgpc | t3_kjf91 | null | t1_c2kvgpc | t1_c2kujv2 | null | 1427617446 | 8 | t5_2fwo | null | null | null |
True | kirakun | null | Where did I ever use that word "different?" Are you misinterpreting something here? | null | 0 | 1316395685 | False | 0 | c2kvgw0 | t3_kjhvo | null | t1_c2kvgw0 | t1_c2kuw2r | null | 1427617448 | 1 | t5_2fwo | null | null | null |
True | dhpye | null | The CORBA ORBs, IDL and EJB spec were so absurdly complex I half-suspected that they had to have been written by aliens. | null | 0 | 1316395753 | False | 0 | c2kvh6h | t3_kjf91 | null | t1_c2kvh6h | t3_kjf91 | null | 1427617452 | 3 | t5_2fwo | null | null | null |
True | kirakun | null | Have you ever worked on a UNIX file system? What are you talking about? | null | 0 | 1316395850 | False | 0 | c2kvhlf | t3_kjhvo | null | t1_c2kvhlf | t1_c2kux6j | null | 1427617457 | 1 | t5_2fwo | null | null | null |
True | superironbob | null | 1 year then was a ludicrously short time to set up production and recover costs. Even today thats a ludicrously short time period. | null | 0 | 1316396169 | False | 0 | c2kvj40 | t3_khvyw | null | t1_c2kvj40 | t1_c2kl12i | null | 1427617478 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316396220 | False | 0 | c2kvjbp | t3_khpzu | null | t1_c2kvjbp | t3_khpzu | null | 1427617481 | 1 | t5_2fwo | null | null | null |
True | MothersRapeHorn | null | Ah! Thanks; I'm a fool. I thought there what another powershell hater but I had my doubts :P | null | 0 | 1316396274 | False | 0 | c2kvjkk | t3_kjja4 | null | t1_c2kvjkk | t1_c2kut91 | null | 1427617484 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Why not use q instead? No one will ever notice. | null | 0 | 1316396356 | False | 0 | c2kvjxw | t3_kjhvo | null | t1_c2kvjxw | t1_c2kvbba | null | 1427617489 | 1 | t5_2fwo | null | null | null |
True | Slime0 | null | I'm suspicious about that for_each function call. Don't get me wrong, for-each is a useful concept, but it really seems like the sort of thing that should be a built-in language feature, not a function call. Besides the ugly syntax, what's going to happen when I'm debugging and I press F10? Am I going to step right over the loop since it's technically a single statement? If I step into it instead, am I going to have to alternate between ugly STL code and my lambda function every iteration? | null | 0 | 1316396491 | False | 0 | c2kvkjy | t3_kjja4 | null | t1_c2kvkjy | t3_kjja4 | null | 1427617497 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | >The irony is: if you think the author is right, and you use something else to read/write data from an RDBMS in an OO application, you still do more or less what an O/R mapper does too.
Thank you! Read this kids, fucking read it, over and over again until it makes sense. Hopefully by then we'll see a decline in these types of articles. | null | 0 | 1316396637 | False | 0 | c2kvl60 | t3_ki83r | null | t1_c2kvl60 | t1_c2kikjf | null | 1427617506 | 1 | t5_2fwo | null | null | null |
True | zokier | null | WinRT is a platform, yes. And what I'd want is *language specific library* to access that platform. More specifically, nice high-level, pure C++ library. | null | 0 | 1316396735 | False | 0 | c2kvlis | t3_kjja4 | null | t1_c2kvlis | t1_c2kv726 | null | 1427617509 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316396741 | False | 0 | c2kvljk | t3_ki83r | null | t1_c2kvljk | t1_c2ks3wo | null | 1427617510 | 1 | t5_2fwo | null | null | null |
True | TheSisko972 | null | Wait, what are you talking about? | null | 0 | 1316396932 | False | 0 | c2kvmb7 | t3_kjhvo | null | t1_c2kvmb7 | t1_c2kvhlf | null | 1427617521 | 1 | t5_2fwo | null | null | null |
True | TheSisko972 | null | Maybe you are? | null | 0 | 1316396953 | False | 0 | c2kvmee | t3_kjhvo | null | t1_c2kvmee | t1_c2kvgw0 | null | 1427617521 | 1 | t5_2fwo | null | null | null |
True | SadisticPenguin | null | Two things -
There is a built-in for each in C++0x, but this type of foreach can adapt to whatever you want to declare. Also, if you're using this type of foreach, you can easily drop in PPL or TBB's parallel_for_each that runs the same for each spread across threads with zero effort. It's a little weird, but I think this type of for_each will still stay in main use despite the built-in one, purely for modularity.
Yes, you'll step into STL code, but you also can simply drop a debug breakpoint into your lambda function. | null | 0 | 1316397196 | False | 0 | c2kvni6 | t3_kjja4 | null | t1_c2kvni6 | t1_c2kvkjy | null | 1427617536 | 3 | t5_2fwo | null | null | null |
True | munificent | null | > solve every problem you might solve with generics in other language.
What about the "I don't want my collection items boxed" problem? | null | 0 | 1316397218 | False | 0 | c2kvnlq | t3_kikut | null | t1_c2kvnlq | t1_c2kr7mw | null | 1427617536 | 4 | t5_2fwo | null | null | null |
True | el_isma | null | This time, they did some advances and then the standard catched up to them. So you could say that they were doing EEE until the standard catched up... | null | 0 | 1316397347 | False | 0 | c2kvo6g | t3_kjja4 | null | t1_c2kvo6g | t1_c2kv6oe | null | 1428193729 | 1 | t5_2fwo | null | null | null |
True | ssylvan | null | Yes, and if that isn't technically possible (given the features supported by C++ and the goals of the library itself, which includes being accessible by multiple languages) a decent backup solution is to extend the language so that it's at least nice and high level, while not being pure C++. The other option, of course, would be to make it not nice and low level (see Win32, or other COM libraries).
C#, say, does have a nice, idiomatic, pure C# interface to WinRT. They didn't extend that language (because they didn't have to), and they didn't extend C++ for no good reason either. | null | 0 | 1316397423 | False | 0 | c2kvoik | t3_kjja4 | null | t1_c2kvoik | t1_c2kvlis | null | 1427617548 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316397553 | False | 0 | c2kvp2d | t3_kjkxj | null | t1_c2kvp2d | t1_c2ktwwr | null | 1427617555 | 1 | t5_2fwo | null | null | null |
True | ssylvan | null | It's COM. | null | 0 | 1316397621 | False | 0 | c2kvpcl | t3_kjja4 | null | t1_c2kvpcl | t1_c2kv4ij | null | 1427617561 | 2 | t5_2fwo | null | null | null |
True | munificent | null | The problem with using components and explicit composition instead of true multiple inheritance is that you lose singular identity. When you forward to a component, `this` becomes the component and not the original aggregate object.
struct Actor {
AI ai;
Renderable renderable;
}
struct AI {
Move pickMove(Actor* actor) {
if (actor->x < 0) return ...
...
}
}
struct Renderable {
void render(Actor* actor) {
drawCircle(actor->x, actor->y);
}
}
See how the methods in `AI` and `Renderable` take an `Actor`? That's need to get back to the object that owns that component. Otherwise, the component has no way of getting that. Its identity is not the same as the actor's. With multiple inheritance:
struct Actor : public AI, Renderable {}
struct AI {
Move pickMove() {
if (x < 0) return ...
...
}
}
struct Renderable {
void render() {
drawCircle(x, y);
}
}
That indirection disappears. This can be important if your component wants to do non-trivial stuff with the main object, like put it in a collection. Unless you're careful, you'll inadvertantly slice off the component and put in the collection while losing the rest of the object.
I haven't read the Go solution closely, but I think it punts on that issue by using int indices for heap items and graph nodes. Without that level of indirection, their solution would have problems.
For games, I think this is generally a good trade-off because components have a *huge* advantage over multiple inheritance: they can be composed dynamically at runtime.
| null | 0 | 1316397662 | False | 0 | c2kvpil | t3_kikut | null | t1_c2kvpil | t1_c2klao4 | null | 1427617563 | 7 | t5_2fwo | null | null | null |
True | Slime0 | null | Glad to hear it's built in for C++0x. But unless I have a need for something special like the parallel_for_each you mention (which sounds useful for some situations), I would never use this if I had to debug it that way. Just not worth the trouble.
You only write a line of code once, but you'll debug it over and over. | null | 0 | 1316397709 | False | 0 | c2kvppm | t3_kjja4 | null | t1_c2kvppm | t1_c2kvni6 | null | 1427617567 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316398023 | False | 0 | c2kvr3f | t3_ketdw | null | t1_c2kvr3f | t3_ketdw | null | 1427617581 | 1 | t5_2fwo | null | null | null |
True | ChiperSoft | null | None of which was created by the patent. They would have done that for a new product regardless.
Patents do not create products, they protect those who did. | null | 0 | 1316398802 | False | 0 | c2kvucv | t3_khvyw | null | t1_c2kvucv | t1_c2kt4x2 | null | 1427617631 | 0 | t5_2fwo | null | null | null |
True | LifeBandit666 | null | Downvoted both of you for being American | null | 0 | 1316398896 | False | 0 | c2kvuro | t3_kjj9n | null | t1_c2kvuro | t1_c2ku7ef | null | 1427617636 | 6 | t5_2fwo | null | null | null |
True | LifeBandit666 | null | I'm so getting downvoted for that. Americans love "revenge" | null | 0 | 1316398995 | False | 0 | c2kvv7x | t3_kjj9n | null | t1_c2kvv7x | t1_c2kvuro | null | 1427617643 | -3 | t5_2fwo | null | null | null |
True | Whanhee | null | Japanese programmers probably have pretty intense debates... | null | 0 | 1316399230 | False | 0 | c2kvw87 | t3_kjw0j | null | t1_c2kvw87 | t1_c2kv68b | null | 1427617649 | 15 | t5_2fwo | null | null | null |
True | grauenwolf | null | I have no idea what your point is? | null | 0 | 1316399425 | False | 0 | c2kvx1x | t3_kjw0j | null | t1_c2kvx1x | t1_c2kvcof | null | 1427617660 | 1 | t5_2fwo | null | null | null |
True | danharaj | null | > /r/programming is not a place to ask for help, run polls, rant, demo your app (unless your demo includes code or architecture discussion), or otherwise use as a captive audience.
Mostly the captive audience part. | null | 0 | 1316399506 | False | 0 | c2kvxf9 | t3_kjkxj | null | t1_c2kvxf9 | t1_c2kvp2d | null | 1427617674 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316399745 | False | 0 | c2kvyfc | t3_kc4pc | null | t1_c2kvyfc | t3_kc4pc | null | 1427617682 | 1 | t5_2fwo | null | null | null |
True | toofishes | null | > Statically typed languages allow you to express types to the development environment. They also typically good at allowing you to express types to other developers, because the expression is standard.
Came here to say this, but glad you said it first. I've done plenty of Java in the past, and a lot of Python more recently, and I find myself having to look into library code to figure out what I should be passing in since the contract presented by an exposed method in Python is not always as helpful as one presented by Java with static typing.
And yes, this is something that can be fixed through documentation, but doesn't that really invalidate his whole "expressiveness" argument? I find it to be a total BS "fact". | null | 0 | 1316399804 | False | 0 | c2kvynm | t3_kjw0j | null | t1_c2kvynm | t1_c2kuspz | null | 1427617685 | 8 | t5_2fwo | null | null | null |
True | Whanhee | null | One use that I found for multiple inheritance is to give various objects properties. For example, in a physics simulation I wrote a while ago, I would have objects that were visible, physical, clickable and a few other things. Instead of bothering with whether physical things should inherit from visual things or vice versa, multiple inheritance solved it rather nicely.
Looking through the parent, I guess, I just reimplemented components... | null | 0 | 1316399991 | False | 0 | c2kvzg0 | t3_kikut | null | t1_c2kvzg0 | t1_c2kpfqc | null | 1427617698 | 2 | t5_2fwo | null | null | null |
True | yogthos | null | > before the math starts to get hard
That's exactly why mathematics is built around the concept of mutability... oh wait | null | 0 | 1316400010 | False | 0 | c2kvziy | t3_kjkxj | null | t1_c2kvziy | t1_c2kunz0 | null | 1427617698 | 3 | t5_2fwo | null | null | null |
True | mcguire | null | > Abstractions exist in software to help us better conceptualize problems, and to make it easier on those who come after us to understand the problem as we conceptualized it. Even imperfect ones....take some positive step in that direction.
Well, yeah, sure, right up to the point were a significant chunk of your code exists to work around your imperfect abstractions. | null | 0 | 1316400043 | False | 0 | c2kvzo2 | t3_ki83r | null | t1_c2kvzo2 | t1_c2kp289 | null | 1427617698 | 3 | t5_2fwo | null | null | null |
True | stoph | null | String is a class without setters, thus it's immutable. | null | 0 | 1316400198 | False | 0 | c2kw0dm | t3_kjw0j | null | t1_c2kw0dm | t1_c2kvcof | null | 1427617703 | -5 | t5_2fwo | null | null | null |
True | Smallpaul | null | Java was marketed as a platform from day 1. The language was the interface for the platform. WORA, remember? | null | 0 | 1316400264 | False | 0 | c2kw0nz | t3_kjf91 | null | t1_c2kw0nz | t1_c2kt4q6 | null | 1427617706 | 5 | t5_2fwo | null | null | null |
True | zakame | null | Somebody forgot about `git whatchanged` | null | 0 | 1316400726 | False | 0 | c2kw2l3 | t3_jugup | null | t1_c2kw2l3 | t3_jugup | null | 1427617731 | 1 | t5_2fwo | null | null | null |
True | cybercobra | null | > [Haskell] requires vastly less code to express various concepts [than Perl]
o_O
We are talking about the same Perl, right? Perl is *nothing* if not terse. | null | 0 | 1316400765 | False | 0 | c2kw2qx | t3_kjw0j | null | t1_c2kw2qx | t1_c2kv724 | null | 1427617733 | 7 | t5_2fwo | null | null | null |
True | GeorgeForemanGrillz | null | How was this different from Elenco's 300-in-1 electronics project kit? That's what I had when I was a kid back in the 80's and it's probably cheaper than this rip-off. This isn't anything new. | null | 0 | 1316400906 | False | 0 | c2kw3d5 | t3_kj1na | null | t1_c2kw3d5 | t3_kj1na | null | 1427617741 | 0 | t5_2fwo | null | null | null |
True | mcguire | null | > In most cases, you'd be better off simply learning the thing one level underneath the abstraction and throwing the framework out the door!
In the words of a wise friend, "They try to make something easy that wasn't hard in the first place, and they slather on a thick layer of complexity doing it." | null | 0 | 1316401022 | False | 0 | c2kw3uo | t3_ki83r | null | t1_c2kw3uo | t1_c2kirco | null | 1427617749 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | > make *fewer* assertions ... others**'**
FTFY :) | null | 0 | 1316401397 | False | 0 | c2kw5ey | t3_kjw0j | null | t1_c2kw5ey | t1_c2kv62q | null | 1427617768 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316401613 | False | 0 | c2kw6ci | t3_kjj9n | null | t1_c2kw6ci | t1_c2kvv7x | null | 1427617781 | 0 | t5_2fwo | null | null | null |
True | TheFrigginArchitect | null | I don't think he was talking about how there are abbreviations (Perl has many) o think he was talking about flexibility. Perl gets used for a lot of different things. | null | 0 | 1316401652 | False | 0 | c2kw6hu | t3_kjw0j | null | t1_c2kw6hu | t1_c2kw2qx | null | 1427617782 | 3 | t5_2fwo | null | null | null |
True | punkmonk | null | I am getting sick of MacOS, and Win8 seems like a promising replacement for the sluggishness that is MacOS
Seems like the tables are turning yet again. | null | 0 | 1316401827 | False | 0 | c2kw78s | t3_kip3s | null | t1_c2kw78s | t3_kip3s | null | 1427617793 | 0 | t5_2fwo | null | null | null |
True | kirakun | null | Show me where I used "different." | null | 0 | 1316401901 | False | 0 | c2kw7ld | t3_kjhvo | null | t1_c2kw7ld | t1_c2kvmee | null | 1427617797 | 1 | t5_2fwo | null | null | null |
True | kirakun | null | Sigh... Please learn how to read before responding to other people's comment. | null | 0 | 1316401959 | False | 0 | c2kw7u7 | t3_kjhvo | null | t1_c2kw7u7 | t1_c2kvmb7 | null | 1427617800 | 1 | t5_2fwo | null | null | null |
True | comex | null | For something like pattern matching (of structures, not text, and more complicated than just unpacking an array)? You might be able to do it with some fancy extension, but Haskell makes this extremely easy. | null | 0 | 1316402038 | False | 0 | c2kw881 | t3_kjw0j | null | t1_c2kw881 | t1_c2kw2qx | null | 1427617806 | 8 | t5_2fwo | null | null | null |
True | khazathon | null | Isn't it sufficient to release a white paper? | null | 0 | 1316402312 | False | 0 | c2kw9g9 | t3_khvyw | null | t1_c2kw9g9 | t1_c2kquia | null | 1427617821 | 2 | t5_2fwo | null | null | null |
True | Rockytriton | null | My quarter is better than your paradigms | null | 0 | 1316402549 | False | 0 | c2kwal2 | t3_kjw0j | null | t1_c2kwal2 | t3_kjw0j | null | 1427617837 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | WODE | null | 0 | 1316402567 | False | 0 | c2kwanx | t3_kjf91 | null | t1_c2kwanx | t1_c2kw0nz | null | 1427617838 | 4 | t5_2fwo | null | null | null |
True | JL235 | null | This is why I often insert the word 'typically' into my arguments, when taking part in these debates.
That was before I learned these debates are 'typically' pointless. | null | 0 | 1316403456 | False | 0 | c2kwenk | t3_kjw0j | null | t1_c2kwenk | t3_kjw0j | null | 1427617890 | 2 | t5_2fwo | null | null | null |
True | rmxz | null | TL/D[Watch]?
What's so interesting about the whole video; and what about silverlight and XAML at 59:00? | null | 0 | 1316403511 | False | 0 | c2kwew7 | t3_kip3s | null | t1_c2kwew7 | t3_kip3s | null | 1427617893 | 3 | t5_2fwo | null | null | null |
True | grauenwolf | null | That is a rather bold claim considering that VS 2011 has only been available for a couple of days.
Where specifically is VS 2011 out of compliance with C++ 11? | null | 0 | 1316403786 | False | 0 | c2kwg1v | t3_kjja4 | null | t1_c2kwg1v | t1_c2kv3id | null | 1427617909 | 5 | t5_2fwo | null | null | null |
True | grauenwolf | null | C# has a *nearly* idiomatic way of accessing WinRT objects. There is still the mis-match between reference counting and mark-and-sweep garbage collection. | null | 0 | 1316403868 | False | 0 | c2kwget | t3_kjja4 | null | t1_c2kwget | t1_c2kvoik | null | 1427617914 | 1 | t5_2fwo | null | null | null |
True | washort | null | So will ES6 be a "skin on Lisp" since it has quasiliterals?
| null | 0 | 1316403964 | False | 0 | c2kwgtx | t3_kk24v | null | t1_c2kwgtx | t3_kk24v | null | 1427617919 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | That remains to be seen. If WinRT is properly documented then it shouldn't be too hard for the other compilers to catch up. | null | 0 | 1316403970 | False | 0 | c2kwguu | t3_kjja4 | null | t1_c2kwguu | t1_c2kv4q0 | null | 1427617919 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316404037 | False | 0 | c2kwh46 | t3_jr6r6 | null | t1_c2kwh46 | t3_jr6r6 | null | 1427617933 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Thanks! | null | 0 | 1316404361 | False | 0 | c2kwicv | t3_kjj9n | null | t1_c2kwicv | t1_c2kv2tm | null | 1427617938 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | Extending standards is not automatically a dishonorable act. It is quite often necessary to make an otherwise unusable standard workable. If it were not for the likes of Microsoft and Netscape there would be no such thing as HTML programming, it would have remained merely a content format. | null | 0 | 1316404388 | False | 0 | c2kwigd | t3_kjja4 | null | t1_c2kwigd | t1_c2kv6oe | null | 1427617939 | 3 | t5_2fwo | null | null | null |
True | artsrc | null | In short, you *can not* express that a class is immutable by having no setters.
String is a class that is carefully designed to be immutable and the absence of setters is just one thing to note. The style of behavior of other functions is caused by this property also.
A setter is not the only thing that can modify a member.
Setters are not oo:
http://www.adam-bien.com/roller/abien/entry/encapsulation_violation_with_getters_and
"Replace" does not generally mean "make a copy which is slightly different". Replace in string does this:
http://download.oracle.com/javase/6/docs/api/java
/lang/String.html#replace%28char,%20char%29
Why is replace like this?
| null | 0 | 1316404670 | False | 0 | c2kwjq6 | t3_kjw0j | null | t1_c2kwjq6 | t1_c2kw0dm | null | 1427617957 | 8 | t5_2fwo | null | null | null |
True | JL235 | null | [Azul Systems](http://en.wikipedia.org/wiki/Azul_Systems) build servers for running high-end Java servers, which scale to 100s of cores, using their own Vega CPUs. They use a custom JVM (based on HotSpot) with hardware support to dramatically speed up memory management and reduce locking.
[Sun SPOTs](http://en.wikipedia.org/wiki/Sun_SPOT) were tiny embedded devices which ran Java directly. They used an ARM CPU with a small J2ME runtime.
Both look like pure Java devices to the developers, but in practice are a mixture of hardware and software.
I managed to borrow some Sun SPOTs once for some work, to play around with and see if I could build something interesting with them. They were kinda cool, but were far too expensive, felt very lacking in features, were quite large (for a tiny embedded device) and mostly felt like a solution looking for a problem. | null | 0 | 1316404675 | False | 0 | c2kwjr8 | t3_kjf91 | null | t1_c2kwjr8 | t1_c2ktf9m | null | 1427617957 | 4 | t5_2fwo | null | null | null |
True | JL235 | null | and now with JavaFX it's a case of *Write Once, sign certificates everywhere* | null | 0 | 1316404817 | False | 0 | c2kwkfp | t3_kjf91 | null | t1_c2kwkfp | t1_c2kvgpc | null | 1427617966 | 2 | t5_2fwo | null | null | null |
True | zzing | null | *sticks head up*
>
*goes back to fortran.* | null | 0 | 1316404866 | False | 0 | c2kwknt | t3_kjw0j | null | t1_c2kwknt | t3_kjw0j | null | 1427617977 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | The list of features that VS11 is slated to implement has been made available by Stephan Lavavej, one of the lead developers on the C++ team and the only developer at Microsoft working on the standard library (MS outsources the rest of it to Dikumware).
The features that VS11 is expected to implement by the time it's released is significantly less than what is currently and for the most part properly implemented by gcc. The issue is that a lot of library features are dependent on core language features, such as variadic templates, proper implementation of emplace methods with standard containers, the entirety of the C++ memory model and the std::thread standard library. Without the core language features in place you get quite a bit of 'gotchas'/surprises when using the standard library.
Microsoft gets a thumbs up in that their compiler produces hands down noticeably better code than all other C++ compilers I've used, gcc, clang, Sun Studio and Intel, but as far as conforming to the standard their compiler is simply way behind the rest. | null | 0 | 1316404891 | False | 0 | c2kwkrl | t3_kjja4 | null | t1_c2kwkrl | t1_c2kwg1v | null | 1427617980 | 1 | t5_2fwo | null | null | null |
True | artsrc | null | Leaving out setters is an inadequate way to document that a class is immutable. According to me and to the person who documented String. That is why the documentation has to say it.
The String replace, upper case methods etc. return copies rather than modifying in place. This makes sense because String is immutable.
| null | 0 | 1316405323 | True | 0 | c2kwmpk | t3_kjw0j | null | t1_c2kwmpk | t1_c2kvx1x | null | 1427617996 | 11 | t5_2fwo | null | null | null |
True | Tekmo | null | Expressive means different things to different people. When I think of the word "expressive", I think of a language where it's easy to reason about what the code does without referring to documentation or comments (i.e. the code "expresses" its purpose well). I'm quite aware that there already is the phrase "self-documenting code" for that, so I prefer to use that term instead since it's less ambiguous. | null | 0 | 1316405324 | False | 0 | c2kwmpn | t3_kjw0j | null | t1_c2kwmpn | t1_c2kw2qx | null | 1427617996 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316405389 | True | 0 | c2kwmzr | t3_kjja4 | null | t1_c2kwmzr | t1_c2kvkjy | null | 1427618001 | 2 | t5_2fwo | null | null | null |
True | grauenwolf | null | Fair enough. | null | 0 | 1316405397 | False | 0 | c2kwn18 | t3_kjja4 | null | t1_c2kwn18 | t1_c2kwkrl | null | 1427618001 | 2 | t5_2fwo | null | null | null |
True | grauenwolf | null | Ok, I agree with that. I would like .NET to have an attribute that indicates a class is immutable with matching compiler support to enforce it. | null | 0 | 1316405499 | False | 0 | c2kwnhg | t3_kjw0j | null | t1_c2kwnhg | t1_c2kwmpk | null | 1427618006 | 5 | t5_2fwo | null | null | null |
True | assclown3 | null | It sounds like what you are after is the Stockham formulation of the FFT, but it really doesn't help that much. You can't really escape the cost of the transpose. Either your reads are coherent, the writes are coherent, or neither. | null | 0 | 1316405530 | False | 0 | c2kwnmi | t3_khryi | null | t1_c2kwnmi | t1_c2kiz3p | null | 1427618007 | 1 | t5_2fwo | null | null | null |
True | altpotato | null | Well that's just your opinion, man. | null | 0 | 1316405530 | False | 0 | c2kwnmj | t3_kjja4 | null | t1_c2kwnmj | t1_c2kv4er | null | 1427618007 | 5 | t5_2fwo | null | null | null |
True | filipf | null | Pre-emptive STFU: Yeah, I know it's not programming but it shows how much more usable software can be | null | 0 | 1316405532 | True | 0 | c2kwnmz | t3_kk5dk | null | t1_c2kwnmz | t3_kk5dk | null | 1427618007 | 1 | t5_2fwo | null | null | null |
True | Paradigm_Shift | null | My Paradigm is bigger than yours! | null | 0 | 1316405692 | False | 0 | c2kwocb | t3_kjw0j | null | t1_c2kwocb | t3_kjw0j | null | 1427618016 | 3 | t5_2fwo | null | null | null |
True | chromaticburst | null | ಠ_ಠ
class ImMutable { public int getSomeValue(){ return randomInt(); } }
class ImMutable2 { public MutableFoo getSomeValue(){ return mutableFooMember; } }
class ImMutable3 { ImMutable(Object mutableObj){ derpMember = mutableObj; } getResultOfCalcWithDerpMember(){...} }
class ImMutable4a { public Foo getSomeValue() ... }
class ImMutable4b extends 4a { public Foo getSomeValue(){ ... override nonfinal method with something breaking immutability. haha im going to put it into generic lists holding 4as to fuck up your day ... }}
class ImMutable5 { public Foo getFoo(){ program state altering side effect ; return foo; } }
| null | 0 | 1316405741 | True | 0 | c2kwokc | t3_kjw0j | null | t1_c2kwokc | t1_c2kw0dm | null | 1427618020 | 15 | t5_2fwo | null | null | null |
True | mistoroboto | null | No, that's the characteristics of the word. | null | 0 | 1316405908 | False | 0 | c2kwpak | t3_kjja4 | null | t1_c2kwpak | t1_c2kwnmj | null | 1427618030 | -1 | t5_2fwo | null | null | null |
True | rhinon | null | i was there! the room was PACKED | null | 0 | 1316405921 | False | 0 | c2kwpcp | t3_kjja4 | null | t1_c2kwpcp | t3_kjja4 | null | 1427618030 | 1 | 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.