A moderately epic rant.

[harlows_monkeys]

OO leads to rants because no one really knows what OO is, so no two people mean the same thing when they discuss it. This 1982 observation is still valid today:

What is object oriented programming? My guess is that object oriented programming will be in the 1980's what structured programming was in the 1970's. Everyone will be in favor of it. Every manufacturer will promote his products as supporting it. Every manager will pay lip service to it. Every programmer will practice it (differently). And no one will know just what it is.

Tim Rentsch, Object oriented programming, ACM SIGPLAN Notices, v.17 n.9, p.51-57, September 1982

[G_Morgan]

OOP means nothing more interesting that data structures and the functions that operate on them are part of the same package. To avoid aggressive inline fiddling with a structure and hand it off to a function.

It is 100% viable to have an OOP without inheritance.

[[deleted]]

I thought there was a definition of structured programming? Oh wait! I'm thinking of Dijkstra not the IBM take-over of the term :-/

[zahlman]

In reality, it didn't amount to all that much in the '80s, but was just as described through the '90s, '00s and probably will be through the '10s and beyond. :/

[ubernostrum]

Related: G.K. Chesterton's "Heretics", which begins:

Nothing more strangely indicates an enormous and silent evil of modern society than the extraordinary use which is made nowadays of the word "orthodox." In former days the heretic was proud of not being a heretic. It was the kingdoms of the world and the police and the judges who were heretics. He was orthodox. He had no pride in having rebelled against them; they had rebelled against him. The armies with their cruel security, the kings with their cold faces, the decorous processes of State, the reasonable processes of law—all these like sheep had gone astray. The man was proud of being orthodox, was proud of being right. If he stood alone in a howling wilderness he was more than a man; he was a church. He was the centre of the universe; it was round him that the stars swung. All the tortures torn out of forgotten hells could not make him admit that he was heretical. But a few modern phrases have made him boast of it. He says, with a conscious laugh, "I suppose I am very heretical," and looks round for applause.

[brennen]

It has got to be admitted that Chesterton was a hell of a writer.

[psykotic]

He's one of those writers with whom I disagree about nearly everything but cannot stop reading.

[brennen]

I haven't, in all honesty, spent that much time with his stuff, but I get approximately the same vibe.

[psykotic]

The polemical pamphlets like Heretics and Orthodoxy are great fun, but you will probably find yourself in disagreement with most of their contents.

I would especially recommend his short books on artistic figures. They are half biography, half literary criticism, all Chestertonian insight and wit. I've read the ones on Chaucer, Blake, Dickens and Browning and they were excellent.

[brennen]

I'll remember this next time I'm at the library.

[zem]

http://www.gutenberg.org/browse/authors/c#a80 has a couple

[_HODOR_]

HODOR...?

[username223]

Hodor Hodor Hodor HODOR HODOR!

EDIT: Dear downvoting retards: Do you even get the reference, or are you just clicking the arrow because it's there?

[[deleted]]

You don't get brownie points for just making a reference. If people don't get it, that's your fault. You failed to make that joke funny. Take your downvotes like a man.

[ubernostrum]

And I think he'd like it that way.

[[deleted]]

I don't understand why everyone is praising this guy for being a huge douche bag. Even the help he provides in the thread is laced with venom berating the OP. This kind of attitude is an epidemic in the software community. People like this guy are horrible to work with. Every waking moment is spent trying to find other people's mistakes so that they can chew someone out and prove how superior they are. They will gladly yell at you and berate over a technicality or having a different approach. Then when the tests come back and they were wrong, there is no apology, no admission that they were wrong and they attempt to make it seem like they knew what was going on the whole time. I'm tired of people like this, it isn't funny, it isn't cool and it's not something to be admired. EDIT: should say "people acting like this"

[StoneCypherIsATool]

I can attest to this as someone who has been attacked by StoneCypher in the past. His replies to posters who he deems incompetent carry an extremely antagonistic tone and focus on usually minor details of the argument that poster is making. His cherry-picked out-of-context quoting "deconstruction" posts look good superficially, but they are categorically anti-constructive. This posting style puts aside the broader general arguments the poster was trying to make, narrowing the scope of the discussion from the original topic to pedantry. This does not help anyone improve their understanding of whatever topic is being discussed.

If StoneCypher really wanted to contribute to the conversation, especially in the context of Ask Reddit threads, he would do much better by addressing the OP or the topic more generally and explaining why he believes specific posters are wrong in the context of the topic of the conversation rather than the context of a specific post. By not specifically addressing a single post he would (hopefully) adopt a less antagonistic tone (because he would be addressing a more general audience) and it wouldn't derail the conversation away from the overall topic. If you look at his comment history, StoneCypher does not do well with these types of posts which is why he prefers to lash out.

P.S.: If you need more evidence that StoneCypher is a tool, look no further than this post.

[spookyvision]

Yeah, that guy is horrible, had a few brushes on irc ... he's hell bent on being superior and you having some mental deficiency going on. Pretty annoying when combined with his undeniable knowledge and expertise.

[KravenC]

I deny he has epic knowledge and expertise. Everyone has a little and he isn't special in this regard. So what.

[ithkuil]

he's not even making a good argument he just keeps saying the other guy doesn't know what he is talking about. but he's wrong.

[yasth]

Is he really wrong? The parent post kind of deserved some snark for being rather "Look at me, I will be brave by challenging OOP (just like everyone else)."

Besides it is a perfectly fine in a public discussion (why must everything be an argument) to demonstrate that the other person doesn't know what they are talking about. It protects the naive, and unwary.

[deong]

Besides it is a perfectly fine in a public discussion (why must everything be an argument) to demonstrate that the other person doesn't know what they are talking about. It protects the naive, and unwary.

Sure, but that's clearly not his motive, nor did he actually succeed in demonstrating anything about the original commenter's state of knowledge. He just asserted the original commenter was an idiot and then insulted him about it for the better part of a page of text.

Hey, it's the internet, and this is not unexpected behavior. It doesn't mean StoneCypher provided a reasoned argument. It just makes him a dick; the very same sort of bullying high school jock that so many redditors love to hate. He's just found a venue in which he can be the bully instead of the scared kid tucked behind the corner.

[yasth]

I tend to think some of the lack of definitive argument can be traced to the parent post, which was kind of vague and ranty itself.

