Interesting: Delphi goes up, C# goes down
Trebor
Bernhard Geyer
Delphi -> + 1,00%
C# looses only position to Python.
C/C++, Perl, Ruby, PL/SQL, SAS, D, Pascal, Lisp/Scheme go down.
Trebor
Correct !
Kim Madsen
months.
The old negative stigmas seems to have lost wind, and new optimism gaining
some foothold.
best regards
Kim Madsen
k...@components4developers.com
www.components4developers.com
"Trebor" <tre...@hotmail.com> wrote in message
news:47ac...@newsgroups.borland.com...
> http://www.tiobe.com/tpci.htm
>
Frank J
> The old negative stigmas seems to have lost wind, and new optimism gaining
> some foothold.
You couldn't tell it from looking at the stock price.
Martin James
"Trebor" <tre...@hotmail.com> wrote in message
news:47ac...@newsgroups.borland.com...
> http://www.tiobe.com/tpci.htm
VB, which is about a much use an obscure Polynesian rodent.
Rgds,
Martin
VT Venkatesh
price :)
More over there is direct relation between the product quality & stock
price though the relation manifests over a period of time only
Venkatesh
Alexandre Machado
"Martin James" wrote
> WTF is 'Lua'?
"Lua" is "Moon" in good portuguese!
In good latin it is "Luna". hehehehe
Regards,
Alexandre Machado
linuxmonkey
> WTF is 'Lua'? Sounds like some obscure Polynesian rodent, as distinct from
> VB, which is about a much use an obscure Polynesian rodent.
One reason for this being so high up could be that it is embedded in
World Of Warcraft for people to script their own user interfaces. 10
million users FTW (for the win).
Renato
news:47ac603a$1...@newsgroups.borland.com...
AFAIK, Lua is a scripting language developed in Brazil and worldwide
adopted.
The word Lua means moon in portuguese.
Regards.
Renato.
Craig Stuntz [TeamB]
unfortunately, has more to do with what their current throwaway TLA is
than how Delphi is doing.
--
Craig Stuntz [TeamB] · Vertex Systems Corp. · Columbus, OH
Delphi/InterBase Weblog : http://blogs.teamb.com/craigstuntz
Want to help make Delphi and InterBase better? Use QC!
http://qc.borland.com -- Vote for important issues
Eric Grange
> VB, which is about a much use an obscure Polynesian rodent.
It's a bit like SQLite, you probably relied on it many times without
knowing you did ;)
Eric
James Smith
also be JITted, and supports stuff that is pretty spacey for most
programmers only accustomed to imperative static languages. Stuff like first
class functions, proper tail recursion, closures (functions that return
functions), iterators, dynamic typing, coroutines are all available.
Lua statement:
a,b,c = foo() -- foo returns multiple results (allowed in lua). If there
aren't enough returns to assign, the remaining vars are assigned nil.
There are toolkits available which allow embedding of Lua scripts into your
Delphi (and the other one) progs. You could have your own lua repl
(read-eval-print-loop) rolled up in your Delphi app.
James
Bob Swart
> Lua statement:
> a,b,c = foo() -- foo returns multiple results (allowed in lua). If there
> aren't enough returns to assign, the remaining vars are assigned nil.
Interesting! And if there are too many returned values, they will just
be ignored, I reckon?
> James
Groetjes,
Bob Swart
--
Bob Swart Training & Consultancy (eBob42.com) Forever Loyal to Delphi
CodeGear Technology Partner -- CodeGear RAD Studio Reseller (BeNeLux)
Blog: http://www.drbob42.com/blog - RSS: http://eBob42.com/weblog.xml
Alexandre Machado
"James Smith" wrote:
> Lua statement:
> a,b,c = foo() -- foo returns multiple results (allowed in lua). If there
> aren't enough returns to assign, the remaining vars are assigned nil.
Ok, I don't know it, and I don't what to discuss about the good, the bad and
the ugly in programming, but...
Is there any competition of programming languages? Who invent "the most
exotic feature or syntax" is the winner? hehehhe
I'm thinking right now how good would be debug an
a, b, c, d, e, f, g, h = foo() statement...
Regards,
Alexandre Machado
Craig Stuntz [TeamB]
> I'm thinking right now how good would be debug an
>
> a, b, c, d, e, f, g, h = foo() statement...
I don't see how this is any harder than:
a = foo(b, c, d, e, f, g, h)
--
Craig Stuntz [TeamB] · Vertex Systems Corp. · Columbus, OH
Delphi/InterBase Weblog : http://blogs.teamb.com/craigstuntz
How to ask questions the smart way:
http://www.catb.org/~esr/faqs/smart-questions.html
Unknown
> I'm thinking right now how good would be debug an
>
> a, b, c, d, e, f, g, h = foo() statement...
And why not just foo(a, b, c, d, e, f, g, h) with them being vars or
outs? Or do they plan on using expressions such as i := i + foo()?
Looks bonkers to me.
--
Alexandre Machado
>> I'm thinking right now how good would be debug an
>>
>> a, b, c, d, e, f, g, h = foo() statement...
>
> I don't see how this is any harder than:
>
> a = foo(b, c, d, e, f, g, h)
foo(b, c, d, e, f, g, h) has a fixed number of parameters, unless I have
default const parameters, or overloaded functions. Howerver, doesn't seem
this is the case with that James Smith post.
I didn't say it is harder. But sure it is different.
if function foo() in Lua returns only 8 results, the sentence:
a, b, c, d, e, f, g, h = foo()
is equal to
a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p = foo()
This doesn't happen in Pascal.
Regards,
Alexandre Machado
Craig Stuntz [TeamB]
> foo(b, c, d, e, f, g, h) has a fixed number of parameters, unless I
> have default const parameters, or overloaded functions.
It has a fixed number, unless it doesn't? OK.
> This doesn't happen in Pascal.
Well, no; that's why it's not called "Lua."
Don't presume that the Lua runtime knows what foo does before you call
it, since it doesn't. Nilling extra vars is a /reasonable/ way to
handle results which may or may not come back from a function (since
the function you think you're calling might not be what actually gets
called). This will seem weird to people without experience with dynamic
languages, but dynamic languages work differently and shouldn't be
expected to behave like a non-dynamic language.
But don't get too comfortable with how Pascal handles params. Lots of
languages do it differently. Look at partial application in Haskell,
for example.
Lots of languages work very differently than Pascal. It's a good
exercise to learn a few of them.
--
Craig Stuntz [TeamB] · Vertex Systems Corp. · Columbus, OH
Delphi/InterBase Weblog : http://blogs.teamb.com/craigstuntz
All the great TeamB service you've come to expect plus (New!)
Irish Tin Whistle tips: http://learningtowhistle.blogspot.com
Alexandre Machado
I knew that it would became a discussion about that... but...
>> foo(b, c, d, e, f, g, h) has a fixed number of parameters, unless I
>> have default const parameters, or overloaded functions.
>
> It has a fixed number, unless it doesn't? OK.
NO Craig,
unless you *the developer*, explicitly tell the compiler that it should
admit 8, 9 or 10 parameters.
Like in
foo(b, c, d, e, f, g, h: Integer); overload;
foo(b, c, d, e, f, g, h, i: Integer); overload;
foo(b, c, d, e, f, g, h, i, j): Integer; overload;
You are explicitly telling to the compiler: Admit 8, 9 or 10 integer
parameters . If I'm responsible for designing some class that implements foo
method I will not let a programmer use foo method passing 7 or 6 or 5
parameters. It is completely different.
> But don't get too comfortable with how Pascal handles params. Lots of
> languages do it differently.
Differently? You said in the last post that it was almost the same! ;-)
> Lots of languages work very differently than Pascal. It's a good
> exercise to learn a few of them.
Sure... But can I tell you they are different indeed after that?
Regards,
Alexandre Machado
James Smith
> ignored, I reckon?
Indeed, that is the case.
James
Richard Foersom
Hoi Trebor
This is old news, that standing (January 2008) was published at the beginning of January. The stat of February seems to be delayed.
It looks all fine with the green arrows, but the absolute percent numbers are more important. With 3.3% it should mean that about 1 in 30 programmer is a Delphi programmer. This need to increase.
One easy step to help more people get started, would be for CodeGear to update the Turbo versions. I hope this is going to happen later this year after Tiburon is out and running. The current Turbo Delphi site gives the impression of an abandoned and dead product.
Doei RIF
Bob Dawson
>
> Indeed, that is the case.
I'm not sure I see the advantage of
a, b, c = foo()
over
foo(a,b,c) where a, b, and c are out parameters
In general, a function result makes the status of the paramter self
documenting (in the line a = function(), a is clearly a result not an
input), and additionally function syntax allows 'stacking' functions in
code, so rather than
foo(a) //out param
bar(a)
we can write
bar(foo())
but if bar takes multiple params, then
bar(foo())
is starting to look rather obscure rather than clean. No telling what's
being passed. would lua allow that?
bobD
>
> James
>
>
Craig Stuntz [TeamB]
> unless you *the developer*, explicitly tell the compiler that it
> should admit 8, 9 or 10 parameters.
That isn't how dynamic languages work. The method you're calling may
not exist at the time you write the code.
> > But don't get too comfortable with how Pascal handles params. Lots
> > of languages do it differently.
>
> Differently? You said in the last post that it was almost the same!
> ;-)
Only the one syntax example you gave, not generally.
James Smith
>
> a, b, c, d, e, f, g, h = foo() statement...
I'm sure there's a different set of challenges for debugging this kind of
stuff, no doubt. But the broader prespective is to see that these kinds of
dynamic languages will do a lot for you without you having to do a lot for
them in return. They can provide greater abstractions, at the cost of
allowing you to shoot your foot off perhaps, but I'm not convinced that that
can't be solved as well. Maybe the answer is to just do it the Erlang way --
if you shoot your foot off, just spawn more feet. Even do it in advance if
necessary.
At any rate, all the stuff that we think makes for correct programming style
is going to be turned on its ear as the general computing environment
becomes more dynamic and concurrent.
James
James Smith
> parameters . If I'm responsible for designing some class that implements
> foo method I will not let a programmer use foo method passing 7 or 6 or 5
> parameters. It is completely different.
Why not. Maybe I don't understand. If you are willing to work with a
function that returns a bunch of results, and you may need some of them some
of the time, but not all of the time, then work with another function that
doesn't return enough results, but that's ok because the results can be
checked for nil, then what you've got is a situation that probably let's you
write a lot less code to support it.
Additionally, let your base code figure out how to solve a problem
dynamically -- one that your host app that you wrote and compiled and sent
out in the wild isn't designed to deal with, but your base code in that same
app is willing to try to frame and cope with.
This is exactly the issue with static programming that we have to understand
to grow past it. Static programming can address what the programmer designed
it to address in advance -- traditional programming is only useful in a very
controlled environment. Step outside of that, then you have to write another
static program to address just another controlled environment. That means
spec, write, compile, test, deploy, then hope that the environment is
controlled the way the programmer expected it to be.
If we adopt and develop expertise with hybrid solutions - like a Delphi/Lua
combination - that identify a perfomance layer and a dynamic layer, this
might be way Delphi survives well into the future.
James
James Smith
> being passed. would lua allow that?
I don't know, I'm just getting into Lua myself. What is great is that you
can fire up the environment and just start typing stuff in to see what
happens.
James
Roland
straighten up considdering your code quality if you do not want to type
too much or use the clipboard all the time.
I know what I am talking about, since I used to program very ugly ...
it's getting better now and LUA would not prevent me from doing
a,b,c,d,e,f,g = foo()
whereas in Delphi I would have to do something like
foo(relevantcompositclass); or foo(the_relevant_array) where
the_relevant_array contains a,b,c,d,e,f,g.
Craig Stuntz [TeamB]
Delphi. If you approach them like Delphi, they'll fail. People who are
only capable of thinking in Delphi terms should certainly stick to
Delphi.
--
Craig Stuntz [TeamB] · Vertex Systems Corp. · Columbus, OH
Delphi/InterBase Weblog : http://blogs.teamb.com/craigstuntz
Please read and follow Borland's rules for the user of their
server: http://support.borland.com/entry.jspa?externalID=293
Roland
I like the nature of Pascal that it wants precise type declaration at
the top of the function or procedure bodies or - in Delphi - in the
interface part of the unit.
People who are only capable of thinking in Delphi should try to start to
think in their head ;-)
Dennis Cote
>
> if function foo() in Lua returns only 8 results, the sentence:
>
> a, b, c, d, e, f, g, h = foo()
>
> is equal to
>
> a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p = foo()
>
These two sentences are not the same.
In the second sentence, the variables i...p will be set to nil if foo()
returns 8 results. In the first sentence i...p will maintain the value
they had before the sentence executes.
Dennis Cote
Richard Foersom
> This is old news, that standing (January 2008) was published at the
> beginning of January. The stat of February seems to be delayed.
It is now (2008-02-10) updated. It does not look as pretty as January.
Delphi changed from 3.3% to 2.8% in just one month, hrm??? Look like
the parameters they measure on is not really the right ones.
Doei RIF
Jolyon Smith
>
>
> > The old negative stigmas seems to have lost wind, and new optimism gaining
> > some foothold.
>
> You couldn't tell it from looking at the stock price.
CodeGear has a stock price?
;)
--
JS
TWorld.Create.Free;
naf
>
> I don't see how this is any harder than:
>
> a := foo(b, c, d, e, f, g, h)
It's no harder, but I believe the Lua version is infinitely more readible.
You can see just by looking at the Lua function that a-h are being modified,
whereas with the Delphi one you won't know until you investigate the
function.
naf
Craig Stuntz [TeamB]
> It's no harder, but I believe the Lua version is infinitely more
> readible.
I agree, although it's the better of two bad alternatives in this
case, IMHO. Were I writing something like that in the real world (in
either language) I'd use an argument type to roll those all together.
--
Craig Stuntz [TeamB] · Vertex Systems Corp. · Columbus, OH
Delphi/InterBase Weblog : http://blogs.teamb.com/craigstuntz
IB 6 versions prior to 6.0.1.6 are pre-release and may corrupt
your DBs! Open Edition users, get 6.0.1.6 from http://mers.com
Mike Swaim
> Alexandre Machado wrote:
>
> > I'm thinking right now how good would be debug an
> >
> > a, b, c, d, e, f, g, h = foo() statement...
>
> I don't see how this is any harder than:
>
> a = foo(b, c, d, e, f, g, h)
What if a,b,c are all properties? In the first function, you can
assign values to all of them. I don't think that you can do so in your
example.
--
Mike Swaim MD Anderson Division of Quantitative Sciences
mps...@mdanderson.org or msw...@odin.mdacc.tmc.edu
Today's Secret Message:
Aladdin strokes the disguised hemisphere.
Craig Stuntz [TeamB]
> What if a,b,c are all properties? In the first function, you can
> assign values to all of them. I don't think that you can do so in your
> example.
Well, in Delphi, anyway. But the Lua example won't work in Delphi
anyway. I wouldn't presume that Delphi's limitations on poperties as
var args apply to every language on earth. I don't know about Lua.
--
Craig Stuntz [TeamB] · Vertex Systems Corp. · Columbus, OH
Delphi/InterBase Weblog : http://blogs.teamb.com/craigstuntz
Chi-Shun Chen (Googi Calendar)
"Trebor" <tre...@hotmail.com> wrote in message
news:47ac...@newsgroups.borland.com...
> http://www.tiobe.com/tpci.htm
>
Well, it seem that:
When a tool need more programmers , longer time to learn and longer
developing time for same project.
These make it looking more public in this modal.
Chi-Shun Chen