Slashdot Mirror
Why We Need More Programming Languages
snydeq writes "Fatal Exception's Neil McAllister writes in favor of new programming languages, given the difficulty of upgrading existing, popular languages. 'Whenever a new programming language is announced, a certain segment of the developer population always rolls its eyes and groans that we have quite enough to choose from already,' McAllister writes. 'But once a language reaches a certain tipping point of popularity, overhauling it to include support for new features, paradigms, and patterns is easier said than done.' PHP 6, Perl 6, Python 3, ECMAScript 4 — 'the lesson from all of these examples is clear: Programming languages move slowly, and the more popular a language is, the slower it moves. It is far, far easier to create a new language from whole cloth than it is to convince the existing user base of a popular language to accept radical changes.'"
Only language we ever needed was C. You putzes just aren't using it right.
/flamebait friday!
.
Obligatory XKCD. http://xkcd.com/927/
'But once a language reaches a certain tipping point of popularity, overhauling it to include support for new features, paradigms, and patterns is easier said than done.' PHP 6, Perl 6, Python 3, ECMAScript 4 — 'the lesson from all of these examples is clear: Programming languages move slowly, and the more popular a language is, the slower it moves.
What's wrong, Slashdot? Where's the editorializing?
It's interesting that Google took part in abandoning ECMAScript 4, which would have been almost fully backward compatible with current implementations while solving most of the "fundamental problems" Google claims require a brand new language to fix.
Seriously I'm sick and tired of defending new languages like Clojure, Go, Dart, Ruby, etc. I'm just going to shut up and let the dinosaurs stagnate and get stuck maintaining all the old code for the rest of their unenjoyable never changing ruts.
My work here is dung.
Easier != Better
OMG!!! Ponies!!!
and C#
Don't really agree. Just look at the popularity of "Go".. if you don't know what it is try googling it, oh yeah....
The reason popular languages move more slowly is because established codebases use them. Backwards compatibility is a good thing. If C++ was radically changing all the time, code that compiled a year ago wouldn't run anymore. Stability and predictability are just as important, if not more so, than radical change when it comes to real-world development.
Algol for Web, COBOL beans, Object Oriented PL/1 ...
A feeling of having made the same mistake before: Deja Foobar
Lets just say that languages designed by committees look that way.
Seriously, choices are always better. My tool (normal tools not software tools) contains two different types of hammers, two different wooden mallets, several different screwdrivers....... If you learn to use the right tool for the job, the different choices make since. If you are stuck on the mentality of "All I need is a bigger hammer" and "All I need is XXXX programming language" then you probably are not using the right tool for the job.
As long as a new version of a language maintains existing capabilities, there is no barrier to adding new features. Or like Groovy, just extend to add the features you think are needed but keep the output compatible with the "parent".
It's notable that the Tiobe Index has just one 21st century language among the top ten (C#, 2001). http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
org.slashdot.post.SignatureNotFoundException: ewg
As long as there are working applications implemented in these languages they'll never go away.
Not to mention old dinosaurs like me will be employed until we're 80 working with these stone-age tools. Plblblblblblbl (*sound of raspberries*)
... , just different.
– The paradigm paradox.
from www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf (Programming Paradigms for Dummies: What Every Programmer Should Know)
Probably worth considering before starting to discuss the issue. The conclusion then could be that a more general paradigm shift is needed.
CC.
TaijiQuan (Huang, 5 loosenings)
With C++0x we have the mutually exclusive aims of nice syntax and new features. The comes a point where maintaining legacy support impinges on the cleanliness of the language to such an extent that it becomes counter-productive. The whole point of a programming language is to express problems in a legible way. The new "enum class" syntax is a good example of how things can go wrong.
It's not C++ itself I have a problem with; it's that improvements to the language are made without breaking legacy support -- no compromise and at any cost. I'm not singling out C++ either; pretty much every language is upgraded in the same way. The difference with C++ is that it's that old and the changes are that great that the syntax additions become plain ridiculous in some cases. It would be better to start with a relatively clean slate and just-do-it-fucking-right.
I like the look of D as a succesor to C++, but unfortunately it doesn't seem to be getting any traction.
Function stretchass() { .cx, ru;
return
}
Jesus. One amusing comment followed up by your retarded reply which went out of fashion roughly two minutes before Beevis and Butthead was ever dumped on an unfortunate humanity, and "phil_aychio"'s reply, which if anything is even dumber.
And this ladies and gentlemen, this why I'll never dive into the world of coding aside from minor batch editing with PS commandlets . As an infrastructure system administrator (server, network, workstation, phones act), you have my deepest sympathies. I don't know how you do it. All of those long hours in the night, new programming languages every time someone farts, fear of being outsourced, moving targets and scope creep. Hats off to you all. As far as I'm concerned, screw that!
Life is not for the lazy.
I'll be programming the navigation system on your space shuttle using VB6. Have a nice trip! :)
It's notable that the Tiobe Index has just one 21st century language among the top ten (C#, 2001)
Java is on there as well, which C# was of course taken wholesale from. Yes C# has moved beyond where Java was, but if you are going to claim C# is a "21st century language" then you have to acknowledge also the other languages that have moved substantially - like Java for one (though it's slowing down for sure), and also Objective-C (which now has GCD/Blocks(closures)/ARC.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
The root cause of the problem is that versioned languages strive to be "backwards compatible" at all.
I've maintained for years that the proper solution is to create a new language standard that does not attempt to be compatible with the old language. Instead, the developers of the new language should provides a reference utility that converts from the v1 standard to v2 standard. This should apply to all incremental language revisions, so that users can upgrade the source and diff to see what changed before assuming that their applications will run correctly with the new language. Also note that creating the reference cross-compiler will help document the differences between v1 and v2.
p.s. Yes, I know this would cause a minor headache for standard library versioning, but it only has to be done once per language revision.
Today, most everything library based is C (*NIX weenie here, dunno about other architectures). And many problems have already been solved in one language or another over time, but its mainly C that has the ability to be called by other languages (Perl, python, C++, java, most everything). What we need is a better idl (http://en.wikipedia.org/wiki/Interface_description_language) or more of them. Ones that are performant, and able to do procedure calls, serialization/deserialization, etc.
Wrong with PHP example.
PHP was perfect from the start.. at being bad.
We don't need more, we need less. Just one. Forth!
If I didn't have absolutely NOTHING to do, I wouldn't be here.
Take C or Java. It is held back by a bad design choice from early in its life? Drop support for that particular syntax. If 15 year old source code won't compile, oh well, you were going to have to rewrite it anyway if you want to port it to a new language.
No language is perfect. The idiocy of language designs stem from the fact that few, if any programming languages were designed by anyone who had ever read a book on psychology, ergonomics or human factors.
There's a saying floating around the internet that "Languages should be easy to read and understand and incidentally be compilable by computers." That about sums it up.
THE COMPUTER DOES NOT MATTER. It is a means to an end. It's only purpose is to serve humans. The languages designed to provide a system level interface to that machine need to be designed around what a human understands, the way a human understands it. Slavish devotion to a hardware design, or even an object model is plain stupid if it makes your product nearly unusable (e.g. the WPF datagrid).
Please do not read this sig. Thank you.
Is it just me, or has almost every article by Neil McAllister made it to the Slashdot front page?
I propose
1) a "slashcallister" because it rolls off the tongue, and can be used to tag these articles (as part of the greater "slashonomy"), so that
2) McAllister's articles be picked up by Slashdot's server-side RSS reader and auto-posted & auto-tagged, thus creating the Official Slashdot Neil McAllister Channel
We have only ONE relational query language in common use: SQL. We need more options. SQL is hard to extend by DBA's, emphasizes nesting over named-references, has a messy COBOL-like syntax structure, and other annoyances.
We have bajillion app languages, but very few query language choices. There is the Tutorial-D language family which spawned REL, but it's more of a tight-typing/compiled style.
We also need something more dynamic. I've proposed a draft query language called "Smeql" (Structured Meta-Enabled Query Language, pronounced "smeegol") for such. You can "calculate" column lists using dynamic queries, for example.
It's a far far needier field than app languages.
Table-ized A.I.
Python is actually an example of how can a language continue to develop even after becoming popular. In a brave move, they didn't let backwards compatibility tie them down. By breaking compatibility, the language could continue to evolve: there are many new features in Python3. For this to work without breaking existing stuff, the __future__ module was invented, which allows creating 'forward compatible' code.
I think we don't necessarily need to constantly switch languages to evolve, getting rid of backwards compatibility is another way to go (or make the language very general like LISP).
A language is just a tool. In the hands of a bad programmer you get bad code no matter what the language. A good programmer can do good in most languages. Unfortunately most of the so-called improvements in new languages are merely the equivalent of library content.
Names!
As long as the binary format's correct and/or you're not filling /usr/bin or /usr/sbin, or wherever your OS stores binaries with interpreters... What's the problem? I mean, there's the problem of understanding the intricacies of a given language, but...
The real problem is that when all the clever names are taken.
Non impediti ratione cogitationus.
Forth more we need NOT less we need just one
Get your newfangled wheels here! This time it's in BLUE!
To be honest I find Python the scariest language. I write some pseudo code and it runs. Worse, it usually runs first time.
Deleted
Is there a need for new programming languages? Perhaps. But I don't think this is eternal. Programming is just the ability to express algorithms and logic. It's not an infinite space.
I think people moan about new languages when they don't appear to bring anything really new.
Broadly speaking... following one train of evolution.
assembler - abstract out op codes
C/C++ - direct hardware access... provides human word abstraction for programming (for loop, switch, variables, classes...)
java/c# - virtual machine based, easy library integration (just include the lib)
Those are big significant changes. It is preferable to add new things in these languages via frameworks, new libraries, code generators... for example QT is a huge framework and code generator, but at its core is still C++. You can easily link in any old c/c++ library or source code.
Creating a new language for syntax changes or anything is where I think people begin to moan.
And hold still while i paint you a new color.
---- Booth was a patriot ----
I think anyone just uses what he/she wants to and it doesn't matter if there are more languages out there. For the last 2 years I've been building a system in Java and I don't bother with any of the new nonsense in it that started with Java 5, I do use the latest JDKs and JVMs, but I don't use any of the new features (like annotations, autoboxing/unboxing, varargs, generics, etc.) It's completely unnecessary for me, it would be more useful to have standard ways to communicate with peripherals as part of standard libraries, but that's not getting done.
Building new languages seems sexy for people who don't have a specific business problem to solve, but that's OK too, there is enough room for more of the same, so go ahead.
You can't handle the truth.
"far easier to create a new language from whole cloth than it is to convince the existing user base of a popular language to accept radical changes."
I think we should apply that concept to human languages.
And if you dont agree with me then, sof ertes fidods as'd fguw !
Performance doesn't matter any more. Correctness and quick development does. FP provides that in abundance. (Of course, correctness is just another way to say "quick development" nowadays, but whatever...)
To adress some of your points:
1) Two words: undefined behavior. You'll find it around every corner in C or C++ (two very different languages, of course) -- this leads to unreasonably hard-to-find bugs. In C++ it's also extremely hard to avoid such behavior consistently -- compilers are happy exploit it for optimizations, but somehow can't provide warnings for all cases where you are (unwittingly) relying on UB.
2) Really? Haskell or Ocaml do not rely on any of those things you mentioned. Difficult? Perhaps, but see my point #1. Besides, who would you like making your software... someone who's just "learned java" or someone who knows what the fuck they're doing?
3) So all FP languages which don't perform as well as C (or order-of-magnitude at least) don't perform as well as C. What an insight. Btw, Haskell is also within OoM of C. Also, see the top of this post.
4) How hardware works is fucking irrelevant. If compiler for language X can optimize "fib N" to a constant expression it doesn't matter if your C compiler can generate code which executes a million iterations of a fib-computing loop per second. Certainly, we're not quite there yet, but in the C world there's no hope of doing this beyond *really* simple examples (aka not fib), but FP could conceivably get further. (TC is a barrier, but you can still do useful computation even without TC.) See also: top of this reply.
HAND.
Just be clear, I'm not calling anyone stupid (remember what Clinton said? no no no, not "I did not have sexual relations with that woman." the other thing he said. about the economy.)
Two thoughts:
First, in a way, this is a silly discussion. Of course we need new languages. All interesting software-intensive systems are full of little languages (we just write them ourselves in other standard languages).
Second, it really isn't about the programming language. Yes, different languages make you think/act/work/abstract in fundamentally different ways, but ultimately it is the programming model of the surrounding libraries that has a greater impact on one's productivity.
I wonder, how many of the languages listed on Freshmeat nee Freecode have people here actually used? Which ones do you know well enough to form a good, solid critique on what the language can and cannot do? Which compilers have you contributed code to?
Probably the answers would be "not many", "very few" and "almost none" respectively. And we're the geeks. We're the ones who are actually interested in this kind of stuff. Yet I'm willing to bet that even we couldn't form a sensible, rational, evidence-based opinion on "what is needed" because none of us has the breadth to know what has already been done and either found "not really to be needed at all" vs. "not used because nobody knows about it" vs. "a great concept but in the wrong language". Even we, the most obsessive bunch of nerds out there, simply don't have that kind of data. I reject utterly, therefore, the idea that anyone else is going to know so much more.
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
Please don't click the link.
Mad Software: Rantings on Developing So
Haha this from the man who made an unmeasurably lame "joke" that doesn't even make sense? You need to move out of your "mom"'s basement and quit being so defensive. If that involves paying a bored prostitute, even better, but it's entirely your choice if you'd rather get KBd instead.
We need more programming languages like we need blinking text on webpages. What we really need is newbies(and oldie academia types who think they are important) to understand they aren't God's gift to mankind. They aren't smarter. That they don't need to reinvent the wheel. That most of the shit they are trying to implement has already been discussed and turned down for VERY good reasons. But they know everything. Really we need a return to the basics in all realms of programming. Speaking of webpage programming I would like for once to be able to read a news article without it having to load 8000 scripts, 40,000 ads, pictures/video unrelated to the article, on and on. That's basically what these shitheads are asking for, to be able to the place ads more easily, or sell your data more easily, but they want to be able to do it at the kernel level. You know because identity theft and corruption of companies just isn't easy enough with current languages. What they are asking for is the equivalent of Oracle taking over Sun and OpenOffice. They know better! Follow me or else! Ummm No...FU!
It's all well and good to say "make it understand English", but there are two primary problems with this. First, natural language programming is hard. Really hard. Just getting a computer to understand English with any reasonable reliability is pretty far in the future, and we can't wait for that. Second, we as humans don't really have much success expressing exactly what we want. It's why the most insidious bugs are not in code, but in specification. We so often don't know quite what we want that restrictive languages are actually beneficial, in that they force us to reason consistently.
And it's not some "saying floating around the internet", it's a very famous quote from Structure and Interpretation of Computer Programs, a seminal text in basic programming language theory and compiler/interpreter design. Most importantly, it's probably the first book you should read if you want to intelligently discuss this topic.
Another quote you might find interesting:
When someone says "I want a programming language in which I need only say what I wish done," give him a lollipop.
- Alan Perlis
In short, from someone who likes to design programming languages - stop assuming that just because the problem is easy to understand that it is easy to solve. We're not all basement-dwelling geeks who think UNIX is the pinnacle of end-user usability and newbs should just get over it. We aren't pretending that there is no problem, and we're not refusing to educate ourselves on how to solve it.
Which improve on sql. You mentioned Rel, there's Dee[1] for python. The problem with sql though is the network effect... It's why it's still there.
With C, python, Perl, Pascal, blah there is no network effect, you talk to the computer, it does stuff. With sql, the computer talks to another computer and the other computer has to understand. So you now have sets of computers that talk the same language; SQL everywhere.
[1] http://www.quicksort.co.uk/DeeDoc.html
Deleted
1. Functional programming is pure but the world is stateful. Whenever you read the docs for a functional language they always trumpet the virtues of pure functional programming; but they always have a hack to break it. This is because the world is stateful. If you want to model the world, you need to model state. Maybe there is a purely functional way to model state; but it always looks hacky because they're not modeling it in a straightforward manor. Is it even possible to build a practical CPU that isn't stateful? Why not just get rid of the const keyword in C, default everything to const and add a keyword called "mutable"?
language.
Why not fix the horrible languages that have come since? Seems to me the most popular reason for all the new languages is they always suck thereby insuring a new one to take the place.
Here is a hint, solid business languages with built in understanding of currency handling (read decimal positioning) are wonderful things... albeit a bit boring.
Though I really don't mind PHP , lets me expose core business logic that works flawlessly to those services I can't trust
* Winners compare their achievements to their goals, losers compare theirs to that of others.
But since when is "because it is difficult" a sufficient reason to take the easier path instead of the right one?
It seems to me that it's often the case that at some point, it's better to build something new then to keep maintaining and adapting something old. It's an opportunity to rethink things from scratch, to apply what you've learned, and to toss out accumulated cruft. I find this when I upgrade a Linux distribution or replace an entire computer, but I also find it when I move to a new home, or take a new job, or otherwise seriously revise my living conditions. I expect it applies in much broader social contexts -- I'm certainly not the only one who thinks the patent system ought to be scrapped and replaced.
Complicating this is that there's a need for the self-discipline to focus on maintaining and adapting something that is still in the prime of its utility. But in general, I do think there is a pattern in which it's good to rebuild once in a while.
"Frankly, I think the base topic here, the argument for new languages over improvements to existing languages, is to make everyone equally -incompetent-."
Oh Cool. Harrison Bergeron's world has hit programming.
Just when you thought you knew how to program, let's make you learn Sapphire on MonoRail.
My first Journal Entry ever, in 8 years! http://slashdot.org/journal/365947/aphelion-scifi-fantasy-horror-poetry-webzine
This post was destined to turn into a "Oh yeah? well REAL Programmers use..." argument. I agree with this. No matter what we prefer, the market is only improved by new attempts to improve the power of Programming. I like C based languages, but stepping outside the C Paradigm or even improving the C Paradigm is far from being out of the question. As new needs arise, improved languages will make user and programmers lives so much better. But that doesn't mean we are forced to change until the market deems it necessary. Besides. The market can be slow to change any way. Just ask the military's Fortran programmers.
~theCzar
Keep building new languages, I will surely find a way to bill hours for it.
Java - billable hours and ass loads of hardware .NET - perfect for lock in and selling licenses, rewrite in java once it is determined that hey we need to support other platforms.
PHP - quick and dirty web development cleanup billable hours
Python - one off get it done quick billable hours
Perl - systems stuff they will have to call me back in to maintain
Java Script - client hack more billable hours
C - debugging more billable hours
Ruby - billable hours for rewrite to address performance issues including a ass load of hardware
Got Code?
Most of the time I just want to sit on top of a database where most of the code is in triggers - calculated fields, a cross between a database and a spreadsheet. And then some screens stuff to display that data.
No language is perfect.
Wrong!
That is all.
Carried. Miller Time.
In any one of them. Knowing two or three languages in depth will buy you more than chasing after the moon. At some point you're just going to have to sit down and learn to write a program. Doing anything significant in any language is going to be complicated and require some thought process. What I'm saying here is no matter how shiny your newfangled language is, it doesn't mean you can hire chimpanzees to write your program! And if you can, it probably means you can't do anything actually worthwhile in the language.
I'm trying to teach myself to set people on fire with my mind... Is it hot in here?
and the only cure is More Programming Languages!
Hi! I make Firefox Plug-ins. Check 'em out @ https://addons.mozilla.org/en-US/firefox/addon/youtube-mp3-podcaster/
You can write a [insert buzz word language] compiler or interpreter in C, and it likely already is written in C, so C is the best! ;)
Who else skimmed the article and went for the programming tests?
#1 was not really much about programming and I did horribly on it (13/20)
#2 was mostly programming and I did well (19/20) Another energy drinks question?
Anyone who is anyone programs in Brainfuck....
For example, a suite of compatible languages that allow one to code the same thing in different languages and have a system prove that they have equivalent functionality and if not, spit out meaningful descriptions of what needs to change to converge the implementations.
Nullius in verba
what is it about a music degree that makes learning a new instrument any easier?
I have a Master's degree. My friend has a PhD. Plenty of ear trained/self taught musicians I know learn new instruments just fine. Learning a new instrument is mostly about mouth/breathing/fingers: dexterity and motor function. Music education is mostly about theory/history/opinion. I can get the analogy you were going for, but think you chose the wrong field.
People just seem to be bringing up arguments in defence of their own preferred long-running languages, and there seems to be very little mention of new programming languages -- the entire point of the article. Well, here's one, aimed mainly at web/mobile game apps:
Monkey
"Monkey is a brand spanking new programming language that [...] works by translating Monkey code to one of a different number of languages at compile time - including C++, C#, Java, Javascript and Actionscript."
Monkey's language and compiler are in the public domain, though its game library is proprietary.
the more I like Object Pascal.
OOH ! THIS ANALYSIS MAKES USE OF THE PHRASE 'Tipping Point'.
Therefore it must be CUTTING EDGE THEORY
and TRUTH.
Yeah, but if they were to agree with you, they would have to accept paying engineers lots of money to make hard decisions, instead of paying mbas lots of money to make bad decisions.
is that people get fed up with real or imagined inadequacies and run off to create a new language.
A new language introduces new and different problems: compatibility with existing code for one. Of course, this problem isn't as big as it once was, because of the JVM and CLR.
From Paul Graham's website:
Programs must be written for people to read, and only incidentally for machines to execute.
Abelson & Sussman, SICP, preface to the first edition
Anybody want a peanut?
The languages designed to provide a system level interface to that machine need to be designed around what a human understands, the way a human understands it.
You do realize that this was the exact principle behind such delightful languages as COBOL, BASIC, and Applescript, right? Especially look at Applescript, because it was a very bold attempt, and you can learn a lot from its shortcomings....such as why people don't really try that kind of thing anymore.
"First they came for the slanderers and i said nothing."
It's only logical!
The definition of what a "programming language" is is wrong by nature and misleading when we are talking about all the variety.
The real problem is that we don't have several "programming languages", but instead, we have a plethora of programming "dialects".
We do need another language. Each time we try, another dialect appears.
Any evidence that the statement:
> It is far, far easier to create a new language from whole cloth than it is to convince the existing user base of a popular language to accept radical changes.
is true in any way?
Often wrong but never in doubt.
I am Jack9.
Everyone knows me.
Yes, we actually need better programmers rather than new languages. All those examples (Perl, PHP, ECMAscript, Python..) are scripting languages that were developed to make the life of lazy developers and sysadmins easier. Some people seem to have too much time on their hands.
Since C# at the start was a wholesale ripoff of Java, it's really based in 1995. After all, what about the Microsoft version of Java that predated C# by quite a bit, but was the core for the VM that C# used...
Also just like Java, it has managed to move substantially past its roots.
But to claim it was really "born" in 2001 and thus a "21st century language" where the others are not is absurd.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
If we're nitpicking, C is not strictly a subset of C++, but it's close enough. Anyway, your argument is flawed. If a feature is unnecessary and makes programs harder to write, debug, and maintain, a language that omits it can be superior to one that includes it. Let's imagine, for instance, a "comefrom" construct that you can insert in arbitrary locations in your code. Would a language that supported "comefrom" be superior to one that doesn't?
Any sufficiently advanced technology is indistinguishable from a rigged demo
--Andy Finkel (J. Klass?)
const int SIZE=5;
int arr[SIZE];
Second line works in C++, but is a compiler error in C. You have to use #define instead.
If a computer can fully understand human language, then it can also respond with a fully human like statement. In effect, you're asking for human level AI which would pass the human/computer Turing test. Easy peasy, right?
Honestly, I'm all for using whatever language helps get the project done, rather than trying to ram a square peg into a round hole. If you are doing something specialized that a domain-specific language would help with, go for it. AI (artificial intelligence...) programming histroically used LISP. Math people have used Fortran. The Linux kernel uses C. I would not say all these people should switch to "language of the day" just because. But, if someone was doing, say, vision recognition code, and some new language makes that kind of code easier to write, easier to maintain, and easier to tell just what is going on, then by all means use that language rather than having an unholy mess written in C, or Java, or Python.
"programs must be written for people to read, and only incidentally for machines to execute"
Oh, god, yes.
One of the more important development skills to have is to be able to extract consistent requirements from stakeholders, and then to be able to write them down in such a way that the requirements will be correct and the stakeholder will agree with them.
When it comes to programming languages, give me a language suited to the problem (all the one-language bigots can go pound sand) that's easier to debug than to rewrite. Large, hairy, complex solutions should eventually result in a new programming language that makes those sorts of things much smaller, far smoother, and simpler.
Pick One: http://www-rohan.sdsu.edu/~stremler/sigs/sigs.html (Note - disable Javascript first!)
Good that you brought up Lisp.
It always amuses me how "commando"-type programmers are always complaining about the lack of closures or some such in pedestrian language X.
Thing is, language X and its cousins are supposed to be dead simple linear-logic languages for the purpose of stuff like "if total_purchase < $50, shipping_surcharge = $10", and so on.
You're not going to be generating fractals in one-liners in PHP, so stop whining. PHP and the like are for "lite" programmers, i.e., web programmers. That's not disparagement; it's actually praise. PHP is How Stuff Gets Done (like Facebook growing into a 1/2 trillion dollar corporation).
Meanwhile, if you want a language beauty contest, why not go with LISP and Scheme? These languages allow you to easily extend the language, hence no whining allowed. I seriously doubt anybody's going to come up with a more elegant and extensible language than them.
So, come on language gourmets, what's the problem?
Learn Scheme now, and leave PHP as it is.
I'm not a lawyer, but I play one on the Internet. Blog
I used to teach 68HC11 assembler programming for a long time and towards the end, I wanted to document how new learners created assembly code "wrong". They would intuitively write code that made sense to them. I thought that if I tracked the same "errors" that I was seeing course after course then creating an intuitive language that incorporated the same creative thought process would make programming easier. Unfortunately, the course was dropped and I never got the opportunity to explore the intuitive process further.
Coming from a background of programming in the 90s it never ceases to amaze some of the younger programmers. I had a client that used a Ruby rake task that took 12 hours to run. This had ran daily for at least a year, they had tried to optimize it - which they just didn't understand how to. They didn't know SQL, for example. I rewrote it using execute() directly and reduced the time down to 20 minutes. Then, just for fun I rewrite it in Perl/DBI and shaved the process down to 5 minutes. You would've thought I was levitating fireballs or something.
First, natural language programming is hard.
In fact, it's probably impossible. English and other natural languages are context-sensitive. The precise meanings of some statement(s) in context-sensitive languages cannot be determined solely from the statements themselves without additional information that is external to the languages. For example, the double entendre. If you want another real world example a rule system that's been mucked up by natural language, you need look no further than the various legal codes and presently in use around the world and the lawyers who profit from and manipulate ambiguities therein.
Large, hairy, complex solutions should eventually result in a new programming language that makes those sorts of things much smaller, far smoother, and simpler.
Or switching to an existing programming language that is better able to express the problem than the ones you've been used to using. Just because you don't know it doesn't mean it doesn't exist.
"Little does he know, but there is no 'I' in 'Idiot'!"
Thats kind of where the end goal of programming languages needs to be
No end goal is defined. There is no such a thing as the ultimate programming language paradigm.
Actually, there is no need to distinguish between program data and instruction data. We do so as long as it's useful. However, the point of computing and communication is just to let data interact. I'd be tented to say that's the point of the Universe as well. Goals, if any, might state what the eventual global entropy is going to be, but that seems to be too far to make guesses.
There is no way I could agree more with what you said. In fact, I'd even go as far as to say that we need a better natural language that is closer to a programming language not vice versa. Although it's obviously a difficult thing to get right and almost impossible to get it adapted even if it were good enough.
Natural languages are terribly ambiguous in their meaning. It's so very easy to tell something wrong by making an error in wording or grammar. Especially since different regions actually understand language differently. I live in a small non-English speaking country with a bit more than a million people in it and even here there are native dialects that I can barely understand if at all...
I think that even SQL is not a good idea and too close to a natural language. I still can't remember which order some statements should be especially in complex queries. Why would anyone think it easier to use and read (not that it's even complex query):
INSERT INTO `table1` (`col1`, `col2`) VALUES ('1', '2')
SELECT * FROM `table1` INNER JOIN `table2` ON `table1`.`col1`=`table2`.`col2` WHERE `table1`.`col2`=2
than it would be something like this. A fictional stricter language where the exact order of statements won't matter at all and where possible syntactic errors are pretty much limited with wrong placement of brackets or quotation marks:
insert( tables('table1') columns('col1' 'col2') values('1' '2'))
select( tables('table1' 'table2') columns(all) join('table1 col1' 'table2 col2') where('table1 col2'=2))
... but then I know that the easy to read and understand languages like those in the Wirth family (incidentally also cleaner, more robust and with built-in bounds checks) lost the popularity contest against the abomination that is C. My conclusion is: between readability and less typing, people prefer the latter. Between power to shoot your own foot and mechanisms to prevent ugly bugs, people prefer the former. It's no surprise that several popular scripting languages have essentially taken C and removed types (i.e. the last traces of sanity).
"I love my job, but I hate talking to people like you" (Freddie Mercury)
Having said that, the best way to learn different paradigms is to use languages that are different from each other. Learning only languages that share paradigms will not stretch your abilities that much. For example, in the big picture, C++ and Java are not that far apart.
My personal experience is that Lisp/Scheme is different enough from any of the C derived languages that it forces you to learn to think a new way. Learning Scheme will make you a better C++ coder. I still haven't spent the time to learn Haskell, but I plan to do so. I think it will improve my abilities no matter what I am working on. Lazy, strict functional programming is far enough removed from what I normally do that I expect to learn a lot of new ways to think about coding.
Why is Snark Required?
I believe most reviewers of Ada 9X (and Ada 83 for that matter) will assure you that it was most certainly not designed by committee ;-).
"I love my job, but I hate talking to people like you" (Freddie Mercury)
I don't think languages have to change slowly. It all depends on the way they are developed.
Look at C#. It's quite a young language, but it changed tremendously since it started. And now languages like Java and C++ are trying to catch up with it, at least in some aspects (like lambdas).
In version 1.0, it was mostly a copy of Java, with some enhancements, like properties and delegates. Over time, generics, lambdas (that can be manipulated programatically) and optional dynamic typing were added. And the upcoming version 5.0 will have much better support for asynchronous programming than other languages. All those changes are very useful and can change the way you program.
I think this proves that popular languages don't have to change slowly. And you can even keep backwards compatibility while doing it.
We don't need more languages. By the time I write Java code for a web application that uses JSP and EL syntax, and also emits HTML, CSS, JavaScript, and jQuery, that's what kills me. I have three meta-levels on the same page of code (JSP, emitted HTML/CSS, and emitted JavaScript/jQuery). My mind has trouble distinguishing what belongs at which meta-level. After staring at jQuery code for a few minutes, I still wonder if I'm looking at a snippet of CSS to select something or an anonymous property list in JavaScript. This combination of similar-but-different languages is becoming a nightmare.
I'd almost rather switch among C, COBOL, LISP, and FORTH - which are all radically different - than among C, C++, Java, Perl, PHP etc which are all similar-but-different.
How do you get the length of a string? Each C-like language is different.
strlen()
length()
len()
string.len
string.length
string.len()
string.length()
???
Some C-like OO languages prefer properties to methods (like C#), some are like C and PHP and have a standard function, some are like Perl and randomly use a length() function. I often have to look up how to get the length of a string in an O'Reilly book! This nutty insanity has to stop.
Now there was a language!
Turbo Pascal 4.0 was the best. Not because of efficiency, or programming paradigm, or any of that.
It had an integrated development environment that was a dream to use. The online documentation was helpful. The manual was a masterpiece. It was easy to begin with not very much and to be producing fairly complex results in not much time.
I am not a programmer by trade. Studied it in school, way back in the 20th century. Since then, every now and then I've done some programming for my own utility or for work projects in all sorts of languages, including programming, macro, and scripting languages.
Perl 5.2 was the closest I've come to a language I really like since Turbo Pascal. Yeah, the initial syntax learning curve was ferocious, but in the end it wasn't that steep. Sure, no integrated development environment, but a decent text editor was almost as good. The Perl manual pages were masterful. Again, easy to begin with not very much and produce useful results in not much time.
I'd really like to find my own personal 21st century Turbo Pascal. I don't care about the syntax, although I actually sort of liked the Pascal syntax. I want a tool that is easy to install, that includes a reasonable IDE with conveniences like syntax highlighting and code-completion, useful documentation, and a fairly rapid path from the start line to something useful. I'm willing to give up the IDE if I can get consise and precise syntax documentation and error messages.
I took a look at Perl 6. I haven't given up on it yet, but it doesn't seem cooked yet. And the documentation left me swimming in a sea of information that never seemed relevant to what i was trying to do.
I took a look at Clojure. I had a lot of hope for it. I ended up lost in a sea of irrelevancy trying to figure out how to do very basic things.
Ruby. Couldn't download it. Don't know why. Some website error over a couple of days. Fail. Maybe I'll try again some time.
Python. There is something that just seems wrong to me about indenting being syntactically significant. But what the heck, I'm willing to set that aside. The documentation isn't bad. My biggest issue with Python is "SyntaxError: bad syntax". That's it? Nearly a hundred years of computer science and the most the computer can tell me about my mistake is "SyntaxError: bad syntax"? I can't even get a "operator expected" message? Okay, so occasionally some sort of indentation error, but mostly just "bad syntax". I haven't completely given up on it, but I got tired of fighting that error message.
Actually, C# is the best I've found so far. I am really hoping for something better. But I've been able to start from not much and produce small but useful (console) programs in not much time at all. The combination of command-line compiler and my own text editor was enough to get me going. Basic language documentation is woefully deficient, but somehow that wasn't much of a problem. I've developed a love-hate relationship with Visual Studio, though. Can't seem to make it edit just one file, with full syntax and code-completion. It wants "projects" and "solutions". Screw that. I understand the usefulness of that, but if I'm writing a 30 line script that does something useful to some text data, I don't want to go through all the overhead of "projects" and "solutions", I want to create a file, edit, compile, and done. And the on-line help in VS is . . . stupid.
So, go ahead and jump on me. If any of these are your pet language, and I'm just not getting it, please enlighten me. If you have a different pet language, and I'm just not getting it, please enlighten me.
But whatever it is it needs to be pretty simple to install the basic environment. Basic documentation needs to be pretty useful. An IDE with syntax-highlighting and code-completion is a big bonus, but I can live without it if there's decent error messages and documentation. And it needs to be useful pretty
Sorry, I was not clear that my base assumption is that we're already trying to use the best language for the problem at hand. There are *still* going to be problems that are large, hairy, and complex, given the other constraints we might be working under.
If you don't consider at least three viable different languages for a new project, you're not doing your due diligence.
(Unless, of course, the project is 'use language X on a real-ish problem to see how it really works', and the end result is just a happy side-effect of giving language X an honest go.)
Pick One: http://www-rohan.sdsu.edu/~stremler/sigs/sigs.html (Note - disable Javascript first!)
The problem is twofold: 1.) Someone who thinks we need more programming languages doesn't understand the problem, but it's generally a moot point because 2.) Someone implementing the latest fad in languages inevitably ends up re-inventing the wheel, albeit poorly.
The end result is that while 10% of the features of the new language may be novel and interesting, only about 1% of the features will be useful in the practical sense. And 90% of the time spent in language development will be put into recreating existing functionality in the new language. Look at Java, for example. Just when UI design was starting to make sense, Java reimplemented the entire GUI in Java, and threw away a large portion of what had been learned on how to do UIs well.
And the result? Nobody used the Java UI. Remember Swing? Yeah, I actually wrote GUI apps with it, but Java went the route of the server - hidden from the user, and never ever came close to challenging C++ for work on Desktop apps. Oh, sure, maybe Swing (or whatever they're calling it these days) has improved, but Java missed an entire generation of programmers in the interim.
The problem today is that by the time your new paradigm catches on, and you've developed all of the attending libraries and functionality to make it competitive with existing languages, the paradigm is already obsolete.
There really has been very little progress on languages since C++. There's very little that's new, functionally speaking. The new languages of today aren't revolutionizing the software paradigm - more often than not, they're just reimplementations of existing functionality and language paradigms with a new set of strange and irritating behavior. Python's use of whitespace to perform block delimiting is an interesting step backwards - it was first done in COBOL - and it was just as much a defect then as it is today. When I had to learn COBOL in school, I thought it a waste of time until Python came out, and then I recognized the value: it had taught me the danger of making stupid decisions in language design.
We've come to the point where unless you're using a really old language - older than C - the language is pretty much irrelevant. Granted, some languages are better than others at solving certain problems, but I've yet to find a new language (after Java, that is) that brought something new and important to the realm of computer science. Even Java was a draw - you lost operator overloading and multiple inheritance - in favor of a simpler, more practical paradigm (sound like C, anyone?!). And C# was definitely a step backward; you got none of the advantages of a vm with all of the disadvantages. And Python has just decided to break backward compatibility on a whim, leaving anyone with a substantial codebase out in the cold.
The society for a thought-free internet welcomes you.
I think there are two forces that improve programming languages, much like any other field: evolution and revolution. By which I mean: existing languages evolve by having incremental changes applied to them, and, every once in a while, a new language disrupts the field in a more radical way.
All of this is accomplished by a process where new concepts and new implementations of existing concepts are constantly being tried in new languages, and, although most of these attempts wither, some concepts eventually make it into day-to-day programming. It isn't always the language that first introduces a concept that succeeds or becomes the champion for that concept, but this constant experimentation is what moves the field forward.
The way I see it, we need new programming languages for two reasons. First of all, existing languages have well known deficiencies, that are hard to fix because they are fundamental to the language. You need a new language to get rid of them. The other reason is that we need to keep experimenting. Perhaps this does not technically require new languages, but creating a new language is often how new concepts are explored - and the knowledge gained here will eventually make the language you use better.
Please correct me if I got my facts wrong.
Somebody truncated the "like we need holes in our heads" part.