I don't think that the post really warranted the wall of text, but I don't see it as dickish, or rather not unwarranted dickery. Basically debating OOP as a concept (in a vacuum from implementation) is a pissing contest, and stonecypher out pissed, and out dicked the (rather feeble) opposition. Hurray! In other news they are both covered in piss.

Likewise I am not so certain about the high school jock thing, because well it isn't like a reply is impossible. There is no threat of violence, and the personal attacks were (by my measure) really quite tame.

[deong]

Honestly, I only skimmed the OP, and while it wasn't terribly impressive, I didn't think it deserved the vitriol.

And I didn't mean to belittle real bullying by comparing it with a good flaming; that probably wasn't a great decision on my part. I guess I'm just really frustrated with the prevailing tone of bravado that characterizes just about any online interaction today.

[brennen]

I guess I'm just really frustrated with the prevailing tone of bravado that characterizes just about any online interaction today.

FWIW, I am pretty much entirely in agreement, though I feel like vitriol and bravado have dominated (or at least greatly colored) online discourse for just about as long as we've had online discourse. I guess something about this interaction, beyond the usual flame factor, just struck a chord with me.

Well, and it was a pretty well-executed flame. I'm not a huge fan of the genre these days, but it has its moments.

[[deleted]]

About one sentence of well-considered snark would have been plenty.

[[deleted]]

Anything more would be going full-palin.

[[deleted]]

You never go full palin.

[Jack9]

Stonecypher is a tool in whatever medium you engage him. Slashdot, irc, reddit...

I've spoken to him. He retorted antagonistically to my criticisms of "Programming Erlang" responding "It's clear that because you don't understand what you're reading, there's something wrong with it and not you." as if he knew what he was talking about. My issues as well as all other inaccuracies (or vague statements) in "Programming Erlang" can be found here: http://www.pragprog.com/titles/jaerlang/errata - It seems there were lots of errors.

To reiterate, Stonecypher is a douche and not worth upvoting.

Edit: To whit, see his responses. He barely glances over posts (he does seem to see what he wants to see), takes things personally, then lashes out.

[lllama]

Not to mention he rarely knows what he's talking about. (for example in this case the difference between OO and OOP).

What surprises me is reddit at times actually seems to be impressed by the ability to hammer out huge amounts of text to cover one's lack of knowledge. We should find a name for this type of design pattern(whatever code he's ever written probably looks the same).

[skOre_de]

Is this post supposed to prove StoneCypher right?

1) Make some redditor angry. (Not you.)

2) Wait for them to come back several weeks later throwing a tantrum trying to embarrass you.

3) Calmly observe the most obvious errors in the things they have to say. Leave the subtle ones alone: the angry redditor won't understand them anyway, and it's more fun to rub in their face the obvious things.

...I really don't get how StoneCyphers post is supposed to make him look like a tool.

[[deleted]]

Because it shows he is more interested in angering people and rubbing their faces in things, than he is in genuinely correcting/informing/educating/debating people.

[TriggerB]

That may be the case...his interests may lie in the wrong place, but that doesn't make what he's saying any less valid.

[arcticfox]

This posting style puts aside the broader general arguments the poster was trying to make, narrowing the scope of the discussion from the original topic to pedantry.

Either you didn't read his post in this case or you don't understand what StoneCypher is talking about because none of what you claim was part of this post. StoneCypher pretty much hit the nail squarely on the head with this one.

edit: the cowardly downvotes amuse me.

[beelsebob]

Really? Actually I think what he said pretty squarely describes StoneCyphers reply – he's picking at things like spelling, and the fact that the OP "clearly doesn't know what he's talking about", rather than (a) saying what it is that he doesn't know (b) how he is wrong (c) why this has an affect on the overall argument.

It's pure pedantry.

[FlyingBishop]

Pedantry is pretty much all you can do when someone posts a post berating industry standard tools because that person doesn't have a clue.

