On 07/14/2012 05:28 PM, Gor Gyolchanyan wrote:
On Sat, Jul 14, 2012 at 7:15 PM, Timon Gehr <timon.g...@gmx.ch
<mailto:timon.g...@gmx.ch>> wrote:

    On 07/14/2012 04:44 PM, Gor Gyolchanyan wrote:

        On Sat, Jul 14, 2012 at 6:35 PM, Alex Rønne Petersen
        <a...@lycus.org <mailto:a...@lycus.org>
        <mailto:a...@lycus.org <mailto:a...@lycus.org>>> wrote:

             On 14-07-2012 12:48, Gor Gyolchanyan wrote:

                 I just got an amazing thought. If we end up getting a D
                 front-end in D,
                 I think it would be possible to make the back-end in
        the same
                 space as
                 the code being compiled. This means, having the
        back-end as a
                 library
                 solution. This would automatically provide 100%
        compile-time code
                 introspection. This is just a thought. Not a proposal or
                 anything. What
                 do you guys think?

                 --
                 Bye,
                 Gor Gyolchanyan.


             I can't tell if you're advocating writing a back end in D
        as well.
             If you are, I am strongly against this. There's a reason it has
             taken 10 years for LLVM to get where it is, and it's still
        far from
             complete. We have better things to do with development of D
        than
             reinventing the wheel.

             --
             Alex Rønne Petersen
        a...@lycus.org <mailto:a...@lycus.org> <mailto:a...@lycus.org
        <mailto:a...@lycus.org>>

        http://lycus.org


        I didn't expect D to have it. D follows tons of anti-patterns, that
        other languages have followed. It's yet another language with yet
        another set of insignificant changes. It IS the best one of all, but
        it's not even close to being at least minimally useful for a
        really big
        task.


    Big words.
    [snip.]

Big words? Some languages are pretty much useless for generic
type-agnostic code. They either limit to compile-time templates
(eliminating polymorphism)

I take that to mean C++ or D.
I concur that parametric polymorphism is handy to have.

or just refuse to support it.
Other languages are obsessed with dynamic typing (like Python), which
eliminate modeling power.

I don't see how that would eliminate modeling power (on the contrary).
What it constrains is static checking and runtime performance.


And where is the progress here? Same semi-useful type system as C++ with
a few sprinkles on it.


I was not claiming anything else. There were unsupported claims that D
is the best programming language of all and useless for a really big
task.

Reply via email to