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
|
hackinthebochs
| null |
Dude, I'm sympathetic to what you're attempting here. But you're not making any sense at all. *You're not communicating any argument whatsoever*. Use plain english otherwise we can't have a meaningful discussion.
| null |
0
|
1317325146
|
False
|
0
|
c2nkwjb
|
t3_kucjn
| null |
t1_c2nkwjb
|
t1_c2nktx1
| null |
1427664313
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317325347
|
False
|
0
|
c2nkxpd
|
t3_kvj6y
| null |
t1_c2nkxpd
|
t1_c2nkk7b
| null |
1427664329
|
1
|
t5_2fwo
| null | null | null |
True
|
BeatLeJuce
| null |
works fine on my firefox
| null |
0
|
1317325373
|
False
|
0
|
c2nkxuy
|
t3_kucjn
| null |
t1_c2nkxuy
|
t3_kucjn
| null |
1427664331
|
1
|
t5_2fwo
| null | null | null |
True
|
Otterfan
| null |
Dreamweaver's default monospace font on Mac is 7pt Monaco. That's appalling.
| null |
0
|
1317325443
|
False
|
0
|
c2nky8m
|
t3_kuti3
| null |
t1_c2nky8m
|
t1_c2ngssf
| null |
1427664335
|
1
|
t5_2fwo
| null | null | null |
True
|
pgngugmgg
| null |
Thanks for your reply, but you and I are talking about different things.
| null |
0
|
1317325713
|
False
|
0
|
c2nkzp9
|
t3_kucjn
| null |
t1_c2nkzp9
|
t1_c2ngzho
| null |
1427664356
|
1
|
t5_2fwo
| null | null | null |
True
|
Robbazorrathon
| null |
2 choices max: Red wire / Blue wire
| null |
0
|
1317325783
|
False
|
0
|
c2nl043
|
t3_kv8db
| null |
t1_c2nl043
|
t1_c2nhipf
| null |
1427664361
|
2
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
the . operator bothers me somewhat.
i pretty much always use >>> over .
then it's:
rows >>> map cols >>> all and $ im
| null |
0
|
1317325946
|
False
|
0
|
c2nl129
|
t3_kv3ww
| null |
t1_c2nl129
|
t1_c2nh4j6
| null |
1427664372
|
2
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317325984
|
False
|
0
|
c2nl19p
|
t3_kvg67
| null |
t1_c2nl19p
|
t3_kvg67
| null |
1427664376
|
1
|
t5_2fwo
| null | null | null |
True
|
kataire
| null |
I love absurdist humour as much as the next guy, but I don't understand why _why's guide is considered so good.
The humour is mostly random and irrelevant, the educational quality is lacking. Seriously, wtf? The guide may be okay for absolute beginners, but having some programming experience with various other languages, I find the pace painfully slow and the witticisms painfully bad.
That Rubyists seem to wet their pants whenever `_`why is mentioned doesn't help either. The Ruby community seems to have an awkward obsession with cults of personality, `_`why and the 37signals guys being the more obvious cases.
I *really* want to learn Ruby because I think it's widespread and relevant enough to be worth knowing, but it seems to be hard to find a tutorial that isn't obsessing about the language being the awesomest thing since sliced bread or otherwise wastes my time with useless hyperbole and fanboyisms.
Ruby makes me feel like a grumpy old bastard chasing kids off my lawn in the same way that Java/Oracle makes me feel like a hipster kid on a sugar rush (and Haskell makes me feel like an uneducated troglodyte).
| null |
0
|
1317326018
|
False
|
0
|
c2nl1gn
|
t3_ku2z1
| null |
t1_c2nl1gn
|
t1_c2n8n73
| null |
1427664378
|
1
|
t5_2fwo
| null | null | null |
True
|
hyperforce
| null |
But if good people have bad habits and don't communicate, are they really that good?
| null |
0
|
1317326059
|
False
|
0
|
c2nl1pd
|
t3_ktxk5
| null |
t1_c2nl1pd
|
t1_c2n80v1
| null |
1427664381
|
2
|
t5_2fwo
| null | null | null |
True
|
banuday
| null |
> Rest is just a way of structuring an API that any application could use.
REST is a very specific way of structuring an API. In fact, it is a way of structuring an API in a very minimal and uniform manner, with only the HTTP verbs GET/POST/PUT/DELETE applying to all application resources, which are referred to by a URI. Applications GET preferred representations of current resource state, and discover other resources and alter the state of resources via hyperlinks embedded in the representation.
> there is no conflict.
Ah, but there is! The representation of the resource is (supposed to be) device independent. That is why the web is so awesome as an integration platform, because device independence allows pages to be "browsed" by humans, page-readers for the blind, search engines, etc. This is the integration architecture captured by REST.
Thoughtless application of AJAX completely breaks this model, for example with the stupid #! hack, which goes out of its way to hijack the URI. Hyperlinks are replaced by AJAX calls, which impedes discoverability of URIs, a fundamental feature of REST. The AJAX request and response is typically specific to the type of partial page refresh requested instead of being a feature of the resource itself, imposing AJAX client-side requirements possibly inappropriately onto REST server-side requirements, or vice versa.
Ideally, AJAX should be built *on top of* a "static" representation, using a technique commonly known as *progressive enhancement*. It takes a bit of work to get this right, but the results may be worth it.
> I think you may be trying to think that you should bind objects directly with a REST interface
Umm no... Where on Earth did you get that idea?
EDIT: Cleanup!
| null |
0
|
1317326152
|
True
|
0
|
c2nl27l
|
t3_kv57g
| null |
t1_c2nl27l
|
t1_c2nkdq3
| null |
1427664388
|
2
|
t5_2fwo
| null | null | null |
True
|
buffbuddha
| null |
I knew dressing up as Wonder Woman would come back to haunt me some day.
| null |
0
|
1317326349
|
False
|
0
|
c2nl3ch
|
t3_kulqo
| null |
t1_c2nl3ch
|
t3_kulqo
| null |
1427664403
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
What is the thing that you're talking about? You are quite elusive on this subject!
| null |
0
|
1317326353
|
False
|
0
|
c2nl3da
|
t3_kucjn
| null |
t1_c2nl3da
|
t1_c2nkzp9
| null |
1427664403
|
2
|
t5_2fwo
| null | null | null |
True
|
11t1
| null |
The Wikipedia page you linked seems to say that the name rhymes with "rough".
| null |
0
|
1317326370
|
False
|
0
|
c2nl3gj
|
t3_kv3ww
| null |
t1_c2nl3gj
|
t1_c2nhg60
| null |
1427664404
|
3
|
t5_2fwo
| null | null | null |
True
|
kataire
| null |
But usability is bad for geek cred :(
/s
| null |
0
|
1317326379
|
False
|
0
|
c2nl3ib
|
t3_ku81g
| null |
t1_c2nl3ib
|
t1_c2nhkod
| null |
1427664406
|
2
|
t5_2fwo
| null | null | null |
True
|
kataire
| null |
You mean the shiny?
| null |
0
|
1317326501
|
False
|
0
|
c2nl46v
|
t3_ku8az
| null |
t1_c2nl46v
|
t1_c2ndu6r
| null |
1427664415
|
1
|
t5_2fwo
| null | null | null |
True
|
jsprogrammer
| null |
So, you're saying that when I don't know Haskell, Haskells programs will not make sense to me?
| null |
0
|
1317326757
|
False
|
0
|
c2nl5l3
|
t3_kv3ww
| null |
t1_c2nl5l3
|
t1_c2njpwt
| null |
1427664432
|
0
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317326788
|
False
|
0
|
c2nl5qx
|
t3_kuz4l
| null |
t1_c2nl5qx
|
t3_kuz4l
| null |
1427664434
|
1
|
t5_2fwo
| null | null | null |
True
|
bluGill
| null |
Not necessarily. It may well not check for null, but update some other data structure that you have access to. Maybe it frees the first memory your malloced. Your program would continue to run for a time, but eventually you will use that memory and then segfault - with no clue why your legal memory isn't available. That is somewhat likely.
| null |
0
|
1317326800
|
False
|
0
|
c2nl5td
|
t3_kvfej
| null |
t1_c2nl5td
|
t1_c2nk71d
| null |
1427664435
|
5
|
t5_2fwo
| null | null | null |
True
|
roymustang86
| null |
software engineering and civil engineering to an extent
| null |
0
|
1317326894
|
False
|
0
|
c2nl6ds
|
t3_kuye2
| null |
t1_c2nl6ds
|
t1_c2nhroj
| null |
1427664442
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
How do you know that?
| null |
0
|
1317326930
|
False
|
0
|
c2nl6l8
|
t3_kv4hr
| null |
t1_c2nl6l8
|
t1_c2nj2xs
| null |
1427664445
|
0
|
t5_2fwo
| null | null | null |
True
|
xampl9
| null |
Because if he's shipping the documentation outside his organization, the readers probably won't have the font. And he may not have redistribution rights. And the people reading the docs don't have local admin rights to go download & install the font themselves.
Corporate IT is fun.
/s
| null |
0
|
1317326955
|
False
|
0
|
c2nl6qw
|
t3_kuti3
| null |
t1_c2nl6qw
|
t1_c2nkfte
| null |
1427664447
|
2
|
t5_2fwo
| null | null | null |
True
|
mobiduxi
| null |
to complicated. just publish the image and wait for Apple to sue you for using rectangles.
| null |
0
|
1317326979
|
False
|
0
|
c2nl6vi
|
t3_kv3ww
| null |
t1_c2nl6vi
|
t3_kv3ww
| null |
1427664449
|
-2
|
t5_2fwo
| null | null | null |
True
|
sublime8510
| null |
You seriously think there arent people here in the US that can do that?
| null |
0
|
1317327028
|
False
|
0
|
c2nl75k
|
t3_kuye2
| null |
t1_c2nl75k
|
t1_c2nl6ds
| null |
1427664453
|
1
|
t5_2fwo
| null | null | null |
True
|
trinitygadget
| null |
Nope. Hard to tell tone in writing though.
| null |
0
|
1317327081
|
False
|
0
|
c2nl7gq
|
t3_ku81g
| null |
t1_c2nl7gq
|
t1_c2nhkfn
| null |
1427664456
|
2
|
t5_2fwo
| null | null | null |
True
|
poo_22
| null |
what about a rotated rectangle?
| null |
0
|
1317327108
|
False
|
0
|
c2nl7m0
|
t3_kv3ww
| null |
t1_c2nl7m0
|
t3_kv3ww
| null |
1427664459
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
I thought nobody was using win32 anymore. Wasn't everybody supposed to switch to .NET years ago?
| null |
0
|
1317327248
|
False
|
0
|
c2nl8dj
|
t3_kvfej
| null |
t1_c2nl8dj
|
t3_kvfej
| null |
1427664469
|
-5
|
t5_2fwo
| null | null | null |
True
|
masklinn
| null |
> with only the HTTP verbs GET/POST/PUT/DELETE applying to all application resources
This is not a requirement of REST at all. Not even of REST over HTTP.
| null |
0
|
1317327448
|
False
|
0
|
c2nl9gb
|
t3_kv57g
| null |
t1_c2nl9gb
|
t1_c2nl27l
| null |
1427664483
|
3
|
t5_2fwo
| null | null | null |
True
|
iredwards
| null |
The fine print says (paraphrasing from distant memory) you can install and use it on your machine but you can't use it for sample code in a pdf and/or printed docs published for a commercial Java app without permission. So I just point the FO processor at Inconsolata and everything just works. In fact it works so well I forgot about it until this thread came up today. I vaguely remember there was some not-entirely-trivial reason why I had folks stay with Consolas and not switch everything to Inconsolata for daily work.
| null |
0
|
1317327458
|
False
|
0
|
c2nl9iq
|
t3_kuti3
| null |
t1_c2nl9iq
|
t1_c2nkfte
| null |
1427664484
|
0
|
t5_2fwo
| null | null | null |
True
|
zingbot3000
| null |
> So just using an MS tool or language makes you an "MS guy"? Really?
Yes, really. It ties you to their platform. It's not a free language. The best thing that can really be said for F# is that it shows the potential that OCaml has.
| null |
0
|
1317327516
|
False
|
0
|
c2nl9t7
|
t3_kuhn3
| null |
t1_c2nl9t7
|
t1_c2nhyif
| null |
1427664487
|
6
|
t5_2fwo
| null | null | null |
True
|
locster
| null |
Hi. Folks may be interested in [SharpNEAT](http://sharpneat.sourceforge.net/), it's a framework for evolving neural networks and happens to have a couple of problem domains in the release builds that use Box2D, e.g.
* [Single Pole Balancing in 2D (Human vs. Automatic Control)](http://www.youtube.com/watch?v=b4rfIcn2A_w)
* [Double Inverted Pendulum](http://www.youtube.com/watch?v=thnHbKfAUAE)
They're pretty basic examples but I'm hoping to do more, e.g. maybe a 2D walker. I might try evolving worms also :)
| null |
0
|
1317327570
|
False
|
0
|
c2nla2u
|
t3_kucjn
| null |
t1_c2nla2u
|
t1_c2na7wq
| null |
1427664491
|
3
|
t5_2fwo
| null | null | null |
True
|
pnpbios
| null |
Show them pity. Anywhere still developing in VB probably isn't a nice place to work.
| null |
0
|
1317327733
|
False
|
0
|
c2nlayt
|
t3_kvg67
| null |
t1_c2nlayt
|
t1_c2nkufw
| null |
1427664502
|
3
|
t5_2fwo
| null | null | null |
True
|
locster
| null |
Yeh, I figure minimise joint torque * time, maximise distance travelled.
| null |
0
|
1317327734
|
False
|
0
|
c2nlaz7
|
t3_kucjn
| null |
t1_c2nlaz7
|
t1_c2nhbl2
| null |
1427664503
|
1
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
I may be mistaken, but last time I read about it they were nothing but low-level crap like firmware code for turning off the antenna.
| null |
0
|
1317327866
|
False
|
0
|
c2nlbtl
|
t3_kv4hr
| null |
t1_c2nlbtl
|
t1_c2nl6l8
| null |
1427664514
|
1
|
t5_2fwo
| null | null | null |
True
|
White_Sox
| null |
Ant today I got my book.The printing quality is top notch. Thank you.
| null |
0
|
1317327919
|
False
|
0
|
c2nlc4q
|
t3_jjcwd
| null |
t1_c2nlc4q
|
t3_jjcwd
| null |
1427664518
|
1
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
Making it a class is a useful language construct in C# that will let you abstract away a number of details to let you get the job done... but you won't hear us saying "MapReduce is an object".
| null |
0
|
1317327930
|
False
|
0
|
c2nlc6g
|
t3_kv4xx
| null |
t1_c2nlc6g
|
t1_c2nkg5y
| null |
1427664518
|
-1
|
t5_2fwo
| null | null | null |
True
|
iredwards
| null |
Right. Its more about the redistribution rights, though. In a pdf I would embed the font and not care if the user had it. For web pages, I specify Consolas and wish them all the best. A lot of table entries and samples that are fine with Consolas are less fine with Courier.
| null |
0
|
1317327949
|
False
|
0
|
c2nlcak
|
t3_kuti3
| null |
t1_c2nlcak
|
t1_c2nl6qw
| null |
1427664520
|
3
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
And the CLR was supposed to be cross platform standard too. But Microsoft doesn't think about stuff more than a year or two in advance and plans are easily forgotten.
| null |
0
|
1317328024
|
True
|
0
|
c2nlcpj
|
t3_kvfej
| null |
t1_c2nlcpj
|
t1_c2nl8dj
| null |
1427664526
|
3
|
t5_2fwo
| null | null | null |
True
|
banuday
| null |
D'oh, you're right. REST is not limited to HTTP. And with HTTP, it is true you can add whatever verbs you want, beyond the set defined in the HTTP specification.
Hopefully that snafu did not detract from my point, which is that REST is resource-centric with the uniform interface as central to the design (as opposed to SOAP, for example).
| null |
0
|
1317328053
|
False
|
0
|
c2nlcvl
|
t3_kv57g
| null |
t1_c2nlcvl
|
t1_c2nl9gb
| null |
1427664528
|
1
|
t5_2fwo
| null | null | null |
True
|
roymustang86
| null |
Yeah, I think a large part of that is just laziness, and to an extent "fear". Go to the top schools in the US: MIT, Stanford, Berkeley, Princeton or whichever. Even if you are in undergrad you don't see a lot of Americans in the ECE/CS programs. When you go to grad school, its a whole different story,the majority is always some flavor of Asians there. Oh, and do you know how the H1B process works?? The company has to put an ad out for the job, and show the USCIS that why they were not able to find a US citizen to do the job they are currently giving to a H1B visa holder. So yeah, "super technical" stuff does require outside talent. Let me know if you want examples of the super technical stuff developed by people outside the US.
| null |
0
|
1317328082
|
False
|
0
|
c2nld1o
|
t3_kuye2
| null |
t1_c2nld1o
|
t1_c2nl75k
| null |
1427664533
|
1
|
t5_2fwo
| null | null | null |
True
|
Timbit42
| null |
I quite like Philosopher.
| null |
0
|
1317328084
|
False
|
0
|
c2nld24
|
t3_kuti3
| null |
t1_c2nld24
|
t1_c2ni8ka
| null |
1427664531
|
1
|
t5_2fwo
| null | null | null |
True
|
brotherbond
| null |
From the very first paragraph:
> An assertion is a statement in the JavaTM programming language that enables you to test your assumptions about your program. For example, **if you write a method that calculates the speed of a particle, you might assert that the calculated speed is less than the speed of light. **
| null |
0
|
1317328106
|
False
|
0
|
c2nld70
|
t3_kvnyx
| null |
t1_c2nld70
|
t3_kvnyx
| null |
1427664532
|
4
|
t5_2fwo
| null | null | null |
True
|
dmwit
| null |
Yes, this is exactly right. You can pick lots of different metrics to measure rectangles by. Some make sense, and some don't, and during that part of the exposition, he's trying to figure out what it is precisely about the nonsense metrics that makes them nonsense.
For example, suppose I told you that I believe that the rectangle with the biggest `x` component should be considered the biggest rectangle (with ties broken by `y`, then `w`, then `h`). Does this make sense? Well, it makes sense for other applications, like if all you needed was to make a binary search tree whose elements were rectangles, this would serve perfectly well as a metric. But for this application, it doesn't make sense at all.
But what, exactly, doesn't make sense? As he says later, the bit that doesn't make sense is that you can _enlarge_ the rectangle -- say, by decreasing `x` by one and increasing `w` by one at the same time -- and find that the resulting enlarged rectangle has a _smaller_ metric. So we only want to consider metrics that get "bigger" when the rectangle is enlarged.
(The general math term for this property is monotonicity, and it comes in lots of places.)
| null |
0
|
1317328157
|
False
|
0
|
c2nldh0
|
t3_kv3ww
| null |
t1_c2nldh0
|
t1_c2nja2g
| null |
1427664536
|
2
|
t5_2fwo
| null | null | null |
True
|
sgoguen
| null |
> Oh look, I've just discovered the addition monad.
You mean monoid, not monad. There's a big difference between the two:
A monoid means you've defined a binary operation of that takes two items of type T and returns a value of type T. It's also associative and has an identity element. You can define a monoid in F# like so:
type monoid = 'T -> 'T -> 'T
A monad means you need to defined two functions like so:
bind: M<'T> ->('T -> M<'U>) -> M<'U>
return: 'T -> M<'T>
Bind has to be associative, and the identity rule also has to apply as well.
> Why the hell can't they talk about the important stuff regarding MapReduce in Haskell instead of droning on endlessly about monads?
A lot of programmers still don't know anything monads. This may be old hat for you, but it isn't for a lot of others. When I first started getting into all things monadic, I remember how excited I was when I realized something was a monad. I was excited because it implied these things can be composed easily and predictably and with a nice syntax.
> As far as conveying information, this is even worse than Java's obessions with design patterns.
Words like monad and notation like M a -> (a -> M b) -> M b are intentionally abstract. The reason for this abstraction is to remove references to concrete things so one can reason about the pure structure without being distracted by the implications of metaphorical names. [You'd be surprised at how well names can distort reality](http://www.njgeeks.org/presentations/FS-Patterns-Long/#40) (Doesn't work in IE). Here's a link to the video: (http://www.youtube.com/watch?v=4b71rT9fU-I)
Anyway, that's my two cents.
| null |
0
|
1317328214
|
True
|
0
|
c2nldt3
|
t3_kv4xx
| null |
t1_c2nldt3
|
t1_c2njcd7
| null |
1427664541
|
13
|
t5_2fwo
| null | null | null |
True
|
Flarelocke
| null |
He wanted application, not composition.
| null |
0
|
1317328325
|
False
|
0
|
c2nlefm
|
t3_kuhn3
| null |
t1_c2nlefm
|
t1_c2nj9fz
| null |
1427664548
|
2
|
t5_2fwo
| null | null | null |
True
|
ivquatch
| null |
Wow. This might be the first time I've heard anyone cite the STL (and templates) in defense of C++. I've just perusing the eigen source out of curiosity. While looking at Quaternion, I found this:
/** \returns \c *this with scalar type casted to \a NewScalarType
*
* Note that if \a NewScalarType is equal to the current scalar type of \c *this
* then this function smartly returns a const reference to \c *this.
*/
template<typename NewScalarType>
inline typename internal::cast_return_type<Derived,Quaternion<NewScalarType> >::type cast() const
{
return typename internal::cast_return_type<Derived,Quaternion<NewScalarType> >::type(
coeffs().template cast<NewScalarType>());
}
Jesus christ monkey balls. It's shit like this that scares undergrads off generics for good.
| null |
0
|
1317328362
|
False
|
0
|
c2nlen3
|
t3_kteac
| null |
t1_c2nlen3
|
t1_c2nhqit
| null |
1427664551
|
0
|
t5_2fwo
| null | null | null |
True
|
toofishes
| null |
http://drdobbs.com/blogs/cpp/231602010
| null |
0
|
1317328511
|
False
|
0
|
c2nlfis
|
t3_kvg67
| null |
t1_c2nlfis
|
t1_c2nk18y
| null |
1427664561
|
2
|
t5_2fwo
| null | null | null |
True
|
jsprogrammer
| null |
Right click -> View source?
| null |
0
|
1317328535
|
False
|
0
|
c2nlfnb
|
t3_kucjn
| null |
t1_c2nlfnb
|
t1_c2nj9wf
| null |
1427664563
|
3
|
t5_2fwo
| null | null | null |
True
|
masklinn
| null |
> Hopefully that snafu did not detract from my point, which is that REST is resource-centric with the uniform interface as central to the design (as opposed to SOAP, for example).
Technically, your point is wrong as well. While REST is indeed resource-centric, AJAX is completely orthogonal and REST is no more about "uniform interfaces" than SOAP. Furthermore REST does not mandate any kind of device-independent resource, only that resources (media types) be well defined and that traversal be done with hyperlinks (encoded in the media types).
For instance:
> The AJAX request and response is typically specific to the type of partial page refresh requested instead of being a feature of the resource itself
The AJAX request and response is whatever is needed, and what is needed can be encoded as a resource, even if that resource
| null |
0
|
1317328555
|
False
|
0
|
c2nlfr5
|
t3_kv57g
| null |
t1_c2nlfr5
|
t1_c2nlcvl
| null |
1427664564
|
2
|
t5_2fwo
| null | null | null |
True
|
Robbazorrathon
| null |
They said my delivery methods didn't fit with their business model - churn out cheap rubbish for premium rates and make the client pay for the fixes.
| null |
0
|
1317328562
|
False
|
0
|
c2nlfsm
|
t3_kvo92
| null |
t1_c2nlfsm
|
t3_kvo92
| null |
1427664566
|
49
|
t5_2fwo
| null | null | null |
True
|
janhammer96
| null |
Isn't that exactly the same in almost every single FP language? Why mention Haskell?
| null |
0
|
1317328632
|
False
|
0
|
c2nlg6h
|
t3_kvg67
| null |
t1_c2nlg6h
|
t1_c2nkd32
| null |
1427664571
|
1
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
The problem is that the function has no idea what it can operate on. It just blindly deletes anything you pass it.
| null |
0
|
1317328654
|
False
|
0
|
c2nlgc3
|
t3_kvfej
| null |
t1_c2nlgc3
|
t1_c2nk8vt
| null |
1427664572
|
-2
|
t5_2fwo
| null | null | null |
True
|
jsprogrammer
| null |
How do you know it is undesirable?
If you already know all of the undesirable traits then why do you need a genetic algorithm?
| null |
0
|
1317328723
|
False
|
0
|
c2nlgqu
|
t3_kucjn
| null |
t1_c2nlgqu
|
t1_c2nil4t
| null |
1427664578
|
2
|
t5_2fwo
| null | null | null |
True
|
ash_gti
| null |
Why not? If you had an implementation it would show up in the documentation that its a class somewhere. They were just justifying the reason for implementing it as a monad.
They could of implemented it as a type class or a set of polymorphic functions but in this case they chose a monad.
| null |
0
|
1317328768
|
False
|
0
|
c2nlgyw
|
t3_kv4xx
| null |
t1_c2nlgyw
|
t1_c2nlc6g
| null |
1427664581
|
5
|
t5_2fwo
| null | null | null |
True
|
pgngugmgg
| null |
say there is a lake with two species of fish: A and B. Is A part of the environment of B?
| null |
0
|
1317328782
|
False
|
0
|
c2nlh1s
|
t3_kucjn
| null |
t1_c2nlh1s
|
t1_c2nl3da
| null |
1427664582
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317328798
|
1380816186
|
0
|
c2nlh4m
|
t3_kvo92
| null |
t1_c2nlh4m
|
t1_c2nlfsm
| null |
1427664583
|
11
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
Git recursive is certainly more deterministic. That a lone does not guarantee that it is "safer". In fact, this is the same argument some Darcs people have used against non-determinism in Git that comes from being version-based. If you want to say to me that it's "true" that it's safer, first you need to define what it means to be safer and either do some kind of experiment or proof (sketch proof, even) that it is safer in general. Until you have some kind of proper test then yes, it is personal judgment as to which is better.
| null |
0
|
1317328840
|
False
|
0
|
c2nlhds
|
t3_kt058
| null |
t1_c2nlhds
|
t1_c2ncepf
| null |
1427664587
|
1
|
t5_2fwo
| null | null | null |
True
|
samandiriel
| null |
I'd show them more pity if I hadn't had to clean up so much terrible VB code :P
| null |
0
|
1317328860
|
False
|
0
|
c2nlhi3
|
t3_kvg67
| null |
t1_c2nlhi3
|
t1_c2nlayt
| null |
1427664588
|
1
|
t5_2fwo
| null | null | null |
True
|
neitz
| null |
Well I agree to an extent. But with a tuple it makes sense to have a fixed number of elements, because then you know element 2 is going to be an Int or whatever. But with arbitrary size, its just like a list. I mean you could always use a list of a record type. It is not the same as a truly dynamically typed list, but gives you the benefit of static typing.
| null |
0
|
1317328912
|
False
|
0
|
c2nlhte
|
t3_ktxzn
| null |
t1_c2nlhte
|
t1_c2nkl2k
| null |
1427664592
|
2
|
t5_2fwo
| null | null | null |
True
|
michaelochurch
| null |
I have no idea how recent this problem is, but it definitely feels to have become worse, perhaps just because there are more huge (50MLoC+) code bases these days.
| null |
0
|
1317328936
|
False
|
0
|
c2nlhyi
|
t3_kursf
| null |
t1_c2nlhyi
|
t1_c2nk7pl
| null |
1427664595
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
I don't know much about genetic algorithms but I do wonder if you could improve success by "mating" fit pairs based on a similarity score.. that way you wouldn't be mating a worm evolving one mode of locomotion (which works well) with another type of locomotion entirely (which also works well) resulting in dud offspring.
Maybe this is implicitely accounted for in the selection and breeding process?
| null |
0
|
1317329078
|
False
|
0
|
c2nliof
|
t3_kucjn
| null |
t1_c2nliof
|
t1_c2nd4ov
| null |
1427664604
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
I don't know much about genetic algorithms but I do wonder if you could improve success by "mating" fit pairs based on a similarity score.. that way you wouldn't be mating a worm evolving one mode of locomotion (which works well) with another type of locomotion entirely (which also works well) resulting in dud offspring.
Maybe this is implicitely accounted for in the selection and breeding process?
Also I think the fitness function shouldn't discriminate between "negative" and "positive" directions.
| null |
0
|
1317329097
|
False
|
0
|
c2nliw5
|
t3_kucjn
| null |
t1_c2nliw5
|
t1_c2nd4ov
| null |
1427664611
|
1
|
t5_2fwo
| null | null | null |
True
|
alien_bob
| null |
But you can talk about something being a lambda function, or a LINQ query.
So perhaps when something is the default, you don't bother stating the obvious. But when it uses some specific construct, you mention what that construct is.
| null |
0
|
1317329102
|
False
|
0
|
c2nlixk
|
t3_kv4xx
| null |
t1_c2nlixk
|
t1_c2nlc6g
| null |
1427664607
|
3
|
t5_2fwo
| null | null | null |
True
|
Robbazorrathon
| null |
This MUST be wrong then:
http://www.telegraph.co.uk/science/science-news/8785366/Science-world-in-shock-after-Cern-light-speed-claim.html
| null |
0
|
1317329143
|
False
|
0
|
c2nlj5y
|
t3_kvnyx
| null |
t1_c2nlj5y
|
t3_kvnyx
| null |
1427664610
|
-4
|
t5_2fwo
| null | null | null |
True
|
rubygeek
| null |
People have a significantly increased ability to pick up a first language as children, and generally don't get to pick the one they learn, so that analogy is fatally flawed.
A better analogy would be to say that use of complex ideograms is one of the reasons why comparably few adults attempt to learn Mandarin.
| null |
0
|
1317329159
|
False
|
0
|
c2nlja2
|
t3_kv3ww
| null |
t1_c2nlja2
|
t1_c2njqfc
| null |
1427664611
|
2
|
t5_2fwo
| null | null | null |
True
|
White_Sox
| null |
I second this. Monaco is great.
| null |
0
|
1317329218
|
False
|
0
|
c2nljmr
|
t3_kuti3
| null |
t1_c2nljmr
|
t1_c2ngrki
| null |
1427664616
|
1
|
t5_2fwo
| null | null | null |
True
|
eek04
| null |
Your slogan is misrepresenting things: It's if you take anything, give everything.
And I personally see blocking the ability of people to choose to work on a codebase and give some but not all as a significant flaw in the GPL.
| null |
0
|
1317329220
|
False
|
0
|
c2nljnb
|
t3_kl7h0
| null |
t1_c2nljnb
|
t1_c2lcyhk
| null |
1427664616
|
1
|
t5_2fwo
| null | null | null |
True
|
nielsadb
| null |
There are differences between the two, albeit small ones. You cannot simply take an XPS RIP and expect it to render any OpenXPS PDL file correctly.
Don't know if there are differences between the "XPS Print Path" and that of OpenXPS, but my guess would be that there are.
| null |
0
|
1317329256
|
False
|
0
|
c2nljud
|
t3_kssyt
| null |
t1_c2nljud
|
t1_c2n1fzk
| null |
1427664618
|
1
|
t5_2fwo
| null | null | null |
True
|
I_TYPE_IN_ALL_CAPS
| null |
> Indeed. Because technically the documentation doesn't even need to say what happens when you pass NULL, because NULL is not a valid heap block and is therefore already an invalid parameter.
*SIGH* IT'S LIKE MICROSOFT SWAPPING THE GAS AND BRAKE PEDALS, THEN WHEN YOU COMPLAIN, TELLING YOU IT'S CLEARLY LAID OUT IN A FOOTNOTE STATING THAT THE VEHICLE IS COMPLIANT WITH SUBSECTION B OF THE *MICROSOFT HIGHWAY DESIGN CODE*. OH, YOU DON'T KNOW SUBSECTION B OF THE *MICROSOFT HIGHWAY DESIGN CODE*? WHY ARE YOU EVEN TRYING TO DRIVE, THEN?
| null |
0
|
1317329516
|
False
|
0
|
c2nll8b
|
t3_kvfej
| null |
t1_c2nll8b
|
t3_kvfej
| null |
1427664636
|
-8
|
t5_2fwo
| null | null | null |
True
|
aualin
| null |
My everday programming font, using 6x11
| null |
0
|
1317329549
|
False
|
0
|
c2nlle6
|
t3_kuti3
| null |
t1_c2nlle6
|
t1_c2nh18m
| null |
1427664639
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317329576
|
False
|
0
|
c2nllj4
|
t3_kvo92
| null |
t1_c2nllj4
|
t3_kvo92
| null |
1427664640
|
42
|
t5_2fwo
| null | null | null |
True
|
antonivs
| null |
A more general way to put int_argc's point would be that monads abstract some ambient state (not necessarily mutable) or structure from a value being operated on, allowing the concerns to be separated.
To give a concrete example of this, even something as simple as the Maybe monad abstracts the existence of a value from the value itself, so that you don't need to use error-prone techniques which conflate a data type with metadata about itself, the way "null" values do.
int_argc's basic point is correct, which is that monads are an important tool for this kind of structuring in Haskell, and their use results in very precise types being assigned to different aspects of a program. This is very useful for software engineering reasons, among other things.
| null |
0
|
1317329600
|
False
|
0
|
c2nlln7
|
t3_kv4xx
| null |
t1_c2nlln7
|
t1_c2nk5de
| null |
1427664642
|
6
|
t5_2fwo
| null | null | null |
True
|
Flarelocke
| null |
> I don't know whether Haskell and OCaml have a similar syntactic features
The usual way to write that in Haskell is:
f . g . h $ x
or
f $ g $ h $ x
You can also define reverse application as:
(|>) = flip ($)
infixl 0 (|>)
Also, Haskell's record update syntax is:
data MyRecord = MyRecord { x,y,z :: Int }
myRecord1 = MyRecord {x = 1, y = 2, z = 3}
myRecord2 = myRecord1{y = 100}
(Since Haskell is purely functional, when we say update, we mean clone, although sharing that arises from laziness means the record isn't necessarily a clone as implemented)
| null |
0
|
1317329673
|
False
|
0
|
c2nllzy
|
t3_kuhn3
| null |
t1_c2nllzy
|
t1_c2nj0oo
| null |
1427664646
|
4
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
Sadly I find that to be true. I love VB, I think it is a much better language than C# in many ways, but I don't like the companies that use it.
| null |
0
|
1317329739
|
False
|
0
|
c2nlmdm
|
t3_kvg67
| null |
t1_c2nlmdm
|
t1_c2nlayt
| null |
1427664651
|
0
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
I got rolling worms (dunno if there's a load function hiding anywhere):
2.123932965904618,2.6097850004698078,0.27938222504536503,3.6787974681577893,20,17.97156550307803,13.207433516157446,18.028032497508065,15.83832160187739,17.68811199758967,14.615105510617319,13.72231475912113,12.587049781751379,5.8279318508791595,1.6649571947056931,5.947627394500732,1.1680236524967844,0.8396184632031394,0.6546968994836282,2.23913492396295,2.7749423619809863,1.1577832985359329,0.6243535411614349,0.0816300439202382,0.6666666666666666,0.012975331213774699,0.4107990213717166,0.4965641697352155,0.44645255322927424,0.0626960196660653,0.06938093396440233,3.1305283927457315,3.028238338638132,2.9469696817403728,2.746252254972942
| null |
0
|
1317329778
|
False
|
0
|
c2nlmkx
|
t3_kucjn
| null |
t1_c2nlmkx
|
t1_c2nbvy8
| null |
1427664654
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
[deleted]
| null |
0
|
1317329809
|
False
|
0
|
c2nlmrb
|
t3_ku203
| null |
t1_c2nlmrb
|
t1_c2nd0nc
| null |
1427664656
|
1
|
t5_2fwo
| null | null | null |
True
|
kataire
| null |
Wasn't Wave advertised as e-mail re-imagined with the knowledge of today?
To be fair, Wave wasn't killed by its own limitations. It was merely a victim of terrible, terrible timing.
| null |
0
|
1317329837
|
False
|
0
|
c2nlmx1
|
t3_kuz9x
| null |
t1_c2nlmx1
|
t1_c2ngptw
| null |
1427664658
|
1
|
t5_2fwo
| null | null | null |
True
|
[deleted]
| null |
Yes. So?
| null |
0
|
1317329888
|
False
|
0
|
c2nln6m
|
t3_kucjn
| null |
t1_c2nln6m
|
t1_c2nlh1s
| null |
1427664662
|
1
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
C# won't either.
But VB is a "do what I mean" style language. You can write some pretty horrible code -- from an engineering perspective -- that still works because the compiler is smart enough to figure out your intentions.
| null |
0
|
1317329926
|
False
|
0
|
c2nlne3
|
t3_kvg67
| null |
t1_c2nlne3
|
t1_c2nklm7
| null |
1427664664
|
1
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
You aren't squinting hard enough. The addition monad is `+ 1`, which returns an `M<int>`. The partial integer `y` is then curried with the `M<int>` to create the funkiator `x` of type `P<M<int>>`.
| null |
0
|
1317330252
|
False
|
0
|
c2nlp6o
|
t3_kv4xx
| null |
t1_c2nlp6o
|
t1_c2nldt3
| null |
1427664688
|
-7
|
t5_2fwo
| null | null | null |
True
|
antonivs
| null |
Saying something "is an object" doesn't convey much information because it's at the top of the inheritance hierarchy.
If you inherited a MapReduce from some other class, or created mapreduce objects by instantiating some existing general class, mentioning what class that was would certainly be relevant.
| null |
0
|
1317330379
|
False
|
0
|
c2nlpvd
|
t3_kv4xx
| null |
t1_c2nlpvd
|
t1_c2nlc6g
| null |
1427664698
|
5
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
Sure we could say something can be *expressed* as a a lambda function, or a LINQ query, but that doesn't mean it *is* one.
| null |
0
|
1317330383
|
False
|
0
|
c2nlpwc
|
t3_kv4xx
| null |
t1_c2nlpwc
|
t1_c2nlixk
| null |
1427664698
|
0
|
t5_2fwo
| null | null | null |
True
|
amackera
| null |
These are some great tweaks to an already great font! Thanks for the pointer!
| null |
0
|
1317330396
|
False
|
0
|
c2nlpzc
|
t3_kuti3
| null |
t1_c2nlpzc
|
t1_c2nhyrg
| null |
1427664699
|
3
|
t5_2fwo
| null | null | null |
True
|
Tordek
| null |
1 and 2 are exactly what E-Mail must never have.
| null |
0
|
1317330452
|
False
|
0
|
c2nlq9g
|
t3_kuz9x
| null |
t1_c2nlq9g
|
t3_kuz9x
| null |
1427664703
|
1
|
t5_2fwo
| null | null | null |
True
|
Solomaxwell6
| null |
It's not as simple as picking apart undesirable traits. In the real world, the way evolution works is that you start off with some kind of input (the gene sequence). If that input is shown to be fit, it'll have greater influence on the next generation of inputs. Each element of that next generation will be slightly mutated, so they won't be exactly as fit; some will be better than the predecessor, and then they'll be the ones to pass on their genes. Over time, the slight mutations add up and you end up with something completely different and far more fit than the real thing.
In real life, fitness is basically "able to produce many children given the constraints of its real world environment." When doing an artificial genetic algorithm, you can define fitness however the fuck you want. It's only an analogy, after all, not a requirement. So OP can define fitness as "able to move as fast as possible, while preventing the head from smashing into the ground."
The main point is that we DON'T know all of the undesirable traits. Perhaps a worm should move by crawling. Perhaps a worm should move by jumping. Perhaps a worm should move by using its middle segments to lift the front segment up, then rotate the front segment in a circle, or any number of other horrible methods. Each of those has various levels of efficacy, and the genetic algorithm in OP will figure out what's best.
| null |
0
|
1317330472
|
False
|
0
|
c2nlqcq
|
t3_kucjn
| null |
t1_c2nlqcq
|
t1_c2nlgqu
| null |
1427664705
|
2
|
t5_2fwo
| null | null | null |
True
|
reddit_clone
| null |
Ahh.. Its been a while..
| null |
0
|
1317330472
|
False
|
0
|
c2nlqcy
|
t3_kv2uy
| null |
t1_c2nlqcy
|
t3_kv2uy
| null |
1427664705
|
2
|
t5_2fwo
| null | null | null |
True
|
myhf
| null |
That seems a little silly for a method that calculates the speed of a particle. It might make more sense in a method that calculates the kinetic energy of a particle, but of course such a method could just return Infinity or NaN.
| null |
0
|
1317330493
|
False
|
0
|
c2nlqht
|
t3_kvnyx
| null |
t1_c2nlqht
|
t1_c2nld70
| null |
1427664707
|
2
|
t5_2fwo
| null | null | null |
True
|
mikaelhg
| null |
My goodness, a /r/programming link to an article which discusses things which are actually significant to programming project success, instead of amateur wankery? The sky must be falling.
| null |
0
|
1317330517
|
False
|
0
|
c2nlqm3
|
t3_kv8db
| null |
t1_c2nlqm3
|
t3_kv8db
| null |
1427664709
|
9
|
t5_2fwo
| null | null | null |
True
|
grauenwolf
| null |
Well yea, if you understand that Haskell expresses all list comprehensions as monads it is a pretty good assumption that MapReduce would also be expressed as one. But if you didn't know anything about Haskell and monads then... well you really wouldn't understand the article.
| null |
0
|
1317330542
|
False
|
0
|
c2nlqql
|
t3_kv4xx
| null |
t1_c2nlqql
|
t1_c2nkaw4
| null |
1427664710
|
3
|
t5_2fwo
| null | null | null |
True
|
hyperforce
| null |
Not everyone (like myself) has the discipline or start-it-up-titude to embark on doing their own meta work (things unrelated to raw development like running a business).
| null |
0
|
1317330555
|
False
|
0
|
c2nlqt9
|
t3_ktxk5
| null |
t1_c2nlqt9
|
t1_c2nae06
| null |
1427664710
|
1
|
t5_2fwo
| null | null | null |
True
|
hyperforce
| null |
I agree with you to an extent that you are responsible for voicing your concerns but sometimes the concerns fall on deaf ears. So not much recourse there!
| null |
0
|
1317330609
|
False
|
0
|
c2nlr3k
|
t3_ktxk5
| null |
t1_c2nlr3k
|
t1_c2n7v5e
| null |
1427664717
|
1
|
t5_2fwo
| null | null | null |
True
|
kristovaher
| null |
I originally released it [here](http://www.reddit.com/r/programming/comments/kuti3/5_good_programming_fonts/c2ngj3g) so if you grabbed it there already, no need to grab it again.
| null |
0
|
1317330624
|
False
|
0
|
c2nlr6c
|
t3_kvpld
| null |
t1_c2nlr6c
|
t3_kvpld
| null |
1427664716
|
16
|
t5_2fwo
| null | null | null |
True
|
ondra
| null |
> People have a significantly increased ability to pick up a first language as children,
Do they? I believe this is actually unknown and probably untrue.
Children can spend an insane amount of time practicing.
| null |
0
|
1317330670
|
False
|
0
|
c2nlrg6
|
t3_kv3ww
| null |
t1_c2nlrg6
|
t1_c2nlja2
| null |
1427664723
|
-5
|
t5_2fwo
| null | null | null |
True
|
hyperforce
| null |
Per your definition, a lot of non-professionals make it into upper management. Be all "well that shouldn't be" all you want, but it does happen. What now?
| null |
0
|
1317330698
|
False
|
0
|
c2nlrm3
|
t3_ktxk5
| null |
t1_c2nlrm3
|
t1_c2n8zyi
| null |
1427664723
|
1
|
t5_2fwo
| null | null | null |
True
|
hyperforce
| null |
Dude, finding a competent manager is like finding a unicorn.
| null |
0
|
1317330737
|
False
|
0
|
c2nlrt0
|
t3_ktxk5
| null |
t1_c2nlrt0
|
t1_c2n9v0x
| null |
1427664725
|
1
|
t5_2fwo
| null | null | null |
True
|
TheSuperficial
| null |
Why do I want to eat a big bowl of pasta after looking at that code?
| null |
0
|
1317330752
|
False
|
0
|
c2nlrvl
|
t3_kvo92
| null |
t1_c2nlrvl
|
t3_kvo92
| null |
1427664725
|
27
|
t5_2fwo
| null | null | null |
True
|
hyperforce
| null |
And what if they're not the type to listen?
| null |
0
|
1317330825
|
False
|
0
|
c2nls90
|
t3_ktxk5
| null |
t1_c2nls90
|
t1_c2n98kw
| null |
1427664729
|
1
|
t5_2fwo
| null | null | null |
True
|
ErstwhileRockstar
| null |
The advantage of Java is that you can refactor this code into 5 - 10 methods within 5 - 10 minutes.
| null |
0
|
1317330850
|
False
|
0
|
c2nlsdn
|
t3_kvo92
| null |
t1_c2nlsdn
|
t3_kvo92
| null |
1427664731
|
-1
|
t5_2fwo
| null | null | null |
True
|
djork
| null |
I got laid off over a woman who wrote > 180 separate `.jsp` pages for each permutation of filtered-by/sorted-by views of some tabular data. She worked *really* hard. Meanwhile, I had a net negative code impact at the time I left.
Edit: misogyny
| null |
0
|
1317331600
|
True
|
0
|
c2nlwdz
|
t3_kvo92
| null |
t1_c2nlwdz
|
t3_kvo92
| null |
1427664785
|
71
|
t5_2fwo
| null | null | null |
True
|
reddit_clone
| null |
In a way it is.
Testable means you can modify it (or refactor it) without breaking stuff all over the place.
That takes out _the_ major roadblock for maintenance programming.
| null |
0
|
1317331660
|
False
|
0
|
c2nlwpm
|
t3_ktg8c
| null |
t1_c2nlwpm
|
t1_c2ndsv2
| null |
1427664788
|
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.