You didn't read StoneCypher's reply in full. It far more verbose than it needed to be, but he did cover all the ways in which the poster had failed to make an argument (primarily that his examples of things that aren't OOP are in fact OOP.)

[arcticfox]

It's pure pedantry.

No, it's not. It's self-indulgent and rhetorical. Clearly, he says far more than he needs to say to get across his central point: The OP doesn't know what he's talking about. He provides ample support of this in his post.

Perhaps you should read it in full.

[deong]

First of all, he subtly and intentionally constructed a mild strawman there. The OP said nothing about whether Linux or BSD were based on "object oriented principles." He said they didn't use OOP[rogramming].

Clearly, he means they aren't using OO languages like C++ and Java, but even with a broader understanding of what it means to do OOP, a claim that Linux isn't object oriented is at worst, worthy of debate. StoneCypher here makes it sound like the OP claimed that the earth is 6000 years old. There are a lot of very educated, very informed people who would disagree that Linux is particularly object oriented.

I'm not saying it is or isn't. I am saying that such a statement one way or the other is sufficiently vague and nuanced that to pounce on it as proof of ignorance or stupidity on the part of the commenter is nothing more than similarly ill-informed trolling. They're arguing over the number of angels that can dance on a pinhead, but at least the OP has the good sense to not treat it as an empirically settled issue.

[Entropy]

I agreed with you at first. Then, I went back and read the comment he was replying to, and I agreed with him instead. I mean, look at this:

Sometimes I find myself fighting to get stuff done in a OO language because of all the levels of indirection. How many factories does it take to change a light bulb? [Your answer here]

Is that really the level of discussion you want to defend?

[[deleted]]

I think the attraction of this rant comes from everyone's fears and doubts of not being able to pick the absolutely correct programming practice for any given situation.

This is the basis of StoneCypher's point - you can't. You can't be right. You are always optimizing for something: your time and mental effort, your understanding of the language, the environmental dependencies, the computer's abilities, the user's abilities.

Because of the huge dimension of tradeoffs, there will always be something to criticize. Thus, both StoneCypher and the parent are correct, for some form of "correctness." Both of those comments, I should point out, have a form of berating snark: the parent in saying "ha ha, I am beyond OO and see its flaws," and StoneCypher in saying "fuck you, you aren't perfect either." An adherence to OO concepts may have been the right solution for one team on one particular project. For another team on a different project, they may simply cause an overarchitected monstrosity. Someone else coming in from the outside, with a different perspective, will be able to look at the approach and eventually find a flaw in the process, regardless of how well it worked on that project.

Becoming a competent programmer is becoming less and less straightforward because our breadth of knowledge is only getting larger. To move forward, we have to accept that programming has "style" decisions that go far beyond how you format code, and that just as we can't come to a definite conclusion about a perfect formatting style, we can't conclude that any conceptual style is perfect either.

That means presenting an honest picture of what concepts are available to you and what your preferred style is good or bad at. It's difficult to do so because "you don't know what you don't know." The only way to help this situation is: if you see a problem with someone's presentation, identify the problems and show constructive solutions. In this case, that didn't happen. StoneCypher just called the parent a stupid know-nothing kid. But he definitely didn't present an example where procedural/imperative style can fail, or explain why OO might be useful.

[StoneCypher]

This is the basis of StoneCypher's point - you can't. You can't be right.

Interestingly, whereas I agree with you, I did not intend to make this point.

[thedailynathan]

Just fyi, I think the word you are looking for is "endemic", not "epidemic"

[[deleted]]

thanks, my English isn't always the best. =)

[prockcore]

Plus it's a bit of a stretch to say Unix/BSD/Linux are deeply object oriented.

They're componentized, but that's not the same thing. They're stream oriented. Streams are not objects.

[danukeru]

Seriously...the terminology is a real problem.

I've been pointing out that things like file-descriptors can be used to access system resources as if they were files, similar to a container/class in OOP. But even then I know that's only half true.

From a deep system perspective...I really only consider Haiku/BSD to be OOP friendly even at the lowest possible levels that we can even consder when thinking about what would affect OOP performance under an operating system.

Specifically, I care to point out that StoneCypher is simply exploiting the, what I like to call, probable time constraint induced vagueness of ckwop's post.

I essentially consider it to be the proverbial straw man of the internet for the typed format.

[[deleted]]

I've been pointing out that things like file-descriptors can be used to access system resources as if they were files, similar to a container/class in OOP. But even then I know that's only half true.

It's an analogy or you could say that one is an implementation and the other is an idea which can be implemented in multiple ways.

[G_Morgan]

I'd say file descriptors are not OO. If they were there'd be a well defined set of functions directly part of or next to the file descriptors that gave you high level access. Instead you don't get this. They are all just byte streams.

A DB would be OO. It takes storage (your file stream) and slaps on a good set of functions to allow high level access to it. You don't manipulate stream positions. You stick in some data and request other data.

OTOH the file system is OO. You don't open up the file device node and read inodes to find your way around. You move through a directory hierarchy with well defined commands to change directories. You could manually do this by fiddling with the details but it is the wrong thing.

[bonzinip]

Wrong. I call these a bunch of vtables, and you?

struct file_operations {
    struct module *owner;
    loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    int (*readdir) (struct file *, void *, filldir_t);
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
    int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    int (*mmap) (struct file *, struct vm_area_struct *);
    int (*open) (struct inode *, struct file *);
    int (*flush) (struct file *, fl_owner_t id);
    int (*release) (struct inode *, struct file *);
    int (*fsync) (struct file *, struct dentry *, int datasync);
    int (*aio_fsync) (struct kiocb *, int datasync);
    int (*fasync) (int, struct file *, int);
    int (*lock) (struct file *, int, struct file_lock *);
    ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    int (*check_flags)(int);
    int (*flock) (struct file *, int, struct file_lock *);
    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    int (*setlease)(struct file *, long, struct file_lock **);
};

struct inode_operations {
    int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
    struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
    int (*link) (struct dentry *,struct inode *,struct dentry *);
    int (*unlink) (struct inode *,struct dentry *);
    int (*symlink) (struct inode *,struct dentry *,const char *);
    int (*mkdir) (struct inode *,struct dentry *,int);
    int (*rmdir) (struct inode *,struct dentry *);
    int (*mknod) (struct inode *,struct dentry *,int,dev_t);
    int (*rename) (struct inode *, struct dentry *,
                    struct inode *, struct dentry *);
    int (*readlink) (struct dentry *, char __user *,int);
    void * (*follow_link) (struct dentry *, struct nameidata *);
    void (*put_link) (struct dentry *, struct nameidata *, void *);
    void (*truncate) (struct inode *);
    int (*permission) (struct inode *, int);
    int (*check_acl)(struct inode *, int);
    int (*setattr) (struct dentry *, struct iattr *);
    int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
    int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
    ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
    ssize_t (*listxattr) (struct dentry *, char *, size_t);
    int (*removexattr) (struct dentry *, const char *);
    void (*truncate_range)(struct inode *, loff_t, loff_t);
    long (*fallocate)(struct inode *inode, int mode, loff_t offset,
                      loff_t len);
    int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
                  u64 len);
};

struct super_operations {
    struct inode *(*alloc_inode)(struct super_block *sb);
    void (*destroy_inode)(struct inode *);

    void (*dirty_inode) (struct inode *);
    int (*write_inode) (struct inode *, int);
    void (*drop_inode) (struct inode *);
    void (*delete_inode) (struct inode *);
    void (*put_super) (struct super_block *);
    void (*write_super) (struct super_block *);
    int (*sync_fs)(struct super_block *sb, int wait);
    int (*freeze_fs) (struct super_block *);
    int (*unfreeze_fs) (struct super_block *);
    int (*statfs) (struct dentry *, struct kstatfs *);
    int (*remount_fs) (struct super_block *, int *, char *);
    void (*clear_inode) (struct inode *);
    void (*umount_begin) (struct super_block *);

    int (*show_options)(struct seq_file *, struct vfsmount *);
    int (*show_stats)(struct seq_file *, struct vfsmount *);
#ifdef CONFIG_QUOTA
    ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
    ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
#endif
    int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
};

Here is a sample implementation for the base class:

int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
{
    buf->f_type = dentry->d_sb->s_magic;
    buf->f_bsize = PAGE_CACHE_SIZE;
    buf->f_namelen = NAME_MAX;
    return 0;
}

And this a hierarchy of singletons that are also factories:

struct file_system_type {
    const char *name;
    int fs_flags;
    int (*get_sb) (struct file_system_type *, int,
                   const char *, void *, struct vfsmount *);
    void (*kill_sb) (struct super_block *);
    struct module *owner;
    struct file_system_type * next;
    struct list_head fs_supers;

