Sign in to follow this  

WTF

This topic is 4767 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Guest Anonymous Poster
it should be dead :> if you want another language starting with the letter 'D', get to see the D programming language :] it's got all features delphi has ever had and even more

Share this post


Link to post
Share on other sites
That post is pretty much a joke, but Delphi is an IDE and programming language is Object Pascal, if you did not know it [smile]
And no, I don't need another programming language - had enough [smile] Thanks anyway, Anonymous Poster!

Share this post


Link to post
Share on other sites
Guest Anonymous Poster
We don't need another lame-brained language that does what every other one does. We need more than just a language, we need universal analogue architectures and high level languages that are built from the ground up with fuzzy sets, feedback, and designed in limit approximation functions for halting.
For now, our write everything out explict programming paradigm is quite fine for our digital calculators....I don't think we neither yet another language, but I guess borland thinks otherwise.

Share this post


Link to post
Share on other sites
I really don't get all this talk about Delphi being dead. It's almost as if some people want Delphi to be dead...

As long as there are still people programming in Delphi, it will not die and I happen to know quite a few people who still use it as their only IDE/compiler.

Delphi 9 looks incredible and I'm really looking forward to it. I'm sure the way we will write applications in the future will be quite different from how we do it now. I don't know if .NET is what we will all end up using, but whatever it is, I'm sure Delphi will be around.

Share this post


Link to post
Share on other sites
Quote:
Original post by Anonymous Poster
Delphi was never alive. Geeks.


How amusing.

Quote:
As long as there are still people programming in Delphi, it will not die and I happen to know quite a few people who still use it as their only IDE/compiler.


I'm one of them ;)

Share this post


Link to post
Share on other sites
I seriously doubt thats the main reason though. However from a business/industry standpoint it is an encouraging point. However, there is more to Object Pascal developers than meerly that. And it is something that I find that is sorely underestimated in the past and to this day.

Share this post


Link to post
Share on other sites
This is a slightly modified version of

Top 10 reasons why Pascal is better than C

found at:
http://www.pascal-central.com/top10.html

Top 10 reasons why Pascal/Delphi is better than C

1. Delphi, noble language as it is, was named after the famous ancient Greek oracle Delphi. C was named after a Sesame Street character.

2. Pascal's inventor, Nicholas Wirth, and parameter passing conventions coalesce to form a nifty pun: You can pronounce his name by reference: Wirth or by value: Worth. C was invented at Bell Labs, where they wouldn't know a joke from a transistor.

3. There is only one Pascal, as defined by Wirth, while C has (shall we say?) several fathers: Kernighan & Ritchie, Harbison & Steele, Barnum & Bailey, and Laurel & Hardy.

4. In C, the following variable names are all different: thesame, TheSame, theSame, and THESAME. Nuff said.

5. In Pascal, when you fool with a pointer or handle, you know you're fooling around with a pointer or handle. In C, you could be fooling around with anything. C is the ultimate language for computational promiscuity.

6. In Pascal, we *know* how big an integer is.

7. C is used by liberal, Democratic, Mike Dukakis types of programmers. Delphi/Pascal is a favorite of the GOP. Hey, we know what the big language at Berkeley is, don't we?

8. C is the only language in the civilized world that still refuses to recognize the $ sign for a hexadecimal constant and continues to promote that base pretender to the throne: 0x00.

9. Delphi/Pascal has well-defined rules for Scope, while C appears to be using Listerine. This accounts for the medicine breath of many C programmers.

10. In C, you can do this:
for(;P("\n").R-;P("|"))for(e=3DC;e-;P("_"+(*u++/8)%2))P("| "+(*u/4)%2);
In Pascal, you CAN'T do this :
for(;P("\n").R-;P("|"))for(e=3DC;e-;P("_"+(*u++/8)%2))P("| "+(*u/4)%2);

Share this post


Link to post
Share on other sites
Guest Anonymous Poster
Hey! I like Listerine. Half of your 'Top 10' reasons are petty, ridiculus statements. 1-5. Every language has a purpose (sorta), and you use the one that best fits your needs. The topic of this thread was "Delphi is Dead?" (WTF actually), not language A is better than language B.

