Choosing a new language - lisp

This is a discussion on Choosing a new language - lisp ; Ken Tilton <kennytilton@optonline.net> writes: > >> Python, Haskell and Lisp. > > Python has the users and libs, but those things follow the langue du > jour and Ruby has already eaten that lunch and Lisp is next, meanwhile > ...

+ Reply to Thread
Page 2 of 5 FirstFirst 1 2 3 4 ... LastLast
Results 11 to 20 of 43

Choosing a new language

  1. Default Re: Choosing a new language

    Ken Tilton <kennytilton@optonline.net> writes:
    >
    >> Python, Haskell and Lisp.

    >
    > Python has the users and libs, but those things follow the langue du
    > jour and Ruby has already eaten that lunch and Lisp is next, meanwhile
    > Python is rather lame when it gets to metaprogramming and other powerful
    > deals. Throw in the performance hit and it looks like a total loser. I
    > would swap in Ruby for Python and restart the ****ysis.


    Ruby makes Python look like C performance-wise, while retaining the
    readability of Perl. Not perhaps my choice for a language.

    I use Python at work and hack at home in Common Lisp; I'm hoping some
    time next year to start doing some Lisp work at the office--we'll see
    how that works out.

    --
    Robert Uhl <http://public.xdi.org/=ruhl>
    Ash nazg durbatul√Ľk, ash nazg gimbatul,
    Ash nazg thrakatul√Ľk agh burzum-ishi krimpatul.

  2. Default Re: Choosing a new language

    On Fri, 28 Dec 2007 16:34:55 -0700, Robert Uhl wrote:

    > Ken Tilton <kennytilton@optonline.net> writes:
    >>
    >>> Python, Haskell and Lisp.


    > Ruby makes Python look like C performance-wise, while retaining the
    > readability of Perl. Not perhaps my choice for a language.


    With Ruby 1.9 just released the performance gap is history (sometimes Ruby
    is faster sometimes slower but it is not a decisive consideration).

    My experience, admittedly that's only a sample of 1, with Ruby is that it
    is easier to learn and easier to read than Python, because it is a lot
    more consistent.

    Tim Josling

  3. Default Re: Choosing a new language

    tim Josling wrote:
    > On Fri, 28 Dec 2007 16:34:55 -0700, Robert Uhl wrote:
    >
    >> Ken Tilton <kennytilton@optonline.net> writes:
    >>>> Python, Haskell and Lisp.

    >
    >> Ruby makes Python look like C performance-wise, while retaining the
    >> readability of Perl. Not perhaps my choice for a language.

    >
    > With Ruby 1.9 just released the performance gap is history (sometimes Ruby
    > is faster sometimes slower but it is not a decisive consideration).
    >
    > My experience, admittedly that's only a sample of 1, with Ruby is that it
    > is easier to learn and easier to read than Python, because it is a lot
    > more consistent.


    That's been my experience, as well.

  4. Default Re: Choosing a new language

    On Dec 28, 10:23 am, Rico Secada <coolz...@it.dk> wrote:
    > Hi.
    >
    > First let me start by saying, please don't let this become a
    > flame-thing.
    >
    > Second, I need some advice.
    >
    > I am a 35 year old programmer, who program in C/C++, PHP and Bourne
    > Shell almost daily.
    >
    > I am currently going to start focusing on becoming more skilled at a
    > few key languages, rather than knowing many (which I do on a more
    > superficial level).
    >
    > My key languages are C, PHP and SH (Bourne Shell), and I have stopped
    > using C++ because I find that its a C-hack rather than a good design
    > choice.
    >
    > I have made the following decision:
    >
    > To study Ada and use it instead of C++. I come from a Pascal background
    > and I love the Ada syntax and wide area of usage. I am also attracted
    > to Ada because of its usage in the industry.
    >
    > Now I have three more languages that I am very attracted to, but I
    > prefer to focus on just one of them:
    >
    > Python, Haskell and Lisp.
    >
    > I have been doing some reading and some coding, and I am mainly
    > attracted towards Lisp because of its ability to "fix a
    > running program".
    >
    > But I find that Haskell is a more powerful language. Yet again Python
    > has a huge user base and many libraries, and it is implemented
    > everywhere, where Haskell and Lisp on the other hand hasn't.
    >
    > I like the syntax of all three, and I have gotten beyond the
    > "confusion" stage of Lisp parentheses, so they don't bother me at all.
    >
    > I need advice from people who have been coding in all three, and who
    > can share some views and experiences.
    >
    > Please, if you don't know ALL three by deep experience, don't respond to
    > this thread!
    >
    > Thanks and best regards!
    >
    > Rico.


    Can't say much about others but my experience with C, C++ (20 years),
    C# and Ada so far:

    C is too primitive, too much labor. I use C only on embedded platforms
    with limited availability of other languages.
    C++ for the years of use I have identified the following trouble
    spots:
    - Templates not always instantiate the way you think they should
    - Lack of typing restrictions: typedef is a bad joke
    - #define/ #ifdef should not be part of any high level language
    - no support for concurrency even simple threads

    C#/Java are pretty good except for reliance on garbage collection.
    Try the application that goes through 10Mb per second data crunch and
    witness the hick ups.

    Ada: in my first project. To summarize experience so far
    - More complex takes longer to learn
    - Takes some paradigm shift from pointers, callbacks to tasks/
    message/rendezvous mentality
    - Some keywords seem to be redundant
    - Takes more time to think through data structures, interfaces and
    tasks
    - That can in turn result in better code
    - Anything having to do with life safety better be coded in Ada

    George



  5. Default Re: Choosing a new language

    On Dec 28, 10:23 am, Rico Secada <coolz...@it.dk> wrote:

    > I am a 35 year old programmer, who program in C/C++, PHP and Bourne
    > Shell almost daily.
    >
    > I am currently going to start focusing on becoming more skilled at a
    > few key languages...


    Python and Ruby. They are the future of programming and are here and
    useful today. Both excellent languages... similar yet different. I use
    both for general purpose programming (I do not do Web development
    mostly systems programming). You can do things in minutes with them
    that would take days in Java or C++. You can write very portable code
    in either language (Windows, Linux, BSD, Mac, Solaris, etc.)

    Ada is airline/dod blessed. Hardly used elsewhere. Best of luck in
    finding skilled, affordable Ada programmers outside of major cities.
    The others you mentioned are research projects of math and CS (applied
    math professors)... and are not generally applicable to real-world
    problems. Interesting projects though.

    Best of luck,
    Brad




  6. Default Re: Choosing a new language

    George Neuner schrieb:
    > I know not everyone
    > works in RT, but I can't possibly be alone in developing applications
    > that are hard to restart effectively.


    Indeed. An additional case is interactive applications where setting up
    the situation to be tested requires several time-consuming steps.

    Regards,
    Jo

  7. Default Re: Choosing a new language

    Joachim Durchholz <jo@durchholz.org> writes:
    > Indeed. An additional case is interactive applications where setting
    > up the situation to be tested requires several time-consuming steps.


    At least for web development, there are a lot of automated tools that
    mimic user input, just for this purpose.

  8. Default Re: Choosing a new language

    "The purpose of a programming language is to let software developers
    express their intentions as simply and directly as possible."

    To Mr. Secada, who started this thread: you really have to say more
    about what it is you're trying to accomplish. For example, if
    you want to learn radically new ideas, Haskell makes a lot of sense,
    just because it's so different. If you want to write web sites,
    it's not clear that Ada provides modern and powerful tools
    for that, and you might want to look into Ruby on Rails. It
    depends a great deal on your ultimate purpose. (Joachim
    Durchholz's post already said this very well.) Please let
    us know, and we can provide much more useful help.

    If you work for an employer, or if you join an existing open
    source project, you may have very little ability
    to influence what language you write in! Only if
    you're writing for yourself or starting a new company
    or project do you usually get to make that choice.

    In fact, that's so important that I might as well just stop
    right there. But I can't help myself...

    If you're willing to expand the range of languages you
    might want to learn, Ruby is getting quite popular. And
    you could do worse than to check out the new language Scala.
    If you want to see my own quick reations, see:
    http://dlweinreb.wordpress.com/2007/...t-impressions/

    As for Common Lisp (henceforth "Lisp"):

    You mention that Lisp "isn't implemented everywhere". Well,
    maybe not everywhere, but quite a lot of places. See my
    paper at http://common-lisp.net/~dlw/LispSurvey.html. If
    you want to run on a Cray-1 you are out of luck, but for
    Unix, Linux, MacOS, and Windows you have many options.
    There are also many links in the paper to arguments
    about the virtues of Lisp, which you ought to take a look
    at. (And I recently wrote an essay about what people
    generally complain about re Common Lisp, to be fair. See:
    http://dlweinreb.wordpress.com/2007/...t-common-lisp/

    And now, in response to Mr. Nagle:

    John Nagle wrote:

    >
    > LISP has a cult problem. It's not used much any more, even in the
    > AI community. LISP users tend to be too wierd. The language itself
    > is OK, but few commercial applications use it. Viamall, which became
    > Yahoo Store, is one of the very few major commercial LISP apps.


    Sorry, but that is not true. There are a lot more important apps
    written in Lisp. You can find pointers in my paper (above). See
    especially my own employer, www.itasoftware.com.

    My point is not that Lisp is hugely popular. My point is that
    it has been used in enough applications that it is well-established
    that it can be used for real applications.

    (Haskell, on the other hand, has not been used for many serious
    commercial apps to the best of my knowledge, but people have
    shown that you can actually do some real things with it.
    The one that I think is cutest is the implementation of
    the new Perl 6 language, of which the one in Haskell 98 was
    the first and perhaps still the only!)

    As for Lisp users being "weird", come now, you can do better than
    ad hominem attacks.

    > I've written about 20,000 lines of LISP, but I'll never use it again.
    >
    > Actually, the ability to "fix a running program" isn't that useful
    > in real life. It's more cool than useful. Editing a program from
    > a break was more important back when computers were slower and just
    > rerunning from the beginning was expensive.


    Even if you don't edit from breaks, the fact that you can abort
    out of an error, make a small edit, incrementally recompile into
    the Lisp environment, and retry your program is incredibly useful.
    A fast debugging loop is so important, and harder to obtain when
    you are working with serious, large software. The app I work on
    is many hundreds of thousands of lines of code, and I would not
    want to have to rebuild it (even recompiling one file and then
    loading all the files) every time I made a small change. I
    would like Java far more if I had an implementation that could
    do this; I've seen such, but they haven't taken hold for some
    reason. (In fact, I think Sabre-C could do this! Long ago.)

    And Durchholz is very right when he says: "An additional case is
    interactive applications where setting up the situation to be tested
    requires several time-consuming steps." Absolutely!


    >
    > Python suffers from a slow implementation. Numbers vary, but
    > 10x to 60x slower than C is typical. The language is quite
    > powerful, but is held back by the CPython implementation, the
    > lack of a language standard independent of any implementation,
    > and a clunky mechanism for linking to external non-Python libraries.
    > There's no fundamental reason that Python couldn't be made to run at least
    > as fast as Java, but with the language spec tied to CPython, the
    > other implementations are always playing catch-up and run far behind the
    > CPython implementation.


    As much as I am a born-and-bred Lisp guy, there's quite a lot
    good to say about Python.

    I think 60x C is an exaggeration. It depends on what you're doing.
    But what's really important is where you're spending your time
    and whether the CPU speed of the language is actually the limiting
    factor. It isn't as important in an I/O bound program, for example.
    Or it might spend its time waiting for a user or in network latency.

    We use Python for many components of our system that are absolutely
    performance-critical and it turns out to be plenty fast enough.
    (Common Lisp is used for the most complex component, but not
    most of the others.)

    Another strategy is to use Jython, and find the (usually very few)
    crucial methods and rewrite them in straight Java.

    Meanwhile, coding in a language that makes programming easier
    often lets you come up with better algorithms or techniques
    than you'd end up producing in a clunky language like C,
    which can result in immensely improved performance.

    And if each run of your program is three seconds faster
    but it takes you three months longer to develop it, that
    may or may not be worth it, depending on your situation.

    I have not noticed that the Python hackers have any problem with
    the language not being standardized enough. I have never, ever
    seen this as a practical issue. I have not heard of CPython
    and Jython being incompatible (up to version 2.3).

    By the way, another advantage of using Jython is that you
    end up with .jar files that are quite easy to port, in case
    that happens to be an issue. Plus you get all the Java
    libraries, which might matter a lot. Everything depends on what
    you're doing.

    Jython is about twice as slow as CPython, or at least that's
    what you usually hear. On the other hand, I bet that if you
    run the JRockit implementation of Java (free from BEA), you'd
    get more like the same performance as CPython. Someone ought
    to try that.

    IronPython is actually twice as fast as CPython, if running
    on .NET is appropriate for what you're doing. This is
    measured in the "pystone" benchmark; all of there performance
    figures may vary significantly depending on what you're doing.
    IronPython and Jython will keep getting faster as the
    underlying VM's keep being improved, and IronPython
    specifically will get more and more of a boost from
    the DLR (Dynamic Language Runtime). See my OOPSLA report:
    http://dlweinreb.wordpress.com/2007/10/28/3/
    and recent material from Jim Hugenin of Microsoft. (Yes,
    non-Microsoft CLR implementations seriously exist.)

    How hard it is to link to external libraries may or may not
    matter to this user. It's not terribly easy in many languages.
    On the other hand, there are often not that many needs for it,
    and the ones that are common are often already done for you
    (I bet it's easy to find Python modules to link to some
    powerful crypto numeric packages, for example; so many people
    use Python.)

    Python is an exceptionally clean and easy-to-learn language.
    The same certainly cannot be said for Ada. I don't know
    Haskell but I'd guess it's small and clean. Common Lisp
    is big and design-by-committee, but if you learn it from
    a good textbook ("Practical Common Lisp" is one), this
    isn't a big problem.


    >
    > As languages, C# and Java are reasonably good. They tend to come
    > with too much excess baggage in the form of frameworks, run-time systems,
    > and packagers, but as languages they're fast, safe, and expressive.


    Too much? Those things are quite useful, when used properly. Yeah,
    they're good languages too, especially if you like lots of
    explicit type declarations on variables.

    >
    > Can't speak for Haskell.
    >
    > John Nagle


  9. Default Re: Choosing a new language

    It's not easy to answer this question, and the choice of language is
    quite influenced by what's your use of it.

    Python/Ruby and Java (and C#, sometimes, on Windows) are often a safe
    bet today (for work purposes too), they have lot of libraries and they
    are efficient enough for their purposes. But despite being flexible
    those two pairs of languages have different purposes.

    Haskell is a good language, it has much less libraries and today its
    speed is comparable to Python/Psyco one, it may require some time to
    adapt your mind tuned to older language to its nearly-pure functional
    style. Today I don't think it's a language for newbies. In the future
    maybe it will become more useful for work too.

    Bye,
    bearophile

  10. Default Re: Choosing a new language

    George Neuner <gneuner2/@/comcast.net> writes:

    > On Fri, 28 Dec 2007 12:54:57 -0800, John Nagle <nagle@animats.com>
    > wrote:
    >
    >> Actually, the ability to "fix a running program" [in Lisp] isn't
    >>that useful in real life. It's more cool than useful. Editing a
    >>program from a break was more important back when computers were slower
    >>and just rerunning from the beginning was expensive.

    >
    > Speak for yourself.
    >
    > The ability to patch a running program is very useful for certain
    > types of embedded applications. Not every program having high
    > availability requirements can be restarted quickly, or can be
    > implemented reasonably using multiple servers or processes to allow
    > rolling restarts.


    And in applications like IDEs, dynamically loaded functions are very
    important. Improving Emacs is vastly easier because Emacs Lisp is
    interpreted. You can make a small change to a function and quickly
    determine its effect. That's one reason (among many others I have
    not switched to GPS (which is written in Ada).

    --
    -- Stephe

+ Reply to Thread
Page 2 of 5 FirstFirst 1 2 3 4 ... LastLast