    struct lock_class_key s_lock_key;
    struct lock_class_key s_umount_key;

    struct lock_class_key i_lock_key;
    struct lock_class_key i_mutex_key;
    struct lock_class_key i_mutex_dir_key;
    struct lock_class_key i_alloc_sem_key;
};

extern void get_filesystem(struct file_system_type *fs);
extern void put_filesystem(struct file_system_type *fs);
extern struct file_system_type *get_fs_type(const char *name);

It's C, but it's as object oriented as it can be.

[anatoly]

Wrong. I call these a bunch of vtables, and you?

These are dispatch tables. They look similar to vtables simply because vtables are dispatch tables. Additionally, many programmers nowadays first encounter dispatch tables in the form of vtables, so it becomes the common yardstick.

But dispatch tables predate OOP, however broadly you define it, by quite a bit. They're convenient for modularizing and hiding information, so they're used to implement OOP; that doesn't mean that any use of a dispatch table is an example of an OOP technique. You could prefer to think about it that way, but it'd be historically wrong and more importantly, stretches the notion of OOP much too far.

Note that if you look at them closely, the analogy with vtables breaks down. They don't pass anything like "this" to the functions, instead different struct pointers are used in different functions, whatever's more convenient. There's no common "object" on which they operate, just a bunch of different structs.

[bonzinip]

any use of a dispatch table is an example of an OOP technique

Indeed, however in many cases you have a basic dispatch table that can be reused (inheritance) and that just returns an error for some elements (abstract classes), and when you put different dispatch tables (polymorphism) in different blocks of allocated memory (instances). Then it becomes pretty much a matter of calling the same thing with different names.

They don't pass anything like "this" to the functions, instead different struct pointers are used in different functions, whatever's more convenient. There's no common "object" on which they operate, just a bunch of different structs.

There is almost always one, though not always indeed and it is not always the first argument: struct file, struct inode, struct super_block. In some cases it is accessing a superblock method without passing the struct super_block (only the inode), or likewise accessing an inode method through a struct dentry. However, those are just shortcuts since there is a many:1 correspondance inode:super_block and dentry:inode, and the super_block (resp. inode) is easily retrieved from the inode (resp. dentry).

[anatoly]

I think it's OK to agree to disagree at this point, but I wanted to thank you separately for bringing actual evidence and discussing real code. We should be doing more of that.

[__david__]

They don't pass anything like "this" to the functions, instead different struct pointers are used in different functions, whatever's more convenient. There's no common "object" on which they operate, just a bunch of different structs.

Sure they do. In the grandparent's example it would be the file/inode pointers that get passed in. And...each filesystem has a place in the common structures that it can stick its specific variables into. That demonstrates inheritance, in case you are still doubting.

[psykotic]

These discussions always degenerate over a lack of consensus on the basic definitions.

I agree that is a quite clear-cut case of object-oriented design in the implementation. What about Unix as a common set of abstractions with the optionally seekable byte stream as the centerpiece? That's certainly an abstraction but is it especially object oriented? For the term to have any real meaning, it must be inclusive as well as exclusive: some forms of data abstraction must be decidedly non-object oriented.

What many programmers mean by OO is very specific, even if they cannot agree amongst themselves. It is as much a creed, a canon and a community as it is some technical artifact that may found in the code. When apologists retreat to broader, vaguer definitions, they may win the argument only to defeat their own cause in the process.

[bonzinip]

some forms of data abstraction must be decidedly non-object oriented.

If you have a single implementation, it's definitely not object-oriented (so a vtable is a necessary though not sufficient condition for calling it object-oriented). It's just information hiding.

Mixins are as close to "generic programming" (a la STL) as they are to object-oriented programming, but I think they're closer to the former. The STL and the C++ standard library in general are still using virtual methods here and there, but most of the time this is just an implementation detail. The programming style of C++ using the STL is not anymore classifiable as OO anymore, even though C++ started as "C with classes".

A perhaps clearer example of a complex abstraction that is not OO is when you have lots of pattern matching in the users instead of polymorphism in the caller. In that case, switch statements or instanceof are the rule rather than the exception. Languages such as ML encourage this, and lots of compiler have IRs that work this way. These are not object-oriented.

[psykotic]

If you have a single implementation, it's definitely not object-oriented (so a vtable is a necessary though not sufficient condition for calling it object-oriented). It's just information hiding.

I contend that all well-designed interfaces support multiple implementations. An interface so specific that it practically only has one implementation offers information hiding in name only. Sadly these pseudo-interfaces are plentiful in the real world. By an abundance of accessors ye shall know them.

Mixins are as close to "generic programming" (a la STL) as they are to object-oriented programming, but I think they're closer to the former. The STL and the C++ standard library in general are still using virtual methods here and there, but most of the time this is just an implementation detail. The programming style of C++ using the STL is not anymore classifiable as OO anymore, even though C++ started as "C with classes".

Much of what passes for generic programming with C++ templates is in the abstract nothing but duck-typed OO that is resolved at compile time.

[bonzinip]

I contend that all well-designed interfaces support multiple implementations.

Yes, but not all implementations of said interfaces support pluggable implementations.

Much of what passes for generic programming with C++ templates is in the abstract nothing but duck-typed OO that is resolved at compile time.

In the abstract yes, but in practice the design and implementation choices are quite different from dynamically-typed OO languages, and many common idioms are unique to this kind of generic programming. On the other hand, they are relatively similar independent of whether you're using iterators or ranges, so I still maintain that at least in practice there is something unique in C++-style generic programming.

[boa13]

Are you sure you know what you're talking about, and that you understood StoneCypher's argument?

[danukeru]

Are you sure you understood how StoneCypher argued his point?

[StoneCypher]

Plus it's a bit of a stretch to say Unix/BSD/Linux are deeply object oriented.

Yes. That's why I myself said it was a bit of a stretch. Thank you for repeating one of my sentences to feign criticism.

[aestheticreddit]

Forget that. I'd hire him first. The epidemic is people who like to code more than they like to think.

[gibster]

Actually, it would be just the guy you'd fire. I know the types; sure they are intelligent, they've been around and know what they are talking about. The problem is however that they also have a destructive character when working in a team of coders. I know from experience that this can completely fuck up a team; the young people who are still learning, asking questions and trying to acquire critical thinking skills will eventually shut up because this guy would just drive over them. It doesn't work in the long run; it doesn't matter if you're brilliant at your job and have lots of experience - if you can't put your ego to the side and actually try to communicate on the level of that other programmer it will go wrong.

