Sign in Join

Live chat for Free Pascal, Lazarus, Delphi and every Pascal programmer.

Mailing lists / fpc-pascal / 2009-02

Origin of FPC features

12 messages · 10 people · –

Reply by email Subscribe to this list Your subscription

Read-only archive. Use j and k to move between messages.

leledumbo

I'm writing a paper about FPC and I need references where each language feature comes from. So far, these are my what I know (some are guessing though):

Feature
Original Dialect
Additional Information

Separate compilation
UCSD Pascal
Unit based, not module (like Extended Pascal)

Primitive OOP
Turbo Pascal
C++ like

Modern OOP (including exceptions)
Delphi
Java like, though FPC was born before Java ;-)

Assembler integration
UCSD? Turbo?
AT&T and Intel

External references
UCSD? Turbo?
-

Operator overloading
Pascal-XSC
-

Function / Procedure overloading
Delphi
-

Dynamic arrays
Delphi
-

Variants
Delphi
-

Arrays as parameter enhancements
Delphi
Open arrays, partial arrays

Bitpacked Structures
Native FPC
-

Generics
Native FPC
-

Thread Programming
Native FPC? Delphi?
Bringing threads to language level

In case I miss something that you know, please add. Note that these features are related with language construct, not technical one (i.e. compiling speed, makefiles).

View this message in context: http://www.nabble.com/Origin-of-FPC-features-tp21927731p21927731.html Sent from the Free Pascal - General mailing list .
Krishna
to leledumbo
leledumbo wrote 17 lines
I'm writing a paper about FPC and I need references where each language feature comes from. So far, these are my what I know (some are guessing though): Feature Original Dialect Additional Information Separate compilation UCSD Pascal Unit based, not module (like Extended Pascal) Primitive OOP Turbo Pascal C++ like Modern OOP (including exceptions) Delphi Java like, though FPC was born before Java ;-) Assembler integration UCSD? Turbo? AT&T and Intel External references UCSD? Turbo? - Operator overloading Pascal-XSC - Function / Procedure overloading Delphi - Dynamic arrays Delphi - Variants Delphi - Arrays as parameter enhancements Delphi Open arrays, partial arrays Bitpacked Structures Native FPC - Generics Native FPC - Thread Programming Native FPC? Delphi? Bringing threads to language level In case I miss something that you know, please add. Note that these features are related with language construct, not technical one (i.e. compiling speed, makefiles).

The list is missing bound method pointers which is my favorite feature.

Cheers,
-Krishna

I love deadlines. I like the whooshing sound they make as they fly by. -- Douglas Adams
Florian Klaempfl
to leledumbo: I'm writing a paper about FPC and I need references where each language feature comes…
Show quoted text 10 lines
I'm writing a paper about FPC and I need references where each language feature comes from. So far, these are my what I know (some are guessing though): Feature Original Dialect Additional Information Separate compilation UCSD Pascal Unit based, not module (like Extended Pascal) Primitive OOP Turbo Pascal C++ like Modern OOP (including exceptions) Delphi Java like, though FPC was born before Java ;-)

Class like OOP: Delphi and the draft Object Pascal standard; exceptions: C++

Assembler integration UCSD? Turbo? AT&T and Intel External references UCSD? Turbo? - Operator overloading Pascal-XSC -

Ideas from C++

Function / Procedure overloading Delphi -

Ideas from C++ (FPC had it long before Delphi)

Dynamic arrays Delphi - Variants Delphi - Arrays as parameter enhancements Delphi Open arrays, partial arrays

This was already available in TP

Bitpacked Structures Native FPC -

Mac Pascal dialects

Generics Native FPC -

Ideas from C++

Show quoted text 18 lines
Thread Programming Native FPC? Delphi? Bringing threads to language level In case I miss something that you know, please add. Note that these features are related with language construct, not technical one (i.e. compiling speed, makefiles). ------------------------------------------------------------------------ View this message in context: Origin of FPC features <http://www.nabble.com/Origin-of-FPC-features-tp21927731p21927731.html> Sent from the Free Pascal - General mailing list archive <http://www.nabble.com/Free-Pascal---General-f683.html> at Nabble.com. ------------------------------------------------------------------------ _______________________________________________ fpc-pascal maillist - http://lists.freepascal.org/mailman/listinfo/fpc-pascal
Gerhard Scholz
to leledumbo: I'm writing a paper about FPC and I need references where each language feature comes…

