The Artima Developer Community
Sponsored Link

Weblogs Forum
The departure of the hyper-enthusiasts

262 replies on 18 pages. Most recent reply: Dec 20, 2006 2:11 PM by Carlos Neves

Welcome Guest
  Sign In

Go back to the topic listing  Back to Topic List Click to reply to this topic  Reply to this Topic Click to search messages in this forum  Search Forum Click for a threaded view of the topic  Threaded View   
Previous Topic   Next Topic
Flat View: This topic has 262 replies on 18 pages [ « | 1 ... 10 11 12 13 14 15 16 17 18 | » ]
Jim Shi

Posts: 7
Nickname: jim2000
Registered: May, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 12:08 AM
Reply to this message Reply
Advertisement
The methods in Perl, JavaScript, Python, etc are really
stand-along 'global' functions, whereas in Java,
(instance) methods are attached to their objects and can't be called without instance objects.

You can pass *anything* to first argument in methods of Perl, JavaScript, Python etc if you like, while this is impossible in Java.

This is not to Say Perl etc are better languages
than Java. Java is just more retricted and force you to
do things in decipline. The payoff are greater when you have a larger project.

> >
> http://zephyrfalcon.org/weblog/arch_d7_2003_07_12.html#e284
>
> >
> > Shows how Python was designed as an OO language from
> the
> > beginning. Version 1.0 supported classes, virtually the
> > same as they appear today.
>
> Fair enough, Bruce, I stand corrected.
>
> I still don't understand why self was made mandatory,
> though. I used to think that backward compatibility was
> the reason, but now I'm completely at a loss. The only
> reason I can think of is that this is how we emulated
> classes in C (passing a pointer to this to the function)
> but C++ was already fairly established by then, so it's
> not as if it was a brand new technique.
>
> Also, I'm still bothered by the fact that you declare a
> method with n arguments (self being the first one) but
> invoke it with n-1 arguments.
>
> I also dislike how crowded the code becomes when you read
> "self" everywhere, which is very non-pythonic. I like
> significant space indenting for that reason (it saves you
> from all these "end" keywords that I dislike in Ruby) but
> the omnipresence of self ruins a lot for me.
>
> --
> Cedric

Joao Pedrosa

Posts: 114
Nickname: dewd
Registered: Dec, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 12:16 AM
Reply to this message Reply
"Is it a waste of time to spend 10 times longer to recreate something just because you don't want to spend the time to make it work/port it?
This is strangely close to the not-invented-here syndrome."

Indeed. You are right. It feels good to recreat things. Maybe JDBC 1, 2, 3, EJB 1, 2, 3, Java 1, 5, 6, JSF, JSP, etc, are not being recreated all the time. Java is a moving specification, just like me and my tools -- you blink and another open source tool appears.

Alex Martelli

Posts: 8
Nickname: aleaxit
Registered: Dec, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 1:18 AM
Reply to this message Reply
> both Ruby and Python pretty well. I know that for many
> things, for me, there is a big difference between Python
> and Ruby.

So, why not show them to us, these many things where the difference doesn't boil down to syntax sugar, instead of attacking those who, having investigated to the best of their abilities, haven't found them? Do they have to do with modifying built-ins, using blocks as coroutines, or what else?