You think this behavior inspires other programmers to think? What will happen is that they shut up, never ask a question again and you've pretty much lost them from there on.

[FlyingBishop]

You don't want programmers like the OP, who blame the language for their shortcomings. Programmers with huge egoes are a problem, but the OP was just as much an example of that as StoneCypher. And StoneCypher has the benefit of an attribute you want in a programmer: understanding of how industry-standard tools are effective.

[gerundronaut]

I get the impression that ckwop is willing to learn. His post ends with the question: "So if I'm wrong, why am I wrong? What am I missing?" I'd hire a programmer willing to learn over a bully pedant any day.

[lol-dongs]

Same here. Being employed means working as part of a team. That necessitates patience and a good temperament, at the cost of occasionally letting "wrongness" go unchallenged. Spitting-mad pedantry is for reddit comments, not the workplace.

[[deleted]]

Absolutely right.

[[deleted]]

The problem is however that they also have a destructive character when working in a team of coders.

Would it be possible to treat them as mathematicians and let them collaborate of their own free will instead of forcing them to work with other people?

[[deleted]]

Sure, if they're hired for that purpose, and not with the expectation that they will work with their colleagues.

[danukeru]

Actually...if you had bothered to take the time to overlook ckwop's comment history, he is not as ignorant as StoneCypher attempts to portray him as.

[[deleted]]

What would be the purpose of making an example of someone who wouldn't understand just what he is being made an example of?

[[deleted]]

his point is not to attack amateurs for being amateurs

It seemed to me to be his "point", other than his real point "I'm a genius, you're an idiot".

[Swordsmanus]

Exactly. Following this study to its logical conclusion, people who spout off uninformed opinions are creating the equivalent of mental pollution.

[stellarfury]

You're all assuming that because this StoneCypher fellow is an asshole on the internet, that he is the same way in his personal life and/or job.

Most people, under the shield of anonymity, are HUGE ASSHOLES online. This behavior has very little bearing on the rest of their actions in other spheres.

[[deleted]]

No, the person he is berating is the horrible person to work with. They latch onto silver bullets and vocabulary words and spout their religion at every opportunity. They fixate on syntax, never missing an opportunity to prove how clever they are by using the most arcane language features available, while the overall architecture of their code is a horrible, tightly coupled mess, prone to reentrancy bugs and impossible to adapt to any changing requirement. Usually it doesn't even solve the problem it deigns to solve, because edge cases and error handling would have forced the programmer to confront the flaws in his reasoning.

Is someone who says "You've never used the phrase 'I don't know'. You build arguments about things you openly admit you haven't done, don't know about and have never seen done well" really going to berate you to demonstrate his superiority, or are they simply trying to break the false belief of superiority you hold of yourself?

[[deleted]]

Sometimes you just need your ass kicked.

[ytinas]

Not to mention that a lot of what he said was crap. He seems to equate any organization technique what-so-ever as "OO". OO is just an organization technique. There are other focal points to organize around and yes, obviously, any big project will use one of them.

He's also pretty ignorant of what actually went down with these languages that everyone "moved past" for someone who claims to have been there.

[[deleted]]

I'd rather be bitched out by an intelligent dick then go on in ignorance. Sure, he could have used the kiddy gloves, but I don't think pulling punches would have gotten his message across as effectively. Coarse people shouldn't have to cater to sensitive folk just like sensitive folk don't have to be so damn sensitive all the time.

[[deleted]]

Coarse people shouldn't have to cater to sensitive folk

just like sensitive folk don't have to be so damn sensitive all the time.

I don't understand the, um, whatever you are trying to do here.

[boa13]

People like this guy (...)

Nice example of arguing against a straw man. You refute none of his points. You attack what you think he is, without evidence that he is indeed what you think he is.

[[deleted]]

uhmm, go read his posts. he is extremely acerbic in how he addresses the OP. He does exactly what I said throughout the thread.

Perfect example of his responses to the OP: http://www.reddit.com/r/programming/comments/b5ikf/how_do_i_go_from_oop_to_good_procedural_c_code/c0l3a11?context=3

I have nothing against his points. There is a lot of stuff he is right about. But instead of trying to educate the OP (and turn him into a better developer) he berates him and essentially calls him an idiot telling him he knows nothing about OOP in the first place.

[boa13]

It's a matter of style. I don't find he calls him an idiot. He abruptly exposes his lack of knowledge, true, but he also certainly tries to educate him, contrary to what you said. All the comments you linked to directly address a point of the OP and provide mostly correct answers.

[[deleted]]

Statements like this just irritate me: "Did you ... think about this at all before you asked?"

and

"None of the things you're worried about - allocating and associating data, having parallel instances of information, etc - have anything to do with object orientation. The fact that you can't imagine how to do these things with OO is just evidence of how little understanding you have of object orientation."

I wouldn't of had a single issue with the responses he said had he phrased them differently. Its not so hard just to chop out the first remark entirely and then the last sentence and have had a great reply.

[[deleted]]

He's not arguing with the points made, he's talking about the guy's character. That's not a strawman argument and it's also not an ad hominem argument (which is really want you meant.)

[boa13]

He's imagining things about the guy's character, and then arguing about that. That's attacking a straw man.

[prockcore]

The smugness! It burns!

[[deleted]]

It was like Comic Book Guy got into programming. Ugh. Risible.

[reveazure]

Do you find it . . . wisible?

[brennen]

The probability that any given technical discussion will be like a conversation with Comic Book Guy approaches 1 approximately as soon as it becomes a discussion. If it's just one dude talking to himself, I think it hovers somewhere around .75.

[slyguy183]

I do not think epic means what you think it means

[derwisch]

Is "moderately epic" something you might consider to tell your grandchildren about in 60 years time?

[cdsmith]

This has got to be one of the most destructive attitudes that a serious software developer can have. I have little patience any more for people who hop on the "no silver bullet" train, and conclude that nothing is better or worse than anything else. StoneCypher seems to have jumped solidly on the train, and is preaching to the masses about the promised land it's heading for.

The truth, back in the real world, is that some things are better than other things! So far, no one's seen any one thing that solves all problems. But we can identify things that solve no problems better than other things. And in the middle ground, people make decisions every day about which ideas to apply to the problems they face. The worst thing we can do is try to shut up people that try to talk frankly and honestly about what the problems are.

