From: Michael Neumann <mneumann@...>
Date: 2009-04-12T01:39:56+09:00
Subject: Re: [ANN] Falcon - powering innovation

Kless wrote:

> If anybody is interesed in new technologies, you'll love this new
> language called Falcon [1], which has been open sourced ago little
> time.
> 
> Falcon is a scripting engine ready to empower mission-critical
> multithreaded applications. It provides six integrated programming
> paradigms: procedural, object oriented, prototype oriented,
> functional, tabular and message oriented. You use what you prefer.
> 
> To know more about its design, read the interview to the Falcon author
> that has published ComputerWorld Australia [2].

Nice language (I like all new languages :). Please don't read any of my 
words as criticism.

The Falcon Facts Table [1] is not 100% right about Ruby.

* Document Template: There was eruby in the past (maybe it still exists) 
that was a binary. Other than that, "Document Templating" can be emulated by 
this one-liner:

  ruby -rerb -e"puts ERB.new(STDIN.read).result" < rubyfile.rhtml

And then, I don't think this is an important fact and should definitively 
not be built into the language itself.

* Multithreading: Ruby 1.8 had portable multithreading (it even worked under 
DOS a decade ago). Ruby 1.9 has native OS threads, which are a lot more 
scalable than green threads of Ruby 1.8. But basically the same applies as 
for Python. I guess JRuby is a lot more scalable in this regard.

* Embeddability: You can embed Ruby into a C application in 10 lines of 
code. But usually you write wrappers of a C library and call it from Ruby. 
What you can't do is to embed multiple instances of Ruby into your 
application (you can do that with Rubinius).

* C Dynamic Library Interface: Ruby ships with "dl", with which you can 
access dynamic libraries.

* Compile time metaprogramming: I don't see a huge difference to Ruby's 
metaprogramming here. You can do exactly the same with evaluating strings, 
e.g.

  def makeClassWithProp(name, property)
    eval %{
      class #{name}
        attr_accessor #{property}
      end
    }
  end

* Procedural programming: Well, methods are very similar to procedures. If 
you write methods in the toplevel (without a class declaration), they are 
part of class Object. I don't see a huge difference to procedures :)

* Functional Programming: I'd give Python here a clear "yes", as Python's 
methods are actually functions. You can definitively pass other functions as 
parameters to functions in Python. In Ruby, there are also functions 
("blocks") that you can pass to methods. So I'd give Ruby at least a partial 
here and Python a clear "yes".

* Prototype-oriented: Ruby has singleton methods.
   a = Array.new
   def a.new_method
     "hallo"
   end
   p a.new_method # => "hallo"
   Array.new.new_method #=> method missing

  So this is at least a "partial", like Python :)

* Direct binary data access: Both Python and Ruby have libraries that ship 
by default that deal with this. In Ruby this is done by methods #pack and 
#unpack.

* Virtual filesystem: There is open-uri, a library which provides kind-of
   virtual filesystem:

     ruby -ropen-uri -e'puts open('http://www.ruby-lang.org/').read'

----

IMHO, Falcon mixes too many things into one language, without having a clear 
advantage over languages like Python or Ruby (at least I haven't seen a 
clear feature that Python or Ruby doesn't have). I like Ruby because of it's 
simplicity and well-thought-out underlying model (everything is an object), 
and not to forget the principle of (matz's) least suprise in the core 
libraries. Having too many concepts in a language is not always a good 
thing.

Regards,

  Michael

[1]: http://www.falconpl.org/index.ftd?page_id=facts