Share this post


Link to post
Share on other sites
The topic of this thread was rediculous, as well as some (most) of its content. Also, speaking of "Top 10 reasons" mentioned above, I must agree with anonymous poster that half of them are really stupid. Still, C++ is more popular due to commercial stuff but as a language even though powerful, I think it has significant drawbacks for developing large applications. My major complaint is the case sensitiveness which leads to ambiguity in code (hard to understand), allows ambiguous statements like "if (a = b)" which leads to run-time errors that are difficult to find. On the other hand, Pascal language was designed to be more didactic language - to explain the user *what is going on* in the code and this makes it more suitable for big applications where a lot of people are involved. I believe both languages can be used to create exactly THE SAME thing (in the contrary to what Anonymous poster said) and if used correctly, both languages provide a good way of developing applications.
Still, I don't know if it's just me, but most C/C++ code I have seen on the Internet, including the one provided by Sun Microsystems and others (for instance, communication-related standards from ITU) - is very bad written. No or useless comments, one or two letter variables (e.g. "a, b, t, zZ, ae, gj, ...etc") and number constants integrated in the code (like "if (a>31) ja=jb+44;" -> here, what 31 and 44 mean?!) and hardly packed code makes very BAD example of C/C++ usage. So in general, my critics towards C/C++ languages usually goes to the programmers rather than to the language itself. The reason for that, I think is because there are much more C/C++ inexperienced users (compared to Pascal) due to the same commercial stuff. These users can be teachers or employees dedicated to mathematics or physics that do not have enough knowledge of writing good programs so the source code made by them is just a bunch of equations resolving some sort of problem completely wired.
As an example, I invite you to take the sources of well known OGG Vorbis file format. I've just grabbed the source, opened a random file and saw this part of code:

while(i<n){
int j,k=map[i];
unsigned long pi=46341; /* 2**-.5 in 0.16 */
unsigned long qi=46341;
int qexp=0,shift;
long wi=vorbis_coslook_i(k*65536/ln);

qi*=labs(ilsp[0]-wi);
pi*=labs(ilsp[1]-wi);

for(j=3;j<m;j+=2){
if(!(shift=MLOOP_1[(pi|qi)>>25]))
if(!(shift=MLOOP_2[(pi|qi)>>19]))
shift=MLOOP_3[(pi|qi)>>16];
qi=(qi>>shift)*labs(ilsp[j-1]-wi);
pi=(pi>>shift)*labs(ilsp[j]-wi);
qexp+=shift; }




This code from Ogg Vorvis source illustrates each part of the critics I specified before. If you want something more convincing, here is a code from "g72x.c", a product of Sun Microsystems, which also has all the problems mentioned before:

if (tr == 1) { /* reset a's and b's for modem signal */
state_ptr->a[0] = 0;
state_ptr->a[1] = 0;
state_ptr->b[0] = 0;
state_ptr->b[1] = 0;
state_ptr->b[2] = 0;
state_ptr->b[3] = 0;
state_ptr->b[4] = 0;
state_ptr->b[5] = 0;
a2p = 0 ;
} else { /* update a's and b's */
pks1 = pk0 ^ state_ptr->pk[0]; /* UPA2 */

/* update predictor pole a[1] */
a2p = state_ptr->a[1] - (state_ptr->a[1] >> 7);
if (dqsez != 0) {
fa1 = (pks1) ? state_ptr->a[0] : -state_ptr->a[0];
if (fa1 < -8191) /* a2p = function of fa1 */
a2p -= 0x100;
else if (fa1 > 8191)
a2p += 0xFF;
else
a2p += fa1 >> 5;

if (pk0 ^ state_ptr->pk[1])
/* LIMC */
if (a2p <= -12160)
a2p = -12288;
else if (a2p >= 12416)
a2p = 12288;
else
a2p -= 0x80;
else if (a2p <= -12416)
a2p = -12288;
else if (a2p >= 12160)
a2p = 12288;
else
a2p += 0x80;
}

/* TRIGB & DELAY */
state_ptr->a[1] = a2p;

/* UPA1 */
/* update predictor pole a[0] */
state_ptr->a[0] -= state_ptr->a[0] >> 8;
if (dqsez != 0)
if (pks1 == 0)
state_ptr->a[0] += 192;
else
state_ptr->a[0] -= 192;

/* LIMD */
a1ul = 15360 - a2p;
if (state_ptr->a[0] < -a1ul)
state_ptr->a[0] = -a1ul;
else if (state_ptr->a[0] > a1ul)
state_ptr->a[0] = a1ul;

/* UPB : update predictor zeros b[6] */
for (cnt = 0; cnt < 6; cnt++) {
if (code_size == 5) /* for 40Kbps G.723 */
state_ptr->b[cnt] -= state_ptr->b[cnt] >> 9;
else /* for G.721 and 24Kbps G.723 */
state_ptr->b[cnt] -= state_ptr->b[cnt] >> 8;
if (dq & 0x7FFF) { /* XOR */
if ((dq ^ state_ptr->dq[cnt]) >= 0)
state_ptr->b[cnt] += 128;
else
state_ptr->b[cnt] -= 128;
}
}
}




I write all this because I hope that people finally decide to write better code (especially if they plan on releasing it to public) rather than flaming other languages (like "Top 10 reasons why Pascal is better than C"). If your handwriting is ugly it's not the pen - it's how you use it!

Edit: As an example, I also include the first part of C/C++ code translated to Pascal by our "C to Pascal compiler". In Pascal, the code is still hard to understand:

var
pi: Longword;
qi: Longword;
qexp: Longint;
shift: Longint;
wi: Longint;
begin
pi:= 46341;
qi:= 46341;
qexp:= 0;
wi:= vorbis_coslook_i(k * 65536 div ln);
qi:= qi * labs(ilsp[0] - wi);
pi:= pi * labs(ilsp[1] - wi);
j:= 3;
while (j < m) do
begin
shift:= MLOOP_1[(pi or qi) shr 25];
if (shift <> 0) then
begin
shift:= MLOOP_2[(pi or qi) shr 19];
if (shift <> 0) then
shift:= MLOOP_3[(pi or qi) shr 16];
end;
qi:= (qi shr shift) * labs(ilsp[j - 1] - wi);
pi:= (pi shr shift) * labs(ilsp[j] - wi);
qexp:= qexp + (shift);
j:= j + 2;
end; // while (c++ for)


Share this post


Link to post
Share on other sites
Quote:
Original post by Lifepower
Still, C++ is more popular due to commercial stuff but as a language even though powerful, I think it has significant drawbacks for developing large applications.


As a professional game developer and Delphi advocate, I use both C++ and Delphi extensively.

Quote:
My major complaint is the case sensitiveness which leads to ambiguity in code (hard to understand)


One of my pet hates about publicly available Delphi code is the inconsistency of capitalization. In one recent example, within a few lines of code I saw JPG, Jpg and jpg to reference the same variable. Choose one form and stick with it! I have always dreamt of a case-sensitive Pascal compiler that would force people to get their capitalization correct.

Quote:
, allows ambiguous statements like "if (a = b)" which leads to run-time errors that are difficult to find.


Current C++ compilers emit warnings about such code.

Quote:
Still, I don't know if it's just me, but most C/C++ code I have seen on the Internet, including the one provided by Sun Microsystems and others (for instance, communication-related standards from ITU) - is very bad written. No or useless comments, one or two letter variables (e.g. "a, b, t, zZ, ae, gj, ...etc") and number constants integrated in the code (like "if (a>31) ja=jb+44;" -> here, what 31 and 44 mean?!) and hardly packed code makes very BAD example of C/C++ usage. So in general, my critics towards C/C++ languages usually goes to the programmers rather than to the language itself. The reason for that, I think is because there are much more C/C++ inexperienced users (compared to Pascal) due to the same commercial stuff.


I see the same with publicly available Pascal code. Actually, I see fewer comments in Delphi code. C coders usually get into the habit of adding function header comment blocks. These are very rare in Delphi code. I think this is because the Delphi IDE will automatically create methods for you, but does not encourage the user to add comments.

To be fair, here is a sample of Delphi code that would scare most people.

Y := 0;
X := 3;
Command := (Source^[1] SHL 8) + Source^[2];
Bit := 16;
WHILE (X < SourceSize) DO BEGIN
IF (Bit = 0) THEN BEGIN
Command := (Source^[X] SHL 8) + Source^[X+1];
Bit := 16;
INC(X,2)
END;
IF ((Command AND $8000) = 0) THEN BEGIN
Dest^[Y] := Source^[X];
INC(X);
INC(Y)
END
ELSE BEGIN { command and $8000 }
Pos := ((Source^[X] SHL 4)
+(Source^[X+1] SHR 4));
IF (Pos = 0) THEN BEGIN
Size := (Source^[X+1] SHL 8) + Source^[X+2] + 15;
FOR K := 0 TO Size DO begin
Dest^[Y+K] := Source^[X+3];
end;
INC(X,4);
INC(Y,Size+1)
END
ELSE BEGIN { pos = 0 }
Size := (Source^[X+1] AND $0F)+2;
FOR K := 0 TO Size DO
Dest^[Y+K] := Dest^[Y-Pos+K];
INC(X,2);
INC(Y,Size+1)
END; { pos = 0 }
END; { command and $8000 }
Command := Command SHL 1;
DEC(Bit)
END { while x < sourcesize }
END;


Quote:
I write all this because I hope that people finally decide to write better code (especially if they plan on releasing it to public) rather than flaming other languages (like "Top 10 reasons why Pascal is better than C"). If your handwriting is ugly it's not the pen - it's how you use it!


True. It is usually the author who is at fault. Most of the C++ code that we write at here at work is understandable (meaningful variable names, comments, etc).

Quote:
Edit: As an example, I also include the first part of C/C++ code translated to Pascal by our "C to Pascal compiler". In Pascal, the code is still hard to understand:


What is this C to Pascal compiler that you mention? I've often thought about making such a tool, but never got past lexx and yacc.

Share this post


Link to post
Share on other sites
2 Sly:

Sorry, I hate using quotes (in my opinion it lacks of respect, when replying to someone), but I'm going to talk about each point here:

1) Inconsistency of capitalization: well, in Pascal you use "MyVar" and "myVAR", your eyes hurt (or you hate it) but the program works and you are sure about it, in C++ your program may compile (if such variables ARE declared), your eyes do not hurt (and/or you do not hate it) but your program may not work properly :(
In Pascal it's matter of emotions, in C++ it's matter of how well you pay attention to the code :p

2) Statements like (a = b)
We're talking about language itself and not specific compilers, in theory a compiler does not necessarily have to warn you about this since it's completely valid code in C/C++. And not talking about "(a = b)" exactly, it can be something like "if (a = b--)", which is also correct and sometimes I've seen expressions like this in the code. I did not say it was bad, I say it can be confusing and can lead to bugs that are hard to find. You may argue about this saying there are alternatives (warnings, write better code), but the language itself allows this.

3) The "bad pascal" code you mentioned - even though the code itself is still better written than the examples I've posted, it shows the same thing I've tried to say in my previous post (see "writing bad code"). The thing is - since C/C++ is much popular, there is more public source code in C/C++. My point was that "many people write bad code".

4) About C->Pascal compiler: it's a project we've developed while developing Asphyre Sound System (which unfortunally was not released with Asphyre Component Pack due to lack of development & time). The idea was to make a compiler which can translate the entire C/C++ source files to Delphi-compatible ones. Our compiler handles work pretty well but unfortunally, not all code can be easily translated. For instance, an expression like "a-= (b--) + (c--) + (b--) + (c++)" cannot be translated to Pascal code directly and needs either temporary variables or sequential translation which was not the point of our compiler. I was going to release this project to public, but since I don't own all of it (part of it is of Hab, my partner) and we did not agree for freeware public release, I don't know what will happen with it :(

Share this post


Link to post
Share on other sites
Sign in to follow this