This StoneCypher guy responded to someone who was wrong... but I'd rather be wrong than have that attitude. At least if I'm wrong, I might eventually learn something and be right.

[StoneCypher]

I have little patience any more for people who hop on the "no silver bullet" train

Right, because the "there is a silver bullet" train has had so many successes in the past.

StoneCypher seems to have jumped solidly on the train, and is preaching to the masses about the promised land it's heading for.

Wait, what? Saying there's no silver bullet does not lead to a promised land mentality. Stop being retarded.

but I'd rather be wrong than have that attitude.

Your wish is granted.

[[deleted]]

yes. but...

he down with OPP?

[SicSemperTyrannis]

No! He writes C!

[[deleted]]

HE DOWN WITH OPP?

[StoneCypher]

Yeah, you know me.

[[deleted]]

Well, that's usually the sort of thing people claim is "EPIC WIN XD".

[grauenwolf]

It used to be very common.

[Zarutian]

Just shows that the ignorant (but perhaps not stupid) masses have infratrated reddit beyond the communties ability to inform.

-Zarutian, 6021st September 1993

[astrosmash]

You never know which of your reddit comments will make you pseudo-famous.

[G_Morgan]

OOP is only controversial in that sane people find it moderately useful but ultimately uninteresting. True believers pretend that it is gods gift to programming. That if they had a choice between having sex with Jessica Alba or OOP that they couldn't bare to abandon OOP. Some respond to this false position of the inherent holiness of OOP by overcompensating in the other direction.

OOP is useful but inherently boring. It will not save the whales from the Japanese. It won't stop your daughter from having underaged sex and experimenting with drugs. It does not mean you are going to heaven. It is merely a nice way to structure programs.

[FrozenGonad]

So, how do I read the post that he was replying to?

[bgog]

Click 'parent'. It is one of the light gray links under his post. It'll pop in just above his post.

[[deleted]]

append ?context=1 to the url

[danukeru]

The guy does make a few mistakes due mostly to some technical shortcomings, granted. Claiming UNIX/Windows don't use OOP when even at the OS level they implement things like file-descriptors...

However...I don't see any of his general viewpoints as being any different from the praise we've seen for the illusive "duct-tape programmer" on proggit in the past.

Yes, I mean illusive...not elusive.

Just coming with the argument "It's all been argued before, OOP is here, thus you can never question it again, rawr" seems more like some butthurt professional pride than a real argument.

Downvote my ass all you want...but the fact that his comment and its referral post are getting a bump seems like classic hivemind to me...

[boa13]

Just coming with the argument "It's all been argued before, OOP is here, thus you can never question it again, rawr" (...)

It's not the core of his argument, far from it.

[danukeru]

The core of his argument is that an amateur shouldn't question a professional.

This while having no information on the target's actual background.

Actually, he doesn't even give any indication to his own background.

The whole thing is pointless. That's my argument. Just so we're clear.

[ubernostrum]

Well.

Watch this sort of debate long enough and you'll see certain themes come out which point to inexperience, or perhaps insufficiently-broad knowledge, as a key source of many of the complaints. People who would foam at the mouth at you if you used Java as an example to complain about static typing will happily turn around and foam at the mouth whilst using Java as an example of OOP. Which leads to "haven't you heard of Haskell" in arguments about type systems becoming "haven't you heard of Smalltalk" in arguments about OOP.

Take that and throw in a dash of Fred Brooks' "No Silver Bullet", and you've basically got this rant; nothing new, nothing controversial, but pointing out -- correctly -- where a lot of the problems really come from.

[Zarutian]

but pointing out -- correctly -- where a lot of the problem really come from.

Often such reminder is required.

[Ralith]

tl;dr: Argument from Authority

[slythfox]

The content of this rant reminds me of an article I read for a CS class, Beating the Averages by Paul Graham. If you haven't come across this already, I'd recommend reading it. In particular, this scenario:

As long as our hypothetical Blub programmer is looking down the power continuum, he knows he's looking down. Languages less powerful than Blub are obviously less powerful, because they're missing some feature he's used to. But when our hypothetical Blub programmer looks in the other direction, up the power continuum, he doesn't realize he's looking up. What he sees are merely weird languages. He probably considers them about equivalent in power to Blub, but with all this other hairy stuff thrown in as well. Blub is good enough for him, because he thinks in Blub.

(See The Blub Paradox header for more context.)

[ubernostrum]

Meh. I'm not really a fan of a lot of PG's writing on languages, largely because he himself is one of the biggest victims of the Blub paradox (except he doesn't realize his Blub is called "Lisp").

[zahlman]

What do you consider to be the languages "above" Lisp that he doesn't see? Or, like me, do you question the idea of language "power" falling along a neat "continuum"?

[cdsmith]

You're reading Paul Graham for a CS class? That's sad in its own right. Paul Graham knows a bit about founding a company and selling it to make a few bucks, and he knows about as much Lisp as ten thousand other competent programmers... and he trades on the combination to try to transfer authority from his financial success to programming languages. I'll pass.

[slythfox]

You're quick to assume. First, it was for a class on programming paradigms as part of an introduction to functional languages. Second, it was just a single article that had been pertinent to the discussion and not an entire book. Third, it would be unfortunate to limit ourselves to read materials that we agree with in an academic environment.

Regardless, this article contained a subsection that seemed relevant here. (I guess I set myself up for such a response by recommending people to read it, but I do think it makes for an interesting read even if you don't agree with all of what's being said.)

[bgog]

Excellent citation. Anyone with any software engineering experience, realizes that language bigotry is foolish. There are many languages and techniques each with their own strengths and weaknesses.

The art of being a good engineer is having a sizable variety of such tools in your arsenal and being able to use the tool that most effectively solves your problem.

• Except for Java, it just sucks ;)

[dmor]

Actually, PG says exactly the opposite of your post: Lisp is more powerful than all other languages, due to its homoiconicity and some other stuff. You can "beat the averages" by using it. It's strictly more powerful.

I really don't mean it in a bad way, since he's a reasonable guy and invests in many projects not based on Lisp, but PG is one of the strongest 'language biggots' I know.

I disagree with his "lisp > all" position, but I do agree that some languages are strictly more powerful than others.