You can't expect anybody to read your mind. I haven't found these many important examples throughout two editions of the excellent Pragmatic Programmers' book, nor in my frequentation of comp.lang.ruby, so they can hardly be *obvious*. You have already shown us that you're good at making enemies (I do assure you that you've made at least one, me: and if you are at all representative of the Ruby community, then my position towards Ruby must shift from one of sympathy and interest to intense enmity, too); show us that you're as good at actually SHOWING your points, will you?

> I feel a need to set straight some misconceptions. Quotes

You've certainly set straight MY previous misconception that the Ruby community was composed mostly of sensible people, assuming you're at all representative of it.

> be tolerant with Python and Java folks who 'investigate'
> Ruby and come back to say, ahh, it's a wash, not much
> interesting, syntactic sugar, blah, blah. If it was all

Don't be an idiot, or, if you can't help that, try not to SHOW it so badly. Anybody claiming that the difference between a statically typed language and a dynamically typed one is essentially "syntactic sugar" would of course be laughed out of court: you can't quote any "Java folk" claiming THAT on this thread, so this sentence implicating that this has happened is OVERTLY cretinous.

> simply equivalence and syntactic sugar, then Python
> wouldn't be chasing down features that are very useful in
> Ruby.

If you had bothered to read the various posts I made on Python and Ruby, instead of just coming out swinging for the sole purpose of makign sworn enemies, you would have noticed that I _have_ made the point that obviously the consensus on python-dev must be that using blocks as coroutines can be useful; otherwise, we wouldn't have an approved PEP to enrich generators with features useful for that very purpose (to some extent it IS still syntax sugar, since generators are quite analogous to iterator classes, but the amount of boilerplate differs by enough to make it "substantial"). I am not aware of other language features being similarly "chased down", but since you've chosen to use a plural I'm sure you'll be glad to share your superior knowledge with us.


> And if you insist on treating people who find compelling
> reasons to use a different language as if they lack
> substance or are just misguided or just wanting to be
> 'cool', then don't whine when you receive a figurative
> slap in the face; you asked for it.

I insist on forming my own opinion, and on freely sharing it when publically asked to by a friend; and if that opinion is that two languages are extremely close, with almost nothing but syntax (except of course all sort of possible pragmatical issues, tied to implementation, community, libraries, etc, not to the languages proper) to guide one's choice, I further insist on being able to express that opinion as my answer to my friend without any would-be tyrant feeling enabled to decide that this means "I asked for" any beating, figurative or otherwise.

I would like to hear from other people who consider themselves to be in the Ruby community as to whether you're an isolated, shunned freak, or a well accepted, representative member of that community. That will help me (and other readers of this exchange) decide whether it's you, in particular, who are just a terrible, possibly dangerous individual, or, rather, whether it's Ruby as a whole which, net of technical considerations, should be entirely avoided in order to eschew the risks of entanglement with a horde of crazed face-slapping zealots. I'm listening, and I'm sure I'm not the only one, but, even if it was just me...:

Perhaps in the near-mid term future somebody will request my opinion (people often do, even though I'm now an employee, not a consultant any more), and what I say will determine whether a given project will be given the go-ahead to proceed with Ruby, or not. Before I suffered this unbelievable attack, my opinion would most likely have been mildly favorable, as is easily ascertained by studying all my posts on the issue (with more weight on recent than on ancient ones, as I have explained). Right now, given the doubt that this attacker IS representative of Rubyists in general, I would of course be otherwise inclined. But I always keep listening (which may be why I am so frequently asked to express my opinion, and why many appear to hold that opinion in high regard), so both technical points, and ones about the connection between this attacker and the community, will matter to any opinions that I may be asked to express in the future -- so, thanks in advance to any who want to offer such input.


Alex

Brian Ford

Posts: 153
Nickname: brixen
Registered: Dec, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 2:00 AM
Reply to this message Reply
Alex,

Eeks, would it be that I really slapped you in the face. It was a figure of speech, not a real deed. Poor fella, he must really be smarting.

I don't make any claim to being a representative of the entire Ruby community; that's preposterous.

To say that you may now recommend unfavorably to Ruby because you don't like how I talk to you, is well, just plain cretinous. Really, you give me far too much sway over your wibbly opinions; and that statement sounds really stupid.

I do apologize for putting a wrinkle in your day.


These are things that I find compelling reasons to use Ruby:

1. Classes: open; single inheritance; mix-ins; class methods; singletons; singleton methods; class methods, class_eval; instance_eval. (I'm sure I'm forgetting some aspects, but these are all fantastic. and yes, I know, Python has something like class methods, and for me, decorator syntax is ugly)
2. Blocks and closures
3. Conditional modifiers: print 'yes!' if you_like_ruby unless you_are_grumpy
4. Optional parentheses
5. 'end' closes a "block" (not a Block in 2 above but a block of statements/expressions). Far from being cumbersome or litering code, like self in Python, this 'end' provides a psychological closure, which gestalt psychology has shown to be very important for the way the human brain creates meaning. If you want to understand closure, think about the saying, 'waiting for the other shoe to drop'.
6. No syntatically significant white space. Usually this is not a problem for me in Python, but I don't like it and no one will ever convince me it's a good thing. I have had it bite me, like when programming Python scripts in Zope, and it's just an annoyance I don't like to deal with
7. Libraries have been implemented from the beginning using blocks. Iterators and generators are basic concepts, not add-ons. I generally find the core libraries to be more elegant in Ruby. In Python the C origin usually shines through pretty clearly.
8. There is not necessarily 'one right way' to do something. I really don't like a dumb computer language to act as if it knows better than I do. Of course, there is often a 'better way', but hang out a bit on the python list and you will see it is hardly so clear. A recent example: Guido wants to remove map, lambda et al, and impose list comprehensions as the 'one right way' even though a number of people wrote and said they are very useful to them and would hate to see them go.

There are many reasons why I find Ruby to be more elegant and simpler to understand and use than Python. You won't find me calling Python folks hyper-enthusiasts or making other disparaging remarks. I may say you should know what you're talking about, but so what? You should!

I'm pleased to know that Bruce is a friend of yours. Perhaps he'll listen to you. If you're such a nice guy, why don't you admonish your friend for rudely treating people who think Ruby and Rails are great by arrogantly dismissing them as hyper-enthusiasts.

And, since your last emotional post sounded pretty dense, I must again include a disclaimer: I don't speak for the Ruby community. Hopefully the community as a whole tries to emulate Matz a bit as he is very humble and kind. I have a lot of trouble being humble, especially when people like Bruce like to slap on labels like hyper-enthusiast. I'd rather tell them chinga su madre.

So, grow up Alex. If you have so many people seeking out your opinion, then be cautious when you give it and accept that you won't always be popular. Even if my treatment of you is unfair, as an adult you just learn to deal with it. You don't say ridiculous things like, 'that mean guy with a red hat pissed in my cheerios, now I don't think I can trust anybody with a red hat'. *roll eyes*

Dan Shafer

Posts: 3
Nickname: dshafer
Registered: Dec, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 2:48 AM
Reply to this message Reply
As a programming language junkie, who like early poster Mike Pence has more background as a writer than a programmer but considers himself both, this has been a fascinating and largely informative discussion. I appreciate Bruce's insight in starting it and the contributions of many who have stayed more or less on topic and enlightened me in many ways.

For me, the choice of a programming language for a particular task comes down to three decisions. More or less in rank order, these are:

1. Familiarity
2. Suitability
3. Personal Taste

Note that I said "for a particular task." There is no one perfect programming language. The task at hand must be considered. Religious wars over languages almost always omit that fact, as this thread basically has. That's OK but it does narrow the usefulness of conclusions for me.

As I examine the problem, then, I try to mentally list the languages with which I have some degree of comfort or familiarity (perhaps expertise is a better word) that would be candidates for solving the problem set. It may even require the use of more than one language.

Next, I look at each candidate language and ask myself how well suited it is to solving the particular problem set. I may seek out the opinions of others more knowledgeable either in the domain or in the language as part of that process.

Finally, unless the first two steps yield an obvious choice (which they seldom do in my experience), I make a choice based on taste. My personal taste has a preference for languages that are dynamic rather than static, object oriented rather than procedural, syntactically clean (the more like writing English they are than programming, the happier I am), and with strong graphical IDEs so that I don't have to hand-code UI elements.

For some time, I devoted a lot of energy to Python and Zope. I was never really able to feel like I'd mastered them. In part, I think, that's the fault of Zope more than Python. But I don't look for things to blame, I just recognize that reality. I'm a Ruby Nuby but I'm already quite impressed by and taken with Rails as a real-world solution to two problems on which I'm now working. I'm learning Ruby and I like what I'm seeing. (And I am a Smalltalk refugee so that won't surprise at least some of you.) So I am quite likely at this point to become a Ruby/Rails kinda developer for a while. This despite the availability of an even close-to-decent graphical IDE. (I'm probably going to create my own private code-generator using a tool that would probably only draw great disdain here, <a href="http://www.runrev.com">Revolution</a>.)

Does that mean I think Ruby is "better" than Python? Nope. It just means that, at least for now, it seems to me more comfortable to my particular taste.

To each his/her/its own.

Angsuman Chakraborty

Posts: 19816
Nickname: angsuman
Registered: Dec, 2003

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 3:18 AM
Reply to this message Reply
I very much enjoyed your article.

I have gone through Ruby and RoR. I couldn't find significant business or development advantage to jump ship. In fact the hype is rather surprising and potentially indicates immaturity of the crowd.

I would rather use PHP or Python instead of Ruby any day.

Gregg Wonderly

Posts: 317
Nickname: greggwon
Registered: Apr, 2003

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 8:45 AM
Reply to this message Reply
> > > Just so we're clear, a type to me is a set of values
> > and
> > > operations on those values.
> >
> > Yes, and that implies a contract which should be
> checked
> > and validated as early in the runtime of the
> application
> > as possible. Compile time static type checking is just an
> > earlier validation of the contract that makes it easier to
> > feel comfortable about what will happen at runtime.
>
> If you don't already know this, you won't likely benefit
> from me explaining it in depth: the type-checking the
> compiler can do is extremely limited. Therefore,
> the onus is on you again to demonstrate why the baggage
> that comes with static typing is outweighed by this
> very limited benefit.

I designed and utilized a dynamic language of my own to build a procedure control system. The number one issue that we dealt with was type based test analysis. Second was code path/coverage analysis. I provided a coverage generation dump at VM exit. The analysis data was tied to each class and would be reloaded on the next run. So, at the end of a 4 hour procedure run, we had coverage data that demonstrated which legs of code we had an had not tested. We could devise new tests or do visual walk throughs to provide 100% coverage.

The predominate contributor to type problems was lack of documentation that was browsable and accessible in an IDE like environment that we have these days.

> > > I'd recommend looking over these slides by Jim
> Weirich
> > on
> > > 10 things every Java programmer should know about
> Ruby
> > >
> (http://onestepback.org/articles/10things/index.html),
> > if
> > > you're really sincere about learning something here.
> He
> > > happens to know _both_ Java and Ruby very well.
> >
> > Any language comparison, when aimed at the right
> features
> > can make one look better than the other, right?
>
> See, you can put an advanced cerebral cortex in a monkey,
> but you can't make him use it. Did you read the slides?
> No, you didn't because Jim put one whole big slide in
> there to assure you he wasn't going to tell you Ruby is
> better than Java. All he did was point out important
> things that a Java programmer should now about
> Ruby.

I read every slide. I was specifically speaking to the issue of the overview/comparison of language features. Nowhere was there mention of object serialization across the network, versioning, distributed leasing nor distributed transactions. As I said those are the things that I need and use in the systems that I design and build.

> > Further, new users/uses of the same code get to usethis
> > free testing. They don't have to implement it either.
> > Thus, my test construction is limited to tests that cover
> > semantic behaviors where I cover the vast majority of
> > issues that a human constructed test should have to deal
> > with.
>
> All the compiler can do is ensure that you are executing a
> well defined operation on a set of values (a type). That's
> it. Guess what, that is just as automatic if you write
> tests for your code.

You missed my point. The compiler is written once. It provides the tests so I don't have to write them! That's it, plain and simple. A set of tests that I don't have to write over and over and over as I do with a dynamic language.

Which single test suite you run for your python or ruby code that you can reuse every time that make sure that you have no type incompatibilities? Is that test also available to every single user of your code so that they don't have to write tests to make sure that they are using the right members/methods.

> There is no extra work required. If
> you were just writing tests to mimic a compiler doing type
> checking, that would be stupid. When you test semantic
> things, boundary conditions, etc. you get that
> compiler-like 'type' testing for free. Oops, there I went
> and explained it in more depth. You do know how to write
> tests, yes?

It might be that you can make your tests do both tests at the same time, I don't write tests in that way because the compiler has already done that for me.

> > I guess I'd have to have a language based platform, such
> > as Jini, which provides distributed leasing and
> > distributed transactions, plus a language built in
> > security model, mobile code and method overides "int
> > max(int,int)" vs "double max(double,double)" and finally
> > binary data serialization between instances of the
> > language runtime, over the network to consider a language
> > enterprise worthy.
>
> Um, the only reason why you need int max(int, int) and
> double max(double, double) is because of types.

I picked a poor example for the point I was trying to make. In some cases, you do want to make sure a value is truncated to a integral value. There are other places where you do math on integer values that must be converted to real math because of division that creates real numbers. Perhaps you like to look at a math program and decide what the range of values are.

Automatic type promotion and demotion are interesting, but can result in unexpected results when you don't control them explicitly. At least that's my experience. But, perhaps I do different math calculations that you do.

> It's a lot
> of baggage for nothing gained (unless you don't test your
> code anyway). And of course, you have to have a cast
> operator so you don't need a separate double/int(?)
> max(double, int), and on and on. Now, what happens when
> you get happy with that cast operator?
>
> And you still haven't, or perhaps didn't intend to, answer
> why static typing makes communicating about the program
> more clear.

If all you do is a bunch of string and math stuff, and you are reading software that you know the general behavior of, you'd probably be quite comfortable not seeing type information.

I, personally, want to understand the semantic behavior of the software given the range of values that I expect to use with it. I want to understand the abilities of the software that uses the values that I want to pass to it.

With a Java interface, I get automatic documentation of the expected inputs as the creator. The users get documentation that correctly documents the type based expectations. Like all API documentation, the author provided information might not enumerate all the characteristic behaviors of the software.

> > I don't do web services and I don't create web sites.
> > Those are the features that I use the most often in Java
> > a and which I don't see available in Ruby, Python or many
> > of the other non-statically typed languages which I've
> > looked at.
> >
> > Point me to these kinds of solutions for Ruby and/or
> > Python.
>
> Hmm, you're kidding, right? Okay, probably not considering
> this post: check out druby and pyro. Service locators are
> trivial (as are the rest of distributed objects) when you
> have a dynamic language like Ruby and Python.

No, I'm not kidding. Druby and Pyro don't even come close to the power of the RMI programming model and Jini's expansion of that. Not even close. So, probably you need to go read about Jini and try and absorb the differences so that you can appreciate them.

Number one is missing in both of these is mobile code support!

Interfaces are important for stipulating the contract of the remote service. The implementation needs to be dynamically changable to manage versioning and optimize implementation centrally without clients having to be updated and redeployed.

Bruce Eckel

Posts: 875
Nickname: beckel
Registered: Jun, 2003

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 2:36 PM
Reply to this message Reply
@Alex
> ... or, rather, whether it's Ruby as a
> whole which, net of technical considerations, should be
> entirely avoided in order to eschew the risks of
> entanglement with a horde of crazed face-slapping zealots.
> I'm listening, and I'm sure I'm not the only one, but,
> , even if it was just me...:

The thing about this entire discussion is that it kind of makes my point: the people who were formerly hyper-enthusiasts about Java have moved to Ruby. The comments from Ruby folk seemed to be mostly, "The fact that you haven't said Ruby is the most wonderful thing in the world, and is the solution to all problems, and that anything Ruby does (such as provide multiple names for idential operations) isn't by definition the superior solution -- well, I take this as a personal insult and pass gas in your general direction!" (that latter, by the way, is a reference to a Monty Python sketch, and is something we often do in the Python community to lighten things up. Perhaps if Ruby adopted its own comic theme then that community could follow suit).

These comments seem to take anything except hyper-enthusiasm about Ruby as a personal affront, and I think make my case for me. I have said that Ruby and Rails are making contributions to the programming community, and I still think that. But as Alex pointed out, the ferocity of what we've seen here of the community doesn't draw me in. In contrast, the people commenting about both Java and Python have had, to me, a reasonable perspective, and have argued with examples and experience rather than on faith.

It's too bad. As I've said, I think some very interesting things are going on in the Ruby world. The book by "Why the Lucky Stiff" is one of the most creative things I've seen; it's really wonderful. And Rails appears to have forced people to really rethink what the essence of web programming is about. And some aspects of Ruby appear to have simplified some things that we may not seen that way before. All good things.

I will continue to try to learn Ruby by bits and pieces. But from what I've seen here, I have to be rather careful about where my information comes from. Yes, I know Alex and I know how careful he is, so I will trust his comparisons between Ruby and Python. I hope that he will do more such comparisons, but because of the comments made to him here I wouldn't be surprised if he doesn't. I am certainly less inclined to study and write about Ruby based on what I've seen here. This, I think, ends up being counterproductive to the Ruby community.

And although I criticized some of Bruce Tate's work, I still got more information from his book than I've gotten from the comments posted here. He at least argued for Ruby based on its merits.

I have to agree with Alex; the comments posted here have not encouraged me about the Ruby language community, and I've learned that the community is what makes the biggest difference to me, because those are the people you are going to have day-to-day contact with, and will decide whether you want to go to the conferences, etc. My experience with the Python community has been of a group of people who are thoughtful and generally treat people well. And who are generally happy with themselves and the people around them.

The impression I'm left with from the comments posted here is of the difference between going to a British soccer match and going to Burning Man. Maybe a British soccer match isn't all that bad, because after all people still seem to attend, but from what I've heard -- including first-hand accounts -- it's not something I'd want to go to. Even if the police do search people for weapons on the way in, the fact that they have to makes it seem like more of an aggressive place than I want to be. I'd rather go to Burning Man.

Joao Pedrosa

Posts: 114
Nickname: dewd
Registered: Dec, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 26, 2005 4:39 PM
Reply to this message Reply
Please, don't take my opinions as representative of the Ruby community -- I never meant them this way. Actually, I've been trying to specialize myself at Ruby, because I can choose a language to use almost exclusively. Since three years ago, Ruby has been gradually turning into my default language, and when it didn't have the "right tools", I built them myself, like database access, GUI database wrappers, GUI wrappers, reporting (txt, pdf, html, rtf), database administrator, a custom Ruby editor that I hope to improve it with more visual tools in the future, etc. All things that I built myself (many times based on components from other people), all part of my differentiating strategy.

Besides adopting Ruby as my main platform, I chose to support Linux as my development environments, though I intend to support Windows and Linux when deployment time comes.

So, I'm not really trying to make friends or evangelize Ruby in the best way. The Ruby people are really great and mostly don't care about what other people use -- it's your choice, right? No problem about that. Even though we might not agree with the superficial way that people make decisions sometimes, though they are valid decisions in some ways.

Cheer up. I'm cheering up. :-)

Brian Ford

Posts: 153
Nickname: brixen
Registered: Dec, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 27, 2005 12:40 AM
Reply to this message Reply
> These comments seem to take anything except
> hyper-enthusiasm about Ruby as a personal affront, and I
> think make my case for me.

...

> I have to agree with Alex; the comments posted here have
> not encouraged me about the Ruby language community,

Bruce,

This is just pathetic. You are the one who painted people who find Ruby a great language and Rails an interesting framework with a broad, broad belittling brush. Are you honestly going to say that calling people hyper-enthusiasts is not derogatory and provocative?

And if you get some less than flattering responses, that means the Ruby community isn't very nice? Take it for what it is: some people who think you wrote a stupid article with a nasty slant that was totally uncalled for.

If you and Alex, for instance, are treated harshly, that's as it should be. You are more dangerous than the average jerk because you profess, and carry, the air of expertise. There's a responsibility that comes with that. If I stand up and call BS on you, it may or may not be true. However, it does a service for those who may be mislead by you.

Ruby deserves a lot of respect. There are a lot of interesting ideas in it. It is not a simple knock-off of Python or Perl. The languages are not equivalent. If they were, you could just as easily recommend Ruby instead of Python. For whatever reason, you don't like Ruby as much as Python. Fine. That's definitely your choice. But if you write nonsense belittling people that do like Ruby, I think you do deserve to be ridiculed. Since you super-sensitive, dish-it-out-but-can't-take-it, folks are also kinda dense, let me emphasize: I think you deserve it; I'm not the Ruby community.

Alex Martelli

Posts: 8
Nickname: aleaxit
Registered: Dec, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 27, 2005 2:01 AM
Reply to this message Reply
> The thing about this entire discussion is that it kind of
> makes my point: the people who were formerly
> hyper-enthusiasts about Java have moved to Ruby. The

Yes, I see your point now, and I have to agree: whatever the purported advantages of Ruby may be, the fact that Brian Ford raves so wildly about it (and about anybody who doesn't enthuse as crazily about it as he does, me and you included) is a HUGE disadvantage for Ruby to surpass.

Just one example...:
I claim the differences are mostly syntax sugar, he blasts me for it, and as one of the points allegedly showing that they're not he lists the fact that... (wait for it...) *parentheses are optional*. Yes, that's just right: to show why it's so evil of me to point out that the differences are moslty syntax sugar, he lists TYPICAL SYNTAX SUGAR ISSUES as "counterexamples"! And not just parentheses, but even *lexical* issues such as whitespace significance.

In retrospect, I apologize to the Ruby community as a whole, for even ever suspecting this Brian Ford scum might somehow be "part of it": he's clearly simply a sample of bottom-feeding low-life. The best favor he could possibly do, to Ruby as well as to the world in general, would no doubt be to keep his foul mouth shut tight, although that's no doubt beyond his understanding.

Still, if there are more rabid sickos like him prowling around the edges of that otherwise respectable community, that must still count as a serious issue. I think Python's been unusually lucky in mostly avoiding attracting that type of weirdo, perhaps because of the "dampening" influence of its highly pragmatical, commonsense, real-world-based Dutch origins.


> comments from Ruby folk seemed to be mostly, "The fact
> that you haven't said Ruby is the most wonderful thing in
> the world, and is the solution to all problems, and that
> anything Ruby does (such as provide multiple names for
> idential operations) isn't by definition the superior
> solution -- well, I take this as a personal insult and
> pass gas in your general direction!" (that latter, by the
> way, is a reference to a Monty Python sketch, and is
> something we often do in the Python community to lighten
> things up. Perhaps if Ruby adopted its own comic theme
> then that community could follow suit).

I think that, much as I was inclined to do earlier, you're tainting the whole community by their association with Brian Ford. Joao, for example, has been guilty of a little over-enthusiasm, but he's also apologized for it and I don't think he attacked anybody personally, like Brian did, nor did, to the best of my recollection, post such patent absurdities as Brian's implied claim that making parentheses optional or whitespace nonsignificant is anything OTHER than *syntax sugar*.


> These comments seem to take anything except
> hyper-enthusiasm about Ruby as a personal affront, and I
> think make my case for me. I have said that Ruby and Rails
> are making contributions to the programming community, and
> I still think that. But as Alex pointed out, the ferocity
> of what we've seen here of the community doesn't draw me
> in. In contrast, the people commenting about both Java and
> Python have had, to me, a reasonable perspective, and have
> argued with examples and experience rather than on faith.

Agreed on all points. Still, of all the commenters, including enthusiastic ones, only Brian Ford has definitely exceeded the norms of civil human coexistence: that he's allegedly on Ruby's side is a worry, but we're basically talking about ONE dangerous individual, I don't think we've yet seen proofs that the crazed Brian-like assault-bots have overrun a programming community that just a couple of years ago (back when I participated in that long thread on comp.lang.ruby) was still quite a decent one... only worrisome HINTS of that hypothesis, such as the fact that no other Ruby enthusiast, so far, has considered it appropriate to chastise Brian for his excesses.


> It's too bad. As I've said, I think some very interesting
> things are going on in the Ruby world. The book by "Why
> the Lucky Stiff" is one of the most creative things I've
> seen; it's really wonderful. And Rails appears to have
> forced people to really rethink what the essence of web
> programming is about. And some aspects of Ruby appear to
> have simplified some things that we may not seen that way
> before. All good things.

Haven't read the book you mention (I'll look for it) but I do agree on the other points. Still, let me make a technical point: language design is a trade-off; you don't get to simplify some things without making OTHER things less simple. Consider, for example, the point of syntax sugar that Brian considers so important as to justify his despicable personal attacks against me, and later you: "parentheses are optional" to call a method... the mere MENTION of the method calls it.

This implies that "mere mention" means something utterly different for a method versus other attributes. So, to get a REFERENCE to an attribute, mentioning it is sufficient UNLESS it's a method, but if it's a method and you want a reference to it that you can seamlessly call in the future then you have to go through some syntax gyrations -- if, that is, you can get seamless polymorphism among callables at all.

In Python, it's a no-brainer: ANY mere mention ALWAYS just gets a reference; given ANY reference to a callable, you can always, if you wish, call it by juxtaposing parentheses [possibly with arguments inside, if needed]. There is hardly any "rule" to memorize here: by making the juxtaposed parentheses mean "call this thingy", like in C, the need for a chasm between callables and non-callables disappear. For an example of structured containers of callables, see for example the excellent Deferred class in Twisted (a book on Twisted has just been published by O'Reilly, though I haven't seen it yet). You CAN, I'm sure, arrange things similarly in Ruby -- but not without heavier syntax, because you can't just pass "x.y" for future reference if it's a method, you have to gyrate syntactically around it. I remember similar obstacles in Smalltalk (similar to Ruby in many ways -- except syntax sugar;-) being part of why I went back to Scheme, at the time, in my quest for the most usable VHLL (a quest I've been on for over 20 years, since I first met Rexx when it was still an internal IBM research project, which gave me my first inkling that there WERE other possible VHLL's, beyond Scheme and other Lisp variants, and besides the sheer academia of Backus' FP... a quest that, for the nonce, has led me to choose Python).


> I will continue to try to learn Ruby by bits and pieces.
> But from what I've seen here, I have to be rather careful
> about where my information comes from.

Yes, it's hard to fault that conclusion.

> Yes, I know Alex
> and I know how careful he is, so I will trust his
> comparisons between Ruby and Python. I hope that he will
> do more such comparisons, but because of the comments made
> to him here I wouldn't be surprised if he doesn't.

Thanks for the appreciation. If and when I do publish anything more on the subject, I will be certain to mention the Brian Ford-style rabid dogs as a potential disadvantage of Ruby, unless I should hear a strong condemnation of his unjustifiable personal attacks by other Ruby practitioners.

> I am certainly less inclined to study and write
> about Ruby based on what I've seen here. This, I think,
> ends up being counterproductive to the Ruby community.

I don't think there can be any doubt about that. Should I ever want to try and sabotage some emerging technology in the future, I think I'll take a leaf from Brian Ford's book: I'll make up a credible pseudonym and pose as a rabid take-no-prisoners Rottweiler dog "defending" it by personally attacking anybody trying to be reasonably even-handed about it, "justifying" the rants by self-contradictory diatribes.

> And although I criticized some of Bruce Tate's work, I
> still got more information from his book than I've gotten
> from the comments posted here. He at least argued for Ruby
> based on its merits.

And that's a completely different issue from the garbage Brian Ford has posted, for sure. One may agree or disagree about specific technical arguments, but the kind of junk and personal attacks that Brian Ford has posted is obviously beyond the pale.


> I have to agree with Alex; the comments posted here have
> not encouraged me about the Ruby language community, and
> I've learned that the community is what makes the biggest
> difference to me, because those are the people you are
> going to have day-to-day contact with, and will decide
> whether you want to go to the conferences, etc. My

Good point. FWIW, my frequent experiences with the Ruby people at open source conferences has been ENORMOUSLY more positive than Brian Ford might lead one to suspect; we've shared coffees and beers and stimulating discussons, and nobody's ever been obnoxious, indeed, in my experience at those conferences, NOBODY AT ALL has EVER been anywhere as obnoxious as he is. I think that here we get a chance to check if things have changed recently: if no Ruby enthusiast speaks up strongly and unconditionally condemning Brian Ford, then that may sadly confirm the impression that the Ruby community has recently taken a horrid turn for the worse, and disgusting behavior at the Brian Ford level is now considered to be justifiable if it is "for the Cause".

> experience with the Python community has been of a group
> of people who are thoughtful and generally treat people
> well. And who are generally happy with themselves and the
> people around them.

A fair summary -- which, until Brian Ford stomped crazily on the scene attacking me with no holds barred, I might have equally used of my experiences with the Ruby community, or, for that matter, the Perl one (in which I also count a lot of friends, even though we intensely disagree on technical language-design issue we'd never DREAM of behaving as abysmally as Brian Ford appears to think he was fully justified to do).


Alex

Dan Shafer

Posts: 3
Nickname: dshafer
Registered: Dec, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 27, 2005 3:05 AM
Reply to this message Reply
Wow. This whole Brian Ford and Ruby community "tude" byplay has been so unproductive and unhelpful that both sides seem to me to obscure the real conversation.

I didn't find Mr. Ford nearly as offensive as Alex obviously did. OTOH, I didn't enjoy his participation much, either, because it seemed to me to lack substance a lot of the time. But, at the same time, I found it strange that Bruce, whose work I've long admired, would feel that -- even if the Ruby community contained a BUNCH of offensive jerks (which my experience says it doesn't) -- the presence of nimrods in a language's community somehow affects the quality or usability of the language itself.

Oh, well.

I thought it might be interesting to try to help steer this conversation back on a Java vs. Ruby (sorry, no Python in this one) slant by pointing to a recently posted piece on IBM's development site by Andrew Glover. You'll find it at http://www-128.ibm.com/developerworks/library/j-ruby/?ca=dgr-lnxw06RubyOffRails. I think it's a pretty intriguing piece even if I understood only about half the Java and about 2/3 of the Ruby.

Vincent O'Sullivan

Posts: 724
Nickname: vincent
Registered: Nov, 2002

Re: The departure of the hyper-enthusiasts Posted: Dec 27, 2005 6:55 AM
Reply to this message Reply
> > I have to agree with Alex; the comments posted here
> > have
> > not encouraged me about the Ruby language community,
>
> pathetic.
> belittling
> derogatory
> provocative?
> stupid
> nasty
> dangerous
> jerk
> belittling
> you do deserve to be ridiculed.

QED Bruce.
Well done.

Morel Xavier

Posts: 73
Nickname: masklinn
Registered: Sep, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 27, 2005 5:11 PM
Reply to this message Reply
Brian, I'll start this reply as a "pythonista" who's spent the last few weeks getting his hands dirty with Ruby in order to try to "get" the language.

I, though, hope that I won't make too many mistakes.

I'll disclaim that, even though there are slight differences, I fond Ruby to be extremely similar to Python in spirit, and in capabilities. It has zones where it really shines, and others where I prefer the Python way. Overall, I really think that none of both languages is "The True Answer", and the one you pick really is a matter of personal taste (that's a short version of what I wanted to write when I first read Bruce's post/troll, back when there were no answers yet, but I decided to check what others would have to reply first)

> 1. Classes: open;
I assume you talk about the ability to re-open previously coded classes.

Truth to be told, this is a useless feature for user-defined classes. Now for the base classes of the languages, I do indeed find it wicked cool and, above the basic coolness, extremely nice.

> single inheritance; mix-ins;
This is a matter of personal taste, a toned down (less powerful) version of multiple inheritance, yet more than enough for 99.99% of the situations.

I don't really like single inheritance + mix-ins, but that's really personal taste

> class methods; singletons; singleton methods; class
> methods, class_eval; instance_eval. (I'm sure I'm
> forgetting some aspects, but these are all fantastic. and
> yes, I know, Python has something like class methods, and
> for me, decorator syntax is ugly)
Apart from the fact that you mentioned class methods twice and that I don't mind (hell, I quite like) decorators syntax, I haven't had the need to use any ruby singletons yet so I won't comment on that part

> 2. Blocks and closures
Aaah, blocks.

It's funny how 75% of the Ruby hype comes from them (nb: That number has just been Pulled Out Of My Ass).

Even more when you realise:
* That most other languages already have that with a less specific syntax (including Python)
* That blocks are not OO items, they come straight from functional programming.

What are blocks? Blocks are units of code execution, they take arguments, they reply with return values.

Damn, blocks are functions. Period.

Blocks are objects (well blocks can be converted to proc objects that can be returned and passed around as arguments, but that's trivial and usually done by Ruby under the hood, so blocks are objects).

So blocks are first-class object functions.

With closure, which most if not all languages that consider functions as first-class objects feature. And that includes not only Python, but languages as "basic" as Javascript.

The last thing, the only thing that Python misses (yes, I say misses because I find that quite annoying) is that blocks can be defined as anonymous functions. Python functions are always bound to a name (except lambdas, but lambdas are castrated functions and Guido wants to nuke them from Python 3000 so they don't count).

Blocks is merely the rubyist linguo for anonymous functions used as first class objects. Even though most rubyists don't seem to realize it (or don't want to admit it).

I find very interresting the reason why Ruby needed such a construct: Ruby has methods, these methods can be used as functions, but they have to be bound to an object, they don't feature closure, and due to the parens-less ability to call them you can't pass around Ruby methods as regular objects, because doing so would merely pass around their return values.

Damn, Ruby's not perfect and the necessity of blocks comes from one of the "features".

In fact, you can emulate ruby blocks in python with just about one more line:

Instead of
object.action do |args|
doSomething args
end

You write
def block(args):
doSomething(args)
object.action(block)

You have closure, you have FP functions that you can pass around and dynamically generate and use as return value and etc.

Wouldn't I like to be able to write
object.action( def (args):
doSomething(args)
)

now that I tried "blocks"? Truth to be told yes, even though I see many issues that we'd run into in Python (the first one being that Guido quite seems to hate anonymous functions)

Are blocks the Gift Of God?
No. Clearly not, they're anonymous functions with closure period, the birth of these things can be traced back to lisp for god's sake.

The only think we can say about them, is that Matz had the idea to use them everywhere in the code language, and that it was appropriate (at least for Ruby).

> 3. Conditional modifiers: print 'yes!' if you_like_ruby
> unless you_are_grumpy
That one is truly, completely, fully and extremely clearly a matter of taste.

While the construct reads as vanilla english and pleases the eye of the Perl refugee, it doesn't bring much, some people will like it others won't, but I don't call that a big difference.

> 4. Optional parentheses
Extremely debatable, and probably one of he reasons why Ruby had to have specific function objects (that don't want to be called functions).

The very nice thing about them, though, is that they make properties a breeze (and properties are, imo, one of the fields where Python could do much better even though the rubyists trying to diss python often use blocks to do so but very rarely use properties)

> 5. 'end' closes a "block" (not a Block in 2 above but a
> block of statements/expressions). Far from being
> cumbersome or litering code, like self in Python, this
> 'end' provides a psychological closure, which gestalt
> psychology has shown to be very important for the way the
> human brain creates meaning. If you want to understand
> closure, think about the saying, 'waiting for the other
> shoe to drop'.
Style again. I hate that end construct, even more than I hate Java's Curly Brace Forests. Others like them.

> 6. No syntatically significant white space. Usually
> this is not a problem for me in Python, but I don't like
> it and no one will ever convince me it's a good
> thing
. I have had it bite me, like when programming
> Python scripts in Zope, and it's just an annoyance I don't
> like to deal with
Style again. My editor does indentation for me, I don't worry about it, I just know that I won't have to reindent, and I have much less typing to do.

Hell, in fact that one should be merged with 5.

> 7. Libraries have been implemented from the beginning
> using blocks.
As I said, that's the only praise I'd have for blocks if I had to praise them, the fact that they're used a lot in the STL, and -- much more importantly -- the fact that they're used damn well. Most if not every usage of block in the STL is intelligent, meaningful and well thought of.

Then again, where Ruby uses blocks Python will very often use comparison functions. Different syntax, same goal.

> A recent
> example: Guido wants to remove map, lambda et al
Duh? Last time I checked Guido wanted to remove lambda and reduce, not map or filter, do you have any link for these?

Oh, and he wants to nuke out print, too *wink* *wink*

James Watson

Posts: 2024
Nickname: watson
Registered: Sep, 2005

Re: The departure of the hyper-enthusiasts Posted: Dec 28, 2005 12:24 PM
Reply to this message Reply
> James,
>
> How thoroughly did you read the post that you quoted? It
> didn't state that Ruby doesn't scale well. It stated that
> Ruby used a very different model for scale out than Java,
> one that has weaknesses and strengths. You linked to an
> excellent article but seemed to misunderstand its
> subtleties.

I understood it to say Ruby doesn't support true threading inside a process. To scale, multiple processes are used. This is not a "different model" than Java, it's the lack of a model. Java can be scaled with multiple processes too. It's not a solution provided by the language, it's a work-around for the lack of a feature. In fact we run some old Java code that uses the multiple process model and it's definitely inferior to using true threading IMO.

Flat View: This topic has 262 replies on 18 pages [ « | 10  11  12  13  14  15  16  17  18 | » ]
Topic: The departure of the hyper-enthusiasts Previous Topic   Next Topic Topic: Java Applets + Ajax = ?


Sponsored Links



Google
  Web Artima.com   

Copyright © 1996-2017 Artima, Inc. All Rights Reserved. - Privacy Policy - Terms of Use - Advertise with Us