Slashdot Mirror
A Brief History of Programming Languages?
Aviancer asks: "French computer historian Éric Lévénez has compiled a family tree of programming languages that I found quite interesting. This prompted me to wonder if there was any controversy on the issue of language lineage and my searches found another page on the same topic. I thought I'd pull an 'ask the audience' to see if there were any corrections on either (both?) pages to be made." What other computing language origins are you aware of that may not be mentioned in either page?
It is (a) percursor to object-oriented languages such as Smalltalk and C++, and was the first strongly-typed language (Python being the most recent.)
Try not. Do or do not, there is no try.
-- Dr. Spock, stardate 2822-3.
Might have been updated lately, though. Always interesting, though. There's one for UNIX, too.
"These people look deep within my soul and assign me a number based on the order in which I joined" --Homer re:
here, maybe?
Where's the equal time for creationism? I don't believe in this "evolution" stuff. I think God created .NET (cough, cough) and then rested on the seventh day.
And it was good.
Then, root created 1.
And that, too, was good.
Then, root created assembly.
And that totally rocked.
Then root created HCF.
And it was very, very bad.
Obliteracy: Words with explosions
I don't see INTERCAL on there anywhere. Of course since it was written to be different from all existing languages, it can be kinda hard to fit in a language tree.
The most significant programming language of them all is not even listed.
This is prolly the Slashdot record of n-ple repeated article. This comes up every few months :-O
They have transparantly missed out BBC BASIC. A BASIC language, which included some of the better programming constructs of Pascal.
Half of the UK's current programmers cut their teeth on the BBC Micro/Archimedes BASIC implementations.
I learned to program with GWBasic, QBasic, TurboPascal, Modula-3 - none of which made it into the chart...
Oh maybe that's why they called it a "Brief History".
An Indian-American Hindu committed to non-violent thought/speech/action alarmed by the global explosion of radical Islam
Neither diagram shows any, but I think it could be argued to exist--the keywords struct and union, long and short (note that the "at least 64-bit type" C9X mandates is called long long int, just as it would likely be called in Algol 68 for a target where int is 16 bits), the notion of coercion. (There may well be others I am overlooking.)
The pascal branch seems to die out around 1996ish. I remember using it in 2nd year programming as a teaching language. That was in 1995.
Is Pascal all but dead?
What do schools use now as the teaching language? Surely not C. I have nothing against it but it isn't for beginners.
The Caml language (pronounce "Camel") is missing.
Caml is a programming language, easy to learn, easy to use, and yet amazingly powerful.
It is developed and distributed by INRIA (the main French research institute for computer science), since 1984. It is freely available for Unix, PC or Macintosh.
There exist two flavors of Caml: Caml Light and Objective Caml. Caml Light is merely a subset of Objective Caml, especially designed for teaching and learning the art of programming. In addition to the Caml Light's core language, Objective Caml features a powerful modules system, full support to object-oriented paradigm, and an optimizing compiler.
More information here.
They misspelled:
The Devil -> Fortran I
Plankalkul ??
Believe it. The only thing it influenced was the name.
I think they forgot Movie++, which of course, runs on MovieOS. It's a great programming language, you navigate classes and objects in full blown 3d floating experiences!
Every video can be programmed to zoom up until you can see microscopic particles WITHOUT any loss of resolution!
My personal favorite is when hackers run virus attacks against giant "Gibson" computers. See, you just don't get a BSOD, you get an awesome 3d graphic eating your desktop!
IGB: More fun than eating oatmeal!
I suspect that by "runtime typed" you mean dynamically typed (typing determined at runtime). A language can be both strongly typed *AND* dynamically typed. Their orthogonal.
;) ]
dynamically vs. static
strong vs. weak.
Perl is dynamic and weak
Lisp is dynamic and strong [or static and strong if you want
A similar historical relationship of programming languages was featured in a "centerfold" of Wired within the past two years. I forget the exact issue, but was more colorful. Unfortuneately, wired.com tends to not put these up on their web archieve. Any one else remember this?
Nice... but is it really neccessary to list tiny little update releases for current languages? And what precisely "defines" a language here-- should we treat SML/NJ as a different language than SML, because it supports continuations? Or current GHC as something other than Haskell98 because of its rank-n polymorphism and built-in support for arbitrary Arrows? And if drafts are in there (Fortran 2000), what about other drafts (ML 2000)?
And, finally, where's Scala (http://scala.epfl.ch/) on that graph?
Assembly Coders - these are extinct group of primitive form of life
before the advent of culture and civilisation, althought without access
to any formal human-recognizable language structure they were amazingly
versatile in their skills to construct reality by pushing and popping strings of
little pebbles from holes dug in the ground. Ancient arcade machines
sometimes found in desolate pubs testify to their once glorious existance.
C - C Programmers are more like highly evolved alien beings from outer space
who spoke purely in binary and pointers. They often take the disguise as
unsightly middle aged man with beard and glasses amongst earthlings.
They do not care for the artifacts of language or culture, they only care
for the semantics. Their job is to construct and engineer the roads,
the transportation, the network lines, the infrasture that our civilazation
have come to depend very much on. They are very hard to communicate with as
intepreting their language requires unusually greater IQ than most of
our earthlings can aspire to.
C++ - C++ Programmers are born again C programmers who realised their
folly of seeing the world in pure binary and pointers. They want to see
reality more concretely thus they talk in objects and classes.
More often than not, C++ Programmers are still attached to their
old ways and their attempts to communicate with others often result
in abstrated hodgepodge just as complicated as the C
language. Most C++ Programmers feel they may have had a
deprived childhood.
Java - Java Programmers are like C++ programmers except they were
brought up in aristrocat families. Their manners in their language
are refined and elegant althought at times may appear slightly
pretentious and artificial. They are very socially closed and
mix with their own kind only, basically they dont like outsiders
playing in their upper-middle class private school sandbox.
Being economically previliged means they have ample access to inheritance
like network libraries, etc. Although their reputation is good amongst
corporate circles, they are rumoured to be impotent when it comes to GUI.
Visual Basic - Visual Basic programmers are perceived to be like your
every day a dime a dozen computer science graduates. They
are naive, confident and sometimes a little brash in their perceived
ability to deal with the real world. Their language developed from high school
jargons and street slang though highly vulgar in the eyes of other programmers,
were often effective (or adequate) in solving a lot of every day
ordinary kitchen and sink problems. Often the case, a job completed
by a Visual Basic programmer, thought cheap and fast leaves little to be desired,
tales of half patched pipes leaking from under kitchen sink are
well known in the industry.
C# - C# Programmers are Java programmers wannabes wanting to achieve the same
social status and previledge that Java programmers have, C# programmers
lacks the authentic social grace and ethics that could help them rise above the
Visual Basic suburbia coarse mentality that tends to predominate them. C# Programmers
also tends to like screen widgets that are glitzy. They are the type of people
that the marketing department love to target in their product focus group.
COBOL - Cobol Programmers are not really people, they were actually mutated
from hole-punch card readers. they have no human affectations
and thus are very capable of churning out millions of incredibly mundane and
humanly degrading pages and pages of printed accounts reconciliation codes.
although they were disbanded by the human rights organisation, Cobol
programmers were actively recruited just before the millineum to solve the Y2k bug
which they were originally responsible for.
Fabled Programmers - the are many species of programmers that claim
to exist but no one have ever met any of these illusive creatures in
Really
;)
"It is a greater offense to steal men's labor, than their clothes"
At least it is an interesting read. Actually, I like OOP somewhat. When it is not overdone.
><////>
Python is a strongly typed language. It is in the class of strongly- and dynamically-typed languages. Read this article on Python's type system for a good overview and a little information on "type" terminology.
the growth in cynicism and rebellion has not been without cause
Same site
"These people look deep within my soul and assign me a number based on the order in which I joined" --Homer re:
I've had the O'Reilly poster on my wall since they released it. So when I saw the graphic on this guy's site, with a January 16, 2005 copyright, and no reference of O'Reilly's poster, I thought it smelled fishy.
g _lang_pos ter.pdfh tml#02
Just take a look at the two images:
http://www.oreilly.com/news/graphics/pro
vs
http://www.levenez.com/lang/history.
and tell me you don't see the similarities.
Anyway, so I thought this guy ripped off O'Reilly's poster, but, as it turns out, if you look in the small print on O'Reilly's poster, you'll see that he was the legitimate creator of the image. I even realized that it's been updated a little bit since O'Reilly released it.
So, yeah, we've seen this story before, however, the link provided in the summary above is new and newsworthy, becuase it gives more links to learn about each individual and family of languages and updated the previous graph.
She loves me: 09F911029D74E35BD84156C5635688C0 She loves me not: 09F911029D74E35BD84156C5635688BF
Dynamic vs. static (or runtime vs. compiletime) and strong vs. weak. Dynamic/static typing is determined by when the type requirements are detected and enforced. C is statically typed - there's no runtime manipulation (or even concept of) types at all. C++ is mostly statically typed but has some runtime typing capabilities. Java is largely statically typed but also checks types at runtime. Python is entirely dynamically typed.
Strong vs. weak affects what kind of type operations are allowed. Typeless (or single-type) languages like TCL are the weakest type, because they allow any operation on any type. Perl has multiple types but does lots of implicit conversions, making it weakly typed. Python performs very few implicit conversions (mostly between different representations of float) and therefore is strongly typed. Pascal doesn't even allow type conversion between pointers or different sizes of arrays and is therefore *really* strongly typed.
There's also some other characteristics of typing, like whether it's class based (C++), does or does not allow user defined types, distinction between UDTs and primitive types, Objects vs primitives, duck typing, etc.
...though I feel you are rather lucky having the last entry fall off the edge of the post and thus reduce significantly the flameage you may get.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
For those, like me, who have no idea what this guy is talking about, see this.
Fortran is always shown as having come from a vacuum, but surely it was inspired by the various "Autocode" languages, of which "Mercury Autocode" is the most famous. (Note: this was all before my time.)
:= ("x", 42);
Smalltalk is derived from Alan Kay's earlier language, Flex, which in turn stole heavily from Euler (Kay confirms this), which was the language Wirth designed before he did Pascal.
Euler was an early example of a dynamically typed, garbage collected language with an algol-like syntax. Now we have python, javascript, and so on.
Python is heavily based on ABC.
Euler must have been a primary influence on Setl, which in turn influenced other languages. Setl was a dynamically typed, garbage collected language with an algol-ish syntax, with arrays (called tuples) and sets as first class values. The List comprehensions of Haskell (and more recently Python) come from Setl. Setl is the first language I know to have the 'slice' notation for extracting subranges from a list:
list(i:j)
list(i:)
Although, i was 1 based, not 0 based, and j was a length, not an index. This slice notation was picked up by Icon, which changed j from a length to an index, and introduced negative indexes. From Icon, slice notation migrated into Python, presumably via ABC (I have no ABC documentation to check), where indexing changed from 1 based to 0 based.
The type names in C all seem to come from Algol 68. They couldn't have come from B or BCPL, which do not have types. Examples of C/Algol 68 type names include "int", "char", "long int" and "void", as well as "struct". This is C:
struct {char c; int x;} s = {'x', 42};
This is Algol 68:
struct (char c, int x) s
Algol 68 has a +:= operator, but I think that comes from C. This is speculation, based on the observation that C's += operator was originally spelled =+, then changed due to the ambiguity of parsing x=+y.
The second link shows Javascript decended from Java, which is surely wrong. Javascript was developed with no knowledge of Java. It was originally called LiveScript, then changed to Javascript for marketing reasons. I'm pretty sure that Javascript/Livescript got its object system from Self, the first prototype-based object oriented language. Self descends from Smalltalk.
I have written a truly remarkable program which this sig is too small to contain.
Lucky you. Maybe you can learn something useful then, instead of doing the trendy stuff.
So far the teacher said the only use it for AI.
Unlucky you. You have an idiot teacher that can't even explain why lisp is so great. Think about this: AI is the hardest problem computer scientists ever need to solve. If a language is good enough to be used for research in AI, it's good enough to solve most any other problem too.
The only problems with lisp are cultural. Many lispers are elitists who don't care for stuff other programmers need, such as distribution of binaries, portability between lisp-implementations, a standard, etc... And most mundane programmers hate lisp because it has lots of silly parentheses.
I don't really care for it, good thing its only once a week.
Try to pay attention. You might learn something.
The Smalltalk implementation Squeak is AWESOME. With their eToys you can do amazing things without typing any code. It is truly a wonder to behold.
Engineering and the Ultimate
The hardware isn't the problem. There's plenty of processing power to do something like that. The problem is that nobody has figured out how to make a programming environment that is both powerful and flexible like modern programming languages, yet extremely simple like legos.
I suppose one could produce a graphical version of a current programming language, but that would be very complicated and slow to use.
If you can figure out how to write something like this that creates large applications like Firefox, Word, or Visual Studio, you'd stand to make a fortune.
Plankalkül was developed in the first half of the 1940ies by Konrad Zuse.
Wikipedia has(as usual) for more information.
It's true on both time and causality.
Alan says so himself here
Read more of this story at Slashdot.Read more of this story at Slashdot.Read more of this story at Slashdot.
I suppose it is inevitable that something like this shows uneven treatment of different areas.
For example, it seems to list about every time a vendor released a Java version, showing version numbers with 3 digits as worthy of note. By that kind of accounting, there should probably be several thousand Fortran entries.
- Snobol, which didn't spread much, but eventually merged with a Fortran derivative to beget Perl.
- Flowmatic, which became Cobol, then Rexx.
- Fortran 1, which became pretty much everything else, via Algol. This is the main part of the main stream.
- Lisp, the other main stream, which joined with Fortran to make Scheme, and joined with it again to make Dylan.
- Prolog, which joined up with Lisp
- APL, which continues today (unlike Snobol) and has some recognizable descendants (unlike Snobol and Flowmatic).
- ISWIM and
- ML which are the only ones that I'd never heard of before, though I recognize their descendants Haskel and Camel.
This ignores sh and SEQUEL, which stand almost entirely alone.There are two main streams, Snobol/Flowmatic/Fortran and Lisp/Prolog. There isn't much communication between them. Their two points of convergence, Scheme and Dylan, so far show no signs of spawning the sort of tree of descendants which sprung from their ancestors, Fortran and Lisp.
ISWIM/ML and APL have almost no communication with either of the mainstreams. Chopping either of them out of the picture would leave few orphaned hybrids.
All those languages from just seven big ideas.
See what I've been reading.
And then there's a whole different class of langauges: math packages that allow programming from within. Heck, minesweeper is even included in Matlab as an example. You an define classes, new data types, etc. I know that quite a bit can be done in Mathematica and Maple as well.
It'd be interesting to see where these fit in, since they have some elements of various languages. (e.g., in Matlab, indexing starts at 1, but much notation is C-like, and some other things are very Java-like.) -- Paul
OpenSource.MathCancer.org: open source comp bio
Also, what about the lead-up to Visual Basic? More or less, after QuickBasic 4.5, we got PDS 7.1 (IIRC - Professional Development System - essentially QB4.5 with some DOS windowing enhancements and a slightly modified IDE), then came Visual Basic for DOS (still a lot of similarities to QB4.5 and PDS 7.1 - but with much greater control of windowing capabilities, and I think it allowed for easy mouse integration and event-driven code routines), then VB 1.0, I think (for Windows 3.1? Can't remember)...
QBASIC 1.1 was some weird thing they threw into DOS around version 5 or so, and kept in some form or another all the way through Windows 98 or so. It came out after VB for DOS - it may have even been released after VB3.0 (??) - strange release...
Reason is the Path to God - Anon
So, Perl is indeed strongly typed (for built-ins), and late-binding dynamically typed (for references and user-defined types).
How could they possibly miss my two languages? COW is a revolutionary system allowing for easy entry of bovines to the computer industry. There is a clear human bias in the list presented here.
There's also Whirl which was designed as an advanced and modern Java replacement.
I don't see why these two critical and important languages weren't included. I feel shocked and saddened by the dreadfully low academic standards represented here. Shocked, I tell you.
Hexy - a strategy game for iPhone/iPod Touch
There is no line from SCO unixware to linux
Maybe if you changed it to under 30...
Common Lisp is strongly, dynamically typed. It has been for a long time. There are, of course, other language attributes than strength and time of datatyping, but those are what you're talking about.
Common Lisp is also object-oriented and beats every other language I know in that arena.
On top of that, with a good Lisp compiler (such as SBCL, CMUCL, or even GNU Clisp, just to name a few free compilers), it is as fast as any other language, even statically typed languages such as C; but particularly faster than other dynamically typed languages.
For those of you out there who are into this stuff:
I had a nice course on this once, discussing all sorts of programming languages. Both their histories, and their design decisions. Most importantly, they did it by a quite nice book:
Concepts of Programming Languages.
Starting with simple constructs and the way they are used, leading up to all the different decisions between languages and their reasons, and splitting off into the different paradigms in programming, it is a MUST HAVE for any CS student. I kid you not. It's damn expensive, but reading it learned me the global view of all the languages out there. Because of it, taking up a new language is much easier since I now can classify it and know what generic specifics to expect.
As said. Get it. Or check the library. I'm guessing any university library with a CS department worth it's salt has one (although possibly older versions which are fine as well).
Fwiffo
At UNI (15 years ago) one of the lecturers had written an OO language that we all had to use in his subject. A bit like ADA but with looser typing. At my last job (a large Financial institution) they had written their own finacnial programming language called A+ for their IBM mainframes.
COBOL programmers were not responsible for the Y2K bug. Jesus was. We were just the ones to profit most from it.
Sig not available, please try again later. If the problem persists, then the submitter is an idiot.
Currently still being developed and used globally, with at least 750,000 + users all around the world.
Currently offered by multiple vendors, runs on all Unix, Linux, M$ systems, except maybe on the 'big iron' IBM boxes. Current vendors with products that are supported are Thoroughbred, Basis, and Providex.
Fortran showed it what NOT to do to be Basic!
Watch for Penguins, they eat Apples and throw rocks at Windows.
1. The PDF chart lists .Net as a separate item and links each of the supported MS languages to it. I think this is an accurate representation.
2. ASP = VB6. You could include ASP as an offshoot of Visual Basic if you like, but it has exactly the same snytax. The real changes came with VB.Net, which is included in both charts.
3. Dylan is included in the PDF chart as an offshoot of C++ and CLOS.
4. Nope, no Hypercard.
5. I suppose so. I don't really have any comment other than I'm not sure how legitimate sh is as a actual language.
6. Erlang is included in the PDF chart as an offshoot of Prolog and Common Lisp.
7. I don't see Cilk on either chart, which is funny since I'd actually heard of it before today. One could probably argue that it isn't different enough from standard C, but I think the implications of parallelism are probably enough to merit its own place on the chart.
8. Mercury is included in the PDF chart as an offshoot of Haskell, SML 90, and CLOS.
9. Funny, but you almost could do that... Is there any library or language that hasn't been grafted onto Perl at this point?
According to wikipedia, the "commercial variant" of Flow-Matic started in 1955. http://en.wikipedia.org/wiki/FLOW-MATIC Wikipedia lists FORTRAN as being developed in 1954-1957. However, the forbears of Flow-Matic definitely preceed FORTRAN, as you'll see below:
B-0 was the original name of Flow-Matic. More interesting perhaps is that both owe influence from A-0, a language developed for the Univac I, and the first language to have a compiler. (Flow-Matic was also developed for the Univac I.) For that reason alone, the tree should probably include it. (Perhaps even as the "root" of the modern languages.) One could argue that the inclusion of Flow-Matic on the chart encompasses A-0, although I would argue that A-0 should probably simply replace B-0 on the chart, since Flow-Matic and B-0 are one and the same.
http://en.wikipedia.org/wiki/A-0
// harborpirate
// Slashbots off the starboard bow!
http://www.cs.washington.edu/education/courses/cse 413/03au/misc/language-chart.jpg
RPG was first offered as a language on the IBM 704 computers in the 1960's and was even promoted as an end-user language--funny, until you realize that programming in those days was done in assembler, and the original RPG was at least a level higher than that. I recall when I was programming in RPG II on an S/34. The boss brought the entire computing staff of 3 people to attend a seminar in Structured Programming. In preparation for that, I was reading a book on Structured Programming in Basic (can't remember the author or exact title). The intro assured me that "you can do structured programming in any language, wheter it's COBOL, PL/I or (God forbid) RPG." We wer all laughing at that, as it is indeed hard to do structured programmming without loop constructs (use GOTO) or even an if/else statement (use indicators). But, as you say, RPG has evolved since then and is even moving to free-form instead of the original form-filling metaphor.
I guess I'll just print this out as the second page on my resume as a timeline of what languages I know and when I learnt them.
Then prospective interviewers can't point out my current 8 years of C# experience is a lie.
---- The geek shall inherit the Earth.
Alan Kay also credits influence of LISP in the essay, as shown in the Levenez chart
HyperTalk had about a kajillion users. It certainly deserves a place in this geneology. I'm not sure exactly where to put it, but it's certainly related to Smalltalk as a close cousin if not a descendant. For completeness, AppleScript should be listed as a descendant of HyperTalk.
I don't know why the PDF lists C++ as an ancestor of Dylan. I was somewhat involved in the development of Dylan, and Scheme, CLOS and Smalltalk were the main parents.
Squeak is the current leader of the Smalltalk bloodline. www.squeak.org
I could not find any reference in either list to Xerox PARC's Mesa, which is often credited as one of Wirth's inspirations for Modula-2.
re: the first one http://www.levenez.com/lang/history.html it is BASIC, not Basic. Also, there was MS-BASIC, GW-BASIC, BASICA, Apple BASIC, MS QBASIC, MS QuickBasic, QuickBasic Extended/PDS. Also, they list JScript, and not VBScript; PHP and not ASP. Also, this one is missing Rexx. http://people.mandrakesoft.com/~prigaux/language-s tudy/diagram.pdf seems to have some data that is off to the right of the page, including what appears to say "PostScript".
Video Production Support
I suppose one could produce a graphical version of a current programming language, but that would be very complicated and slow to use.
Take a look at LabView at some point
While it is primarily aimed at test and measurement applications, anything that can be done in a general purpose programming language can be done in LabView.
but that would be very complicated
It's not overly complicated. In some ways, it is significantly less complicated that text-based languages. For example, if you have a function (VI is labview terminology) that is blocked, it will automatically run other code that does not depend on the output from the blocked function. I don't have to think about threading or setting up a polling loop since it is handled automatically. Also, things like 'Do I need to make a copy of this data?' are handled by the compiler rather than being explicitly specified by the programmer.
and slow to use
With regard to speed, I have a couple of reasonably complex LabView programs that are running on PII's in the 300MHz range with no issues at all. Labview complies to machine code, so there is no issue of interpreting the graphical language at run-time. If you can figure out how to write something like this that creates large applications like Firefox, Word, or Visual Studio, you'd stand to make a fortune.
Well, at a previous employer, we had a LabView application that queried data from a SQL database based on user-specified criteria, pulled statistical data from the results and wrote it into a report, and the created an excel spreadsheet from the queried data. I'm not sure that LabView is the best language for that sort of thing, but it will work.
As far as the fortune bit, at $2000+ for the development environment, I imagine that NI makes a tidy profit off of LabView. Add to that hardware sales for embedded systems and real-time controllers capable of running LabView programs and I have to think that 'fortune' is probably a good description.
Come test your mettle in the world of Alter Aeon!
And as usual, ColdFusion has been ignored by both. It was out before Rebol, Asp, PHP, etc. It's still running strong and it's a proof of concept that tag based languages (as now seen in JSP and Asp.Net) work. Where's the recognition?!?
Michael Dinowitz House of Fusion http://www.houseoffusion.com
The term *used* to cover languages where variables have types that can be (and conventionally are) checked at compile time.
However, since the term had strong connotations, advocates of languages where values have types that can be (and conventionally are) checked at run time, started claiming that their languages are also strongly type cjecked.
As a result, the term is today meaningless. What I use instead is talking about static typechecking (type errors detected by the programmer at compile time) and dynamic typecheckig (type errors detected by the user at run time).
Python rely on dynamic typechecking.
Well the strong/weak typing issue is pretty old fashioned.
... /* OK */ /* Compiler trusts you but shouldn't */
/* compiler trusts you */
Strong and weak typing is not about doing implicit conersions. It's about trusting what the programmer is doing.
K&R C was weakly typed (I'm reaching back decades here so cut me some slack). This was especially fun with pointers which were pretty much all just addresses to memory that usually were implemented as ints.
E.g.
int incrAt (int *x) {
return ((*x)+1);
}
int i = 1;
float f = 3.14;
i = incrAt(&i);
i = incrAt(&f);
ANSI C is more strogly typed:
i = incrAt(&f); / *compiler complains */
But, it is still happy to trust you if you insist:
i = incrAt((int *) &f);
Strong typing doesn't have anything to do with implicit conversions, in my opinion. Consider the following expression:
2 * 3.5
What every sensible language does is this (in prefix notation):
floatMult(intToFloat(2),3.5)
as opposed to:
intMult(2,2.5)
or
floatMult(2,3.5)
which would give the wrong answers. The situation is not different for complex types like objects where there are well defined operations and type promotion schemes.
What strong typing vs. weak typing is, or was about in any case, was safety vs. the amount of work the compiler or runtime system had to do.
These days with powerful systems and overcomplex problems, safety is paramount.
With respect to static and dynamic, they mean exactly as you say.
Post may contain irony: discontinue use if experiencing mood swings, nausea or elevated blood pressure.
Don't see the language JOVIAL. We should. Used in many, many USAF systems, JOVIAL was a true precursor to Ada, and influential in its own right.
If nothing else, JOVIAL should be recognized for the role it plays in things-that-go-BOOM, and therefor in the flow of world history.
However, JOVIAL is significant computationally for the way it introduced real-time extensions, suport for embedded systems, and for very-large-scale systems engineering.
That's a better idea. Putting "BrainFuck" on your resume will doubtless highly speed up its evaluation by most potential employers.
//Information does not want to be free; it wants to breed.
I'll bite on this troll because it plays on so many misconceptions.
[Lisp] has never produced anything of use (actually maybe, but I'm keen to hear of some *large* *all-lisp* program that does something truly useful
How about an entire operating system? Or have you never heard of Lisp Machines? A full-blown editor, or have you never heard of Emacs? How about a state-of-the-art compiler with incremental compilation, on-demand linking, better-than-human-hands optimization, or have you never heard of Common Lisp?
[L]isp is the *worst* language to start out with. For exactly the reason you point out. utterly horrible syntax. And that's all you worry about as a beginner learning lisp.
Have you spent time teaching programming courses? I have. Have you studied the pedagogy of programming? I have. When you teach programming based on C, and similar syntax-laden languages, you spend 1/2 to 2/3 of the course detailing syntax. When you teach Lisp or its derivatives, you spend one week on syntax, and the rest of the term on concepts. Why? Because the syntax of Lisp is incredibly simple and this frees the course to concentrate on more important issues in programming.
((((((((((neq lisp simple))))))))))))))
oh crap! to many close paransss...
You probably never used an editor that had proper indenting and parenthesis matching. In Emacs (and related editors like Epsilon, Jove, microemacs, mg, etc.) you never wonder how many parentheses you need because it's obvious. Parentheses are not a burden.
Put my fist through my alarm clock with its ding-dong death inside my ear. - The Blackjacks.
Would you have students learn to read German as part of a philosophy class so that they can study the Germanic greats in their native language? Probably not, because the particular laguage used to express deep concepts is more-or-less irrelevant. Instead, you would use the one easiest for the task. In the US, it would probably be English. In France, French. In Japan, Japanese.
So when you're trying to teach programming -- not just training someone how to use a particular software house's tool -- why not use a language that best exposes the most important issues without obfuscating them with the arcana of syntax?
Here's another analogy, if you want to teach someone to drive, do you teach them using a tractor? It would work, right? The same basic principles and laws apply to driving tractors, busses, cars, and trucks. But you probably wouldn't want to use a tractor (bus or truck) because they're particularly difficult and quirky to control. You'd probably use a car, and, at least in the US, probably one with an automatic transmission. You would do this because cars the easiest vehicular form to control, allowing the student to quickly master the concepts around controlling their vehicle and concentrate on the more important aspects of driving such as the conventions and laws surrounding interacting with other drivers. In a similar way, Lisp (or Scheme, my personal variant) allows the student to quickly get to deeper issues in programming because the syntax is so simple.
Put my fist through my alarm clock with its ding-dong death inside my ear. - The Blackjacks.
Ahhhh! And *NO* mention of dbaseII, dbaseIII, or even of dbaseIII+ !
Not every programmer is a Software Engineer.
And I'm doing everything I can to correct that.
Put my fist through my alarm clock with its ding-dong death inside my ear. - The Blackjacks.