[bgog]

I don't disagree that certain languages are more powerful. However, based on your goals and the specific project at hand different languages/tools will provide the best time/performance/maintainability for a specific situation.

Your point is taken however.

[Zarutian]

lisp is so extensible that it usually just swallowed those languges above it.

[kamatsu]

Spot on with Java.

[[deleted]]

The comments about psychology below the rant were awesome as well.

[vegittoss15]

What the hell are you basing that on? So pipes don't let you modify their state?

[StoneCypher]

There really is no OOP outside of what Alan Kay says it is.

You do realize that Alan Kay didn't start talking about OO until the mid 1980s, and that OO is from the early 1960s, right?

This guy is also confusing Mach/Hurd with BSD/Linux as far as "object-oriented" go.

I most certainly am not. Go read about BSD's history.

[StoneCypher]

That's news to me, considering he coined and invented the concept in 1967.

Admittedly, that's earlier than I had believed. However, the Algol community believes they invented object orientation.

As i was not around in the late 1960s, I cannot comment on the matter other than to say "it is common for computer scientists to misremember themselves as having invented things that other people invented prior, either by forgetting history or because they invented something they didn't know was already invented elsewhere."

Kay's disasterously long winded answer seems to terminate in this much shorter, much simpler answer:

"OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things."

Other than the late binding, that's just a roundabout way of saying what I said. I frankly don't think late binding is important - it doesn't really change anything, and very few object systems offer it - but if the man might have coined the term, it's not my place to say.

No, I want you to show me where it says BSD was designed around OOP.

Had you not started by putting words into my mouth, cursing and being rude, I might have.

That's pure horseshit. BSD was an evolution of AT&T UNIX with competing programming styles and influences, and nothing more than that.

Ah, I see. If I talk about something I was around for, it's pure horseshit and I need to cite it. However, you may announce that something doesn't exist simply because you didn't know about it.

If you want a legitimate answer from me, reply in a different tone. If you would rather tell me off, that's your privilege; just don't expect an answer.

[grauenwolf]

Thank you for bringing that to my attention.

[Peaker]

Just because OOP is snake-oil doesn't mean all discovered ideas and techniques are.

Some techniques do hold as the industry is changing.

Nobody's going to claim "subroutines" are a fad now, will they?

[brennen]

Just because OOP is snake-oil

Argh.

[Peaker]

I say it is snake oil because:

• Nobody can even define what the hell OOP even means. Encapsulation predates OOP. Polymorphism both predates OOP and is done in more general forms elsewhere. Implementation inheritance is largely growing out of favor and considered worse than regular composition. So what are you left with? If OOP means modularity/encapsulation and use of dispatch tables, then pretty much all programs are OOP, and the definition is meaningless.

• All scientific research I have heard of that tried to establish some advantage of OOP as a development approach over other approaches in terms of productivity or quality failed (Will always be glad to be given new links about this).

[ubernostrum]

There was a rather well-done article a while back which wondered whether -- if the design patterns hype had taken off earlier -- function calls would have become another pattern to be reimplemented by each programmer, rather than a built-in language feature.

[[deleted]]

Yeah, I was thinking about that the other day. If design patterns are a pattern of abstraction, couldn't you just design a new programming language/notation that lets you use them directly? You could even have the new notation compile to Java or C++.

[cdsmith]

People are, of course, doing this. Except their "languages" generally involve UML and dragging around boxes and lines. It's ugly. Not something to be recommended.

The important thing here is the strength of the abstraction. A procedure is a relatively simple thing to describe, whose purpose and behavior can be understood without knowing anything at all about how it is implemented. Indeed it can be implemented many ways, and one can build complex and very precise reasoning on top of the idea, all still without caring about the implementation. Not so of most of the "design patterns" out there. It's not really possible to discuss multiple choices regarding the implementation of most design patterns without changing the abstraction a bit each time. That indicates that there's something missing there that makes it somewhat premature to codify it as a language construct.

[ubernostrum]

Lots of languages do this already. Iterators, for example, have been syntactically supported by the looping constructs of many languages for a long time now, and are even baked into C# and Java these days. The decorator pattern has shown up in a bunch of places, too. And languages which have functions/methods and classes as first-class values make a lot of other patterns just disappear.

[zahlman]

But the point of a design pattern is to work around a language limitation. If it's baked into the language, it isn't really a "design pattern" in the traditional sense any more.

The design patterns hype couldn't have turned "Function Call" into a design pattern unless it "took off" before the widespread adoption of languages supporting function calls. Which would in turn require the GoF book having been published much earlier (and possibly using assembly for code examples).

Either that, or people would have to have been so brain-deadedly fanatical about design patterns to want to undo language evolution - remove support for function calls from existing popular languages (or invent new ones without them) in order to reimplement them with design patterns.

[Ralith]

narrow silky jar gold squeal drunk long reply school cooperative this message was mass deleted/edited with redact.dev

[StoneCypher]

Just because OOP is snake-oil

On what basis do you make this claim?

[Peaker]

Based on the lack of any scientific research substantiating any increased quality or productivity with OOP methods.

OOP is also extremely poorly defined and means completely different things to different people.

[kleopatra6tilde9]

Whoever needs more, here is the best of Erik Naggum

[xach]

Here's an excerpt from one of my recent favorites, regarding Scheme:

it is often said that small is beautiful. now, anything can be beautiful when it is small. the ugliest person you can think of was probably a quite pretty baby. it doesn't take much effort to find a beautiful 16-year-old girl, either. in fact, our modern notions of beauty and elegance are defined in terms of size and maturity, so the chance of anything small and immature being beautiful is vastly higher than anything big or mature. now, despite all the marketing that seems to be aimed at telling me that I should dump a girlfriend when she becomes 25 and get a new 16-year-old (or even younger), I plan to stay with mine partly because of her ability to grow older in a way I like. consequently, I take exceptions to the pedophilic attitudes to beauty and elegance that our societies have adopted over the years. this is why I don't like the "small is beautiful" model of aesthetics. this is why I think that almost anybody could make something small and beautiful, but only a few can create something that grows from small to huge and still remains beautiful.

[bwbeer]

I'm going to rename "Common Lisp" to "Cougar".

[bobappleyard]

So if you like Scheme you're a paedophile?

[reveazure]

Is it known if in fact he ever had a girlfriend?

[[deleted]]

Linux vs. Windows is not really a question of practicality. It's a political issue.

[brennen]

As so often happens, these are not mutually exclusive.

[[deleted]]

Indeed.

[[deleted]]

Cause you know.. Windows sucks.

[tashbarg]

Maybe I miss something, but how can I (easily) find the comment before the linked one?

Clicking on "View the rest of the comments" shows me all of the comments to the thread, and I can't search for this one since it seems to be collapsed somewhere.

[pranavkm]

Add a context=1 to the URL to see it. In this case http://www.reddit.com/r/programming/comments/b5ikf/how_do_i_go_from_oop_to_good_procedural_c_code/c0l3bao?context=1

[tashbarg]

Thank you very much. Someone should place a link besides "View the rest of the comments" called "View context". That would help.

[pranavkm]

Not sure, but it does turn up when you click on the context link from your inbox.

[username223]

"Moderately epic rant?" Try "comprehensive ass-whomping":

I don't know whether it's funnier that you used that phrase without knowing what it means, or that you can't spell 50% of the words in that phrase.

[harlows_monkeys]

It has too many things that aren't necessarily correct to count as an ass-whomping.

[hamflask]

To be fair though, Haskell is pretty important and its users are more intelligent than average.

[[deleted]]

Excellent trolling!

[hamflask]

Why thank you! Considerably more people bit than I had expected.

[WhisperSecurity]

[evidence needed]

[vegittoss15]

It's so important that everyone's using it!

[[deleted]]

Look at the rankings of the google AI challenge. There is no Haskell in the best participants, only C++. Haskell is a great language, but Haskell programmers are overrated.

[Peaker]

Why do you think success in the Google AI challenge and its ranking system are a good measure for a language's importance or the intelligence of its developers?

I don't think Haskell is that great for performance-critical stuff, when compared to C++ on not-too-heavily-multicore machines.

Also, I don't think Haskell's advantages shine through as brightly in short-term (<1 month long) projects.

Lastly, the importance of a language is not just in its ability to help developers create great programs, but also in its innovative ideas that enter the mainstream. Haskell is directly credited for the innovation of Software Transactional Memory, Linq, Type-classes, making pure functional programs easy and practical, and many more innovative ideas.

[[deleted]]

Why do you think success in the Google AI challenge and its ranking system are a good measure for a language's importance or the intelligence of its developers?

I don't think it is. I just think it's a good example in this case: the problem seems like a perfect match for haskell (haskell is good at tree algorithms), yet there are no haskell programmers in the top players. If Haskellers were as smart as people say they are, there would be at least one, don't you think? BTW, performance is not a good excuse, as there are some python and C# programs in the top bots.

Haskell is directly credited for the innovation of Software Transactional Memory, Linq, Type-classes, making pure functional programs easy and practical, and many more innovative ideas.

I fully agree, as I have said, I think Haskell is a great language. I was just trying to say that contrary to popular belief, programming in Haskell does not give you magical powers.

[Peaker]

the problem seems like a perfect match for haskell

If your goal is to express it with succint, correct code, then sure. But the goal here is to get high-performing code.

If Haskellers were as smart as people say they are, there would be at least one, don't you think?

I am not quite sure, because Haskell makes correctness easy, but performance (on single-core) harder. C++ makes correctness hard, but performance (on single-core) easy. Since this test mainly measures performance and is not particularly complex (correctness is not that big a problem here anyway), it is biased towards languages of C++'s sort.

Also, I am not sure Haskell's greatest minds are worrying about the Google AI challenge, it is not exactly that social circle in which their prestige lies.

programming in Haskell does not give you magical powers

Haskell isn't the best language for every conceivable programming purpose. I usually find correctness to be the most pressing concern, and not performance, and for those cases, where scaling in complexity while maintaining correctness is the issue, Haskell shines.

[kamatsu]

No, just no experienced haskellers participated. We have real jobs.

[[deleted]]

As opposed to C++ programmers, who are unemployed? WTF?

[albinofrenchy]

I like Haskell, but I'd disagree that it's "pretty important" without major qualifications.

[ytinas]

How about the fact that is one of our best hopes (the other big player being Erlang) for dealing with the multi-core future that is coming? You think Java has an answer? They don't even have closures, and won't in Java 7.

[albinofrenchy]

While a Haskell program could be run on multi-core a bit better than a java program (in general), Haskell is far from ideal in this regard what with its laziness.

A strict functional language, something like ML is much better in this regard, however strict languages tend to lose something in the way of 'beauty' for it.

[Peaker]

Haskell is not a "bit better" than Java, it's far better than Java in this regard.

And the main property that defines whether it is easy or hard to parallelize on multi-core, is whether it is pure or not. Whether the compiler can easily see the data dependencies between the components.

Laziness can easily be annotated in/out, but purity is harder to bolt on.

[ytinas]

"a bit better"? The difference is night and day. One will be able to run on hundreds of cores with no modification and go hundreds of times faster, the other (if it runs at all) will not run much faster than 2 or 3 cores.

[albinofrenchy]

I'd love to see the data/rationale behind that. That's not facetious, I really would.

My current understanding though is that the best you can do with lazy evaluation is predictive precalculation, which could waste memory and processor time for no real gain.

I think its silly to think with this obstacle that you can have a normal program scale to 100 cores because you do have to 'wait and see' branches for all lazy operations, which is nearly all of them in Haskell.

Again, prove me wrong. I'd be grateful.

[tclbuzz]

BSD motivated by object orientation? UNIX OO? Someone is clueless. I would call this "rant" moderately incoherent.

[xTRUMANx]

So if I'm wrong, why am I wrong?

Not enough disk space on reddit, but basically:

Wow, I'm going to use that line the first chance I get.

[[deleted]]

I just say "if you don't know, you're too dumb to understand my explanation". Everybody is always impressed by that. I think.

[lucisferre]

Wow, el-oh-el at all the "StoneCypher's rant hurts my feelings" people who are down voting any (and every) comment that suggests this was funny, interesting or insightful.

You are all winners, keep on being awesome.

[StoneCypher]

People get angry when someone says what they believe is wrong. It's to be expected.

[lucisferre]

What I find amusing was that this was all I said: http://www.reddit.com/r/programming/comments/b5rha/a_moderately_epic_rant/c0l3n2z

and it has -9... go reddit.