Bitpacked Structures:

The first time I've seen bitpacked structures (arrays & records) was on the pascal compiler for Control Data machines, about 1980.

If I remember right, it was the original ETH Zürich compiler, made by someone of the Wirth staff.

( the keyword BITPACKED was not used, it was done by PACKED)

GPC also has bitpacked stuctures.

Greetings

Gerhard

Earlier message 31 lines
----- Original Message ----- From: leledumbo To: Sent: Tuesday, February 10, 2009 5:56 AM Subject: [fpc-pascal] Origin of FPC features I'm writing a paper about FPC and I need references where each language feature comes from. So far, these are my what I know (some are guessing though): Feature Original Dialect Additional Information Separate compilation UCSD Pascal Unit based, not module (like Extended Pascal) Primitive OOP Turbo Pascal C++ like Modern OOP (including exceptions) Delphi Java like, though FPC was born before Java ;-) Assembler integration UCSD? Turbo? AT&T and Intel External references UCSD? Turbo? - Operator overloading Pascal-XSC - Function / Procedure overloading Delphi - Dynamic arrays Delphi - Variants Delphi - Arrays as parameter enhancements Delphi Open arrays, partial arrays Bitpacked Structures Native FPC - Generics Native FPC - Thread Programming Native FPC? Delphi? Bringing threads to language level In case I miss something that you know, please add. Note that these features are related with language construct, not technical one (i.e. compiling speed, makefiles). ------------------------------------------------------------------------------ View this message in context: Origin of FPC features Sent from the Free Pascal - General mailing list
Marco Ciampa
to leledumbo: I'm writing a paper about FPC and I need references where each language feature comes…
leledumbo wrote 6 lines
I'm writing a paper about FPC and I need references where each language feature comes from. So far, these are my what I know (some are guessing though):

PLEASE write down a page/table on the fpc/lazarus wiki. I think this could be useful for many fpc users out there...

Marco Ciampa +--------------------+ | Linux User #78271 | | FSFE fellow #364 | +--------------------+
Frank Peelo
to Florian Klaempfl: Class like OOP: Delphi and the draft Object Pascal standard; exceptions: C++ Ideas from…
Florian Klaempfl wrote 9 lines
leledumbo schrieb: >I'm writing a paper about FPC and I need references where each language >feature comes from. So far, these are my what I know (some are guessing >though): > >Feature Original Dialect Additional Information >Separate compilation UCSD Pascal Unit based, not module (like Extended >Pascal)

Yay, go units! Pascal supports separate compilation -- as opposed to C, which just tolerates it.

Show quoted text 6 lines
>Primitive OOP Turbo Pascal C++ like >Modern OOP (including exceptions) Delphi Java like, though FPC was >born before Java ;-) Class like OOP: Delphi and the draft Object Pascal standard; exceptions: C++

By "Class like OOP", do you mean properties? Or only being able to declare them on the heap, instead of allowing the programmer to choose?

Just curious about what the dividing line between "Primitive OOP" and "Modern OOP" is considered to be, because TP's objects already had inheritance, polymorphism, public vs private and all that good stuff. Apart from the name change and having to be on the heap, ISTM it was more an evolutionary process for a few years, OOP just got new features with each new compiler release.

>Assembler integration UCSD? Turbo? AT&T and Intel

TurboPascal got inline assembler in v6 IIRC. (Previously one had to do the assembly externally, and use "inline()" or "external" to put the bytes into the program.)

>External references UCSD? Turbo? -

What they then? functions & procedures in another unit? Or externally-assembled code?

UCSD Pascal had an "External" for procedures and functions defined in separate assembler files. TP 3 also had it; maybe previous versions too but I'm not that old.

Frank

Ken G. Brown
to leledumbo: I'm writing a paper about FPC and I need references where each language feature comes…

From:
<http://faculty.frostburg.edu/cosc/htracy/COSC450/MODULES/PasM2Ada.htm> re: Pascal
It was originally designed, by one man, Nicholas Wirth, for teaching structured programming.

Ken G. Brown

leledumbo apparently wrote 12 lines
I'm writing a paper about FPC and I need references where each language feature comes from. So far, these are my what I know (some are guessing though): Feature Original Dialect Additional Information Separate compilation UCSD Pascal Unit based, not module (like Extended Pascal) Primitive OOP Turbo Pascal C++ like Modern OOP (including exceptions) Delphi Java like, though FPC was born before Java ;-) Assembler integration UCSD? Turbo? AT&T and Intel External references UCSD? Turbo? - Operator overloading Pascal-XSC - Function / Procedure overloading Delphi - Dynamic arrays Delphi - Variants Delphi - Arrays as parameter enhancements Delphi Open arrays, partial arrays Bitpacked Structures Native FPC - Generics Native FPC - Thread Programming Native FPC? Delphi? Bringing threads to language level In case I miss something that you know, please add. Note that these features are related with language construct, not technical one (i.e. compiling speed, makefiles). View this message in context: <http://www.nabble.com/Origin-of-FPC-features-tp21927731p21927731.html>Origin of FPC features Sent from the <http://www.nabble.com/Free-Pascal---General-f683.html>Free Pascal - General mailing list . _______________________________________________ fpc-pascal maillist - http://lists.freepascal.org/mailman/listinfo/fpc-pascal
OCTAGRAM
to Florian Klaempfl: Class like OOP: Delphi and the draft Object Pascal standard; exceptions: C++ Ideas from…
> Assembler integration UCSD? Turbo? AT&T and Intel

Should it be considered as idea?

> External references UCSD? Turbo? -

This one as well. A very basic feature.

> Operator overloading Pascal-XSC - Ideas from C++

C++ originated in 1991 or so. Operator overloading was in Ada 83 (which itself existed some time before ISO standard)
http://archive.adaic.com/standards/83lrm/html/lrm-06-07.html

> Function / Procedure overloading Delphi - Ideas from C++ (FPC had it long before Delphi)

Again, Ada 83 :)
http://archive.adaic.com/standards/83lrm/html/lrm-06-06.html

> Bitpacked Structures Native FPC -

Again, Ada 83 :)
http://archive.adaic.com/standards/83lrm/html/lrm-13-04.html

> Generics Native FPC - Ideas from C++

Well, Ada 83 also had generics, but they might differ from FPC's ones.

Thread Programming Native FPC? Delphi? Bringing threads to language level

Ada 83 had them already, but FPC's implementation might be a bit different.

From one point of view, FPC developers usually don't know Ada (there is an

opinion that FPC hadn't happen if its founders knew Ada that time). From another point of view, FPC developers and Ada compiler developers are working on a similar problems and are likely to produce solutions that are very similar.

View this message in context: http://www.nabble.com/Origin-of-FPC-features-tp21927731p21953620.html Sent from the Free Pascal - General mailing list .
Florian Klaempfl
to OCTAGRAM
Show quoted text 11 lines
>> Assembler integration UCSD? Turbo? AT&T and Intel Should it be considered as idea? >> External references UCSD? Turbo? - This one as well. A very basic feature. >> Operator overloading Pascal-XSC - > Ideas from C++ C++ originated in 1991 or so. Operator overloading was in Ada 83 (which itself existed some time before ISO standard) http://archive.adaic.com/standards/83lrm/html/lrm-06-07.html

Not in FPC.

Show quoted text 5 lines
>> Function / Procedure overloading Delphi - > Ideas from C++ (FPC had it long before Delphi) Again, Ada 83 :) http://archive.adaic.com/standards/83lrm/html/lrm-06-06.html

Not in FPC, when I designed overloading, I knew nothing about Ada so the ideas came from C++.

>> Bitpacked Structures Native FPC - Again, Ada 83 :) http://archive.adaic.com/standards/83lrm/html/lrm-13-04.html

See above.

>> Generics Native FPC - > Ideas from C++ Well, Ada 83 also had generics, but they might differ from FPC's ones.

See above.