New Programming Languages Come From Designers

eldavojohn writes "A very lengthy and somewhat meandering essay from Crista Videira Lopes has sparked off some discussion of where new programming languages come from. She's writing from the viewpoint of academia, under the premise that new languages don't come from academia. And they've been steadily progressing outside of large companies (with the exception of Java and .NET) into the bedrooms and hobbies of people she identifies as 'designers' or 'lone programmers' instead of groups of 'researchers.' Examples include PHP by Rasmus Lerdorf, JavaScript by Brenden Eich, Python by Guido van Rossum and — of course — Ruby by Yukihiro Matsumoto. The author notes that, as we escape our computational and memory bounds that once plagued programming languages in the past and marred them with ultra efficient syntax in the name of hardware, our new languages are coming from designers with seemingly little worry about the budget CPU being able to handle a large project in the new language. The piece is littered with interesting assertions like 'one striking commonality in all modern programming languages, especially the popular ones, is how little innovation there is in them!' and 'We require scientific evidence for the claimed value of experimental drugs. Should we require scientific evidence for the value of experimental software?' Is she right? Is the answer to studying modern programming languages to quantify their design as she attempts in this post? Given the response of Slashdot to Google's Dart it would appear that something is indeed missing in coercing developers that a modern language has valid offerings worthy of their time."

Comments

Quite obviously...

[Anonymous Coward]

All you need to create a good programming language is a beard. The more epic the beard, the better your language will be

Re:Quite obviously...

[Anonymous Coward]

Relevant.

Re:Quite obviously...

[MysteriousPreacher]

It was tried, but failed. It had no support for graphics, and stability and a lack of standardization were major problems.

While the majority of programs ran reasonably fine, a significant minority would deliberately crash themselves and other applications. This instability is due to a feature by which Zombie Mohammed code ensures correctness. Unlike Catholic++, Zombie Mohammed certification is very decentralized, and has reached the point at which each individual program considers itself to be the sole arbiter of correctness. When a program encounters another that doesn't adhere perfectly to its own standards, it will attempt to crash it - which normally leads to both applications being killed. Although widely claimed that Zombie Mohammed code will only attack other languages, such as Borland's Turbo Presbyterian, the truth is that Zombie Mohammed code is far more likely to kill its kin than foreign languages.

To this day, many Zombie Mohammed developers claim their language to be stable, and that crashing programs are the result of the language being distorted or misused. Oddly enough though, the "stable" developers seem unable to explain exactly how the rogue developers' code is a misuse of the language, and are slow in condemning their actions. Even now in developed nations that have discarded archaic languages, criticism of these outdated languages attracts threats of violence - with many people and publications opting for self-censorship. Zombie Mohammed is gaining popularity in Europe, which some have likened to the idiocy of buying a top of the range modern PC in order to run Windows 3.11. Sensitivities considered, it would be a good idea if the immigration process would encourage those who wish to use modern languages. It doesn't mean that use of Zombie Mohammed in Europe should be prohibited - more than immigrants must understand that Zombie Mohammed is just one of many languages in use, and that it shall not be protected from criticism or ridicule. Really, how can they expect no criticism when they use a dysfunctional programming requiring an interpreter?

The language remains popular in some parts of the world considered socially backwards and unsophisticated, where pretty much anything is an excuse for a flag burning angry mob. Whether Zombie Mohammed is a cause or a symptom of social retardation is unclear, and certainly such issues are not restricted to this language. One of the largest and most developed countries uses JC (albeit in thousands of variations), yet there is regular in-fighting between various schools of JC developers, and antics that baffle the rest of the developed world, such as JC developers trying to have a programing language taught in religious ed. Thankfully thus far religious leaders have presented a united front in claiming that computer programming is more suited to science than to religious education.

Re:Quite obviously...

[f3rret]

Dude, Sean, chill. You thought way to hard about that.

Re:Quite obviously...

[MysteriousPreacher]

Yeah, started as a quick joke, but grew in to an Uncyclopedia article. I'm going to sit down with a cup of tea.

Re:Quite obviously...

[celle]

I got catholic++ and turbo but of all the relatively bad languages out there which one(s) in your opinion fits Zombie M?

Doomed

[Joce640k]

Aren't the basic programming concepts understood and defined now? All a new language can really bring to the table is a different syntax.

The successful new 'languages' these days are those that include a big set of libraries, eg. Java and C#. People use them for the libraries more than the language. Without the libraries Java and C# are nothing more than reinventions of the UCSD p-system.

Re:Doomed

[Anonymous Coward]

Not quite true. There are believed to be a very large number of possible models for computation, of which functional and imperative programming are but two.

Most of them are unlikely to be particularly useful, but there is plenty of scope for new languages which exploit them.

Re:Doomed

[ledow]

This.

Pretty much, after you learn your second or third programming language, they are all pretty much the same. There are some oddball ones for very specific purposes (e.g. PROLOG), but pretty much they are all the same things with different syntax and different libraries.

Some of them are slightly more suited to different tasks (e.g. LISt Processing, etc.) but there's really not much to choose between them. I'm not a fan of the newer languages - anything that LOOKS like gobbledegook from a distance usually does a good job of masking gobbledegook close-up. Just looking at some of the Ruby examples on the Wikipedia page makes my programming-mind want to vomit. I find C++ quite obtuse too. C99 is pretty much the best compromise that I've found between gobbledegook and flexibility.

Does your language compile to the target? Does your language run and compile from your development host? Does your language enable you to do the things you want without unnecessary hindrance? Almost every programmer who chooses a language asks themselves that and if they aren't satisfied it's true, will move to something else.

To an extent, OOP is just a formalisation of things that function programmers have been doing for decades into a space-saving syntax. Similarly for other "paradigms" of programming. In the end, the compiler still has to squeeze it all into the same instruction set and it's just whether it bothers to check for over-runs, abstract away certain details, make certain optimisations, etc. that makes any difference. The end code is usually pretty indistinguishable.

This is my answer when someone wants to choose a language to "start programming": Any of them. It doesn't really matter. Probably good to start with something you can understand immediately but it really doesn't matter what you do it in. It's like a child who's started learning to speak wondering what language they should speak - whatever is available, practical and you can manage.

Programming is communication of some instruction to the computer, that's why we call them "languages". What language you use is merely a practical consideration (i.e. verbosity, popularity, availability, what others can understand, etc.) that's pretty much made for you. Some languages aren't available, don't have a compiler (only an interpreter), need external libraries for everything, aren't cross-platform, etc. Beyond that, the only thing that matters is the message - the program itself - not the language.

Since I was a teenager, I thought of writing my own language that would pick bits I like out of each language and merge them. It would just create a hideous mess, of course, but if I've considered it, it usually means lots of other people have done it before me. Any language that purports to be the collation of the good points of others will be regarded by everyone else as a collation of the bad points of everything else.

A one-man language isn't, in and of itself, a bad thing. The problem comes when it literally does nothing you can't already do, albeit with slightly different syntax and slightly more work.

Basically, if you wanted, you could rewrite a C pre-processor to compile any of those languages directly to C syntax, and vice-versa. There's nothing "new", just some "shiny" things.

Things haven't moved on since C, really. Sure, we've prettied up the syntax, clarified some edge-cases, added some libraries, etc. but it's all just spit-and-polish on a language made in the 60's. The fact we use those slightly-cleaner versions for the vast majority of software today (including the compilers of most of those other languages) means that there really wasn't any huge paradigm shift, or change in the way we work, or need to move on.

The only thing I think might change the way we work in quantum computing. That's going to need a serious rethink and redesign in order for people to "program" them effectively. But, you know what? I have a suspicion that the first practical languages for that will be "C with knobs on".

Re:Doomed

[TheRaven64]

Aren't the basic programming concepts understood and defined now? All a new language can really bring to the table is a different syntax.

If you really believe this, then you've been stuck in Algol-derivative land for far too long.

Re:Doomed

[Anonymous Coward]

Good grief, what a profound misunderstanding of the entire field this post represents.

If you have an interest in this field, you need to spend some serious time with Haskell and LISP before you even begin to think about writing longwinded comments about how all languages are fundamentally the same.

It is trivially true that any program you can write in [language X] you can also write in assembler, and therefore C. If the entire field of programming languages could be summarized like this, why aren't we all using assembler?

The insight only comes when you understand this thing called "abstraction" and why it's useful. There is a reason I use Django templates, and don't usually write HTML-producing code in C. There is a reason I use LISP when I'm doing natural language processing. I can do more work in one line of Python than you can do in 100 lines of C. The right language for the job can make two orders of magnitude difference in productivity. If you don't understand that, please, STFU.

Re:Doomed

[Nursie]

C/C++ inherently buyy and unsafe?

No more buggy than code written in any other language, and only unsafe in the hands of people that don't know what they're doing. Arguably these people shouldn't be allowed near any programming language anyway.

Re:Doomed

[OeLeWaPpErKe]

Compiling functional languages down to C is extremely simple. Functional code is imperative, it's just accepting the rule that you can never reassign a variable. It's the reverse that's hard.

But just because it's hard doesn't mean it's not done. Pretty much every C compiler with the partial exception of gcc compiles C code into a functional-style imaginary assembly-like language, because that allows more optimization algorithms to work. It's hard and complex, but it gains you a few percent of efficiency.

Most high-level programming languages easily "compile down" to C, in a straightforward and easy manner. Just look at the gnome source code to recoil in horror at the manual, convoluted and incomplete reimplementation of C++'s virtual method tables. Complete with the "your destructor isn't virtual" gotcha just waiting to bite you, except without the compiler warning when you do screw it up. Or the linux kernel's way of dealing with all sorts of datatypes, like a file handle. It *is* object-oriented, both gnome and the kernel, they just prefer to compile manually.

Want to give C "all the power of python" ? Just make all variables part of a huge dictionary, and do everything with symbolic lookups. ( x.y(z) => (*dict_get(dict_get(global, "x"), "y")) (dict_get(global, "z")), and all types reduced to "void *". There's people who actually do stuff like this (like, again, gnome).

The new linux iptables code looks like an extremely basic lisp implementation, because they know how to make that fast. The previous one looked like an interpreter for an extremely convoluted language (much slower because of the 2 strands of execution : first the interpreter itself, second the actual rules being executed. This hinders cache efficiency a lot).

Going down is never the problem. Compiling any highlevel language down to C is an easy exercise (I won't go as far as to say it's trivial, it's not). Imho it's not the best option. C is hard to optimize (but code is available to do that), so compilers necessarily miss a lot of opportunities. The compiler actually has to determine the programmer's intention, prove difficult properties about portions of code, before a lot of optimizations can be applied. Needless to say, this is very hard. Dataflow oriented languages, by contrast, are much easier to optimize and beat C in performance. But nobody knows them, and so actually coding such a compiler is a very hard, very lonely exercise.

Re:Doomed

[Joce640k]

I find C++ quite obtuse too. C99 is pretty much the best compromise that I've found between gobbledegook and flexibility.

To an extent, OOP is just a formalisation of things that function programmers have been doing for decades into a space-saving syntax.

The big advantage of C++ over C is resource management (using "RIAA").

With C++ you can define a smart pointer type, use STL containers and strings and everything pretty much manages itself. With C you simply can't do that. Writing big/complex programs in C is an awful lot more work than in C++.

Exceptions too. If you're parsing a complex data file several layers deep then error handling will make C code enormously complex. With C++ you just throw an exception and let stack unwinding free all the temporary data for you.

Re:Doomed

[Mabhatter]

This is like arguing for good Engineering. The Efiel Tower is a great piece of engineering and applied sciences. It is also a terrible house or car factory.

What these "bad" languages provide are tools to do a TASK well. The classic case of a well designed and engineered language would be Java. The underlying computer science is excellent.... But it doesn't SOLVE PROBLEMS PROGRAMMERS ACTUALLY HAVE. Java is like a store full of Craftsman tools of every type.. A langauge like Perl is a master lockpicker's toolset... Not much to look at, but get the job done.

Re:Doomed

[TheRaven64]

Pretty much every C compiler with the partial exception of gcc compiles C code into a functional-style imaginary assembly-like language, because that allows more optimization algorithms to work.

Really? Because I've worked on several C compilers, and that's not something I've ever seen. Unless you're talking about SSA form, in which case you're wrong on several counts. First, GCC does use SSA form and has for about five years. Second, SSA form is usually quite restricted: memory is not SSA, for example, so it's not very like a functional style at all. I'm not even going to talk about your conflation of vtables with object orientation.

Re:Doomed

[JasterBobaMereel]

C was widely used because it was well supported on all platforms and had extensive libraries ..
C++ see above (and the syntax is similar to C)
Java - See above for cross platform (and the syntax is similar to C/C++)
JavaScript - See above for Web-browsers (and the syntax is similar to C/C++/Java)
C# See above (for Windows and some other systems) (and the syntax is similar to C/C++/Java)

Do you see a pattern here, can I learn a language similar to what I already know, that will be well supported on the platform I am using, and will have all the libraries I will need ...

Languages that are better in every respect will fall by the wayside if they don't meet these criteria regardless of how much better they are ...

C and it's descendents are not the universal perfect language that people suppose, they are just popular, and now are just popular because they are near ubiquitous ...

Re:Doomed

[buchner.johannes]

I disagree. For me, there are three important points to discuss programming languages:

  1. Syntax
  2. Access
  3. Community

ad 1) We know all about and can analyse the syntax. Fine. All the discussion happens here.
ad 2) But what does the finest Haskell help me if I can't access a CD, Bluetooth or a XMPP server, and whether it makes a difference where I want to run the code (web server, mobile phone, mainframe, laptop). In principle, all languages are Turing-complete and equivalent, and I can write wrappers between languages, but as long as I can't *practically* do all the things I need, I'm stuck. The available libraries/access methods draw a picture of what is possible. Here C due to its age, Java with it's tendency to make package that are reusable and Python are among the best (from my experience). As an aside, .NET lacks here, and massively because there is no spirit to make libraries available to others for free causing a non-availability of free libraries.
ad 3) A language is also dominated by its users. This is most noticable with PHP. The background of users dominates what a language should do. Also, this determines the amount of help and easy-to-access documentation. Which again makes a language popular or not.

One individual is not capable of addressing (2). Also, whether a language is picked up by the masses (3), or whether you can build and hold this community, is not a rational, predictable process. When designing a language, you don't have full control over success.

When comparing two languages, don't just look at (1), also look at (2) and (3).

Re:Doomed

[Anonymous Coward]

The big advantage of C++ over C is resource management (using "RIAA").

I think you meant RAII (resource acquisition is initialisation), also known as SBRM (scope-bound resource management). The RIAA would just disable all your copy constructors to stop copyright infringement.

Re:Doomed

[Joce640k]

Just because it can be done, doesn't mean you should do it.

Most arguments against C++ are of the "Look, I can do this and it's bad!!!" type. Real C++ programmers just ignore them and carry on writing code which doesn't do that.

Yes. C/C++ are inherently predisposed towards being buggy and unsafe, relative to more modern languages. They trade runtime checks for minimal runtime overhead (and I'm not saying that's a bad thing), but they don't make any effort to assist the programmer in the area of code correctness.

Modern C++ implementations usually have run time checking on by default. eg. In Visual C++ std::vector checks the range of all indices to see if they're legal. If you do C++ right then the only memory error you'll is a null pointer (just like super safe Java).

C++ isn't problem-free, but all the old mid-1990's arguments aren't applicable any more, sorry.

PS: C and C++ are completely different languages, writing "C/C++" only shows your ignorance.

Re:Doomed

[betterunixthanunix]

Exceptions too. If you're parsing a complex data file several layers deep then error handling will make C code enormously complex. With C++ you just throw an exception and let stack unwinding free all the temporary data for you.

Except that C++ exceptions are tricky beasts; this is a classic "hard to shoot yourself in the foot, but if you manage it you'll blow your leg off" situation. Aside from how easy it is to get exceptions wrong (e.g. when your exception types are part of an inheritance hierarchy), there are also hidden "gotchas" like this:

SomeClass::~SomeClass(){
log.print("Destroying SomeClass Object");
}

See the problem? Wondering why this is relevant to exception handling? The body of this destructor might throw an exception, which is OK sometimes but deadly if the destructor was called as part of the stack unwinding process that resulted from another exception being thrown (which causes abort() to be called).

The C++ standard library also has (or at least as of C++98, had) poor support for exceptions. You must explicitly activate exceptions in some classes; "new" may or may not throw exceptions; the number of exceptions that might be thrown is very limited. There are some parts of the C++ standard library that require you to check return types or to check class members on your own (sometimes this is a good thing -- throwing an exception at the end of input would be horribly annoying).

C is not much better, since error states are advisory and people often ignore them (how many times do you see people fail to check the return value of printf?). What C++ needs (and perhaps this is in C++0x) is a better definition for exceptions, one that does not cause programs to abort (which is even worse than checking return values) and to make better use of exceptions in the standard library. Unfortunately, this would create all sorts of headaches for compiler writers, who would have to rethink their code generation strategies, so I do not think it is likely that we will see this happen any time soon.

Re:Doomed

[psmears]

Compiling functional languages down to C is extremely simple. Functional code is imperative, it's just accepting the rule that you can never reassign a variable.

No it's not. There's also the small matter of first-class functions (e.g. being able to return a function as a result from your function, where the returned function still has access to the local variables of your called function.) C doesn't natively support this. It can be simulated, of course, but it's certainly not easy, because (roughly speaking) the lifetime of locals is no longer tied to the lifetime of the stack frame for that function.

And then there's laziness - being able to define a function that contains an infinite loop (say, calculating all the prime numbers one by one), and then applying another function to it to ask for the first 100 results - and having it do what you want (e.g. returning the first 100 primes) without looping forever.

This can certainly all be achieved with translation to C - as the existence of ghc proves - but it is far from "extremely simple".

Re:Doomed

[TheLink]

1) Some programming languages are great for all the code you have to write. They are very powerful, very expressive, high performance, etc etc.

2) Other programming languages are great for all the code you DON'T have to write! They have lots of _good_ well documented standard or defacto standard libraries, modules, so you don't actually have to write stuff for a lot of things.

Being a crappy lazy programmer I prefer languages that satisfy both 1) and 2), but with 2) as a priority. Because I end up having to write a lot less and it's not my responsibility to document, support and fix those libraries. Yes I may have to fix or workaround some of the library bugs, but it's not really my job...

The good libraries are written by programmers far better than me, so if I use their stuff instead of reinventing it, it means fewer bugs and higher quality.

Of course, if you are a great programmer your priority would be 1). 2) only being a minor factor.

Re:Doomed

[Anonymous Coward]

Of course they're not magic. But they offer abstractions which are very different to what C offers. Haskell's type system in particular needs to be studied to really understand what I'm talking about - if you think functional languages are only about list processing you're just reading the back of the cereal packet.

You must be a pretty lousy C programmer then.

Indeed, I only have 22 years of experience with that language and its successors.

Of course you can write your 100 lines of C in a library and say "hey, I'm only calling a library", but in Python what you can do in one line of ad-hoc code can take 100s of lines of ad-hoc C code. Look up list comprehensions. And yes, eventually a library interprets those, but high-level languages allow you to escape the bounds of that kind of thinking (all programs reduce to how they execute) and think in terms of higher-level abstractions. And that is the whole point which the "everything boils down to C eventually" argument misses.

Re:Doomed

[scamper_22]

It's a little more than just libraries... but the general point is true. It is also the tools, debugger, documentation, compiled format, general programming environment.

For example, one of the major differences between Java/C# and C/C++ is that C/C++ says nothing about how the code is actually compiled. Whereas Java/C# specify how their compiled output is specified (as they are tied to a runtime platform). This makes things like importing libraries trivial in c#/Java. Just grab the library and click import... problem solved. All the information on the library is contained in the library itself... types and everything. The compiler can derive a lot of information just from this and most importantly, can count on it being there. You don't need to worry about linking issues or naming issues or compile flags of some library...

Also things like debuggers. You can get a lot of functionality in C++ by using smart pointers or the STL. But rarely is the debugger support that nice. Stepping into calls means you're always stepping through smart pointer code. Similarly, you dig into the details of STL structures just to view the contents of a map or something. Nothing is impossible and there are 'systems' in place to help the debugger decode things... but in general, the support is not there.

Divorcing the 'language' from the rest of the environment is like talking about 'operating systems' strictly in terms of the kernel. Sure it can be an interesting technical discussion, but these days, most of what matters is in the system taken as a whole (kernel, default application, shell, configuration, interface...)

Re:Doomed

[im3w1l]

4. IDEs and tools

Does it have a wysiwyg gui designer?
Can I hotswap code during debugging?
Refactoring?
Can I get documentation on a function just by hovering my mouse over it?
Are there automated bug finders?

Re:Doomed

[mfnickster]

What these "bad" languages provide are tools to do a TASK well.

Agreed. The language is usually designed to do a task that the designer needs done, e.g. Larry Wall invented Perl to solve problems in that his available tools didn't do as well.

Or at least, didn't fit his working style. It seems most languages are conceived to fit with the developer's working style, which makes sense as you usually prefer to use a tool that works well for you. If it works well for others too, so much the better.

Re:Doomed

[Anonymous Coward]

There is a reason I use LISP when I'm doing natural language processing.

Is it for the irony? Because I'd totally do it for the irony.

Re:Doomed

[Johann Lau]

What an absolutely terrible misunderstanding of the benefits of compiled code

Try to keep up. The person I replied to argued that scripting languages make for lazy programming, and generally acted as if void pointers and casting types were totally unheard of, and as if types changed on the fly out of nowhere, without any connection to what is going on in the program.

You don't just get warnings with compilers, you get errors, which completely block compilation.

ORLY? You don't say. Way to miss the point: If the compilers offers more checks for well formed code, if anything *that* would make people more lazy.

Scripting languages do not give such errors until a user stumbles across them.

Neither do compiled languages, if what you do is technically correct, but still a bug in the context of the app.

Your argument lies on the blatantly false premise that all compilers do is produce warnings and then proceed to produce compiled object anyway.

What? You're just babbling. What argument am I making? I'm simply refuting an argument someone else is making, and I don't see you addressing any of that, you just go on about strawmen and endulge in more of the pitiful ad-hominems. Oh noes, the "real programmers" are speaking... it's just that they're not saying anything.

This basically screams "I've never worked on a large system, or had to take over someone elses code".

Yeah, and? Did I claim otherwise? No, I just called bullshit on bullshit statements. You on the other hand cannot even keep up with a discussion on Slashdot :/ I guess it's the lack of type checking that makes you fail so hard ^^ Bad code is bad code, you can produce unmaintanable code in just about any language you could mention. It's just unmaintanable code where you always know an int is going to be an int, awesome.

Re:Doomed

[Barbara, not Barbie]

Simple example - "automagic" unicode translation in perl - the only way around it was to write a program in c to crawl 40 gigs of data and manually get rid of the foreign characters.

Re:Doomed

[Thing 1]

Scripting languages do not give such errors until a user stumbles across them.

Well, "perl -c" processes a Perl script and reports any issues, without running it. This is similar to the errors and warnings you are expecting before deployment.

Re:Doomed

[OeLeWaPpErKe]

I work at a company that does lots of work in python, and the level of frustration with it is astounding. Lots of people *are* implementing important stuff in python, and it's always greeted with much enthousiasm, and even more sighing. You see, python is slow. Due to how we work it takes about 3 seconds to start a python program (we basically use a pip + virtualenv clone that allows you to take the fully downloaded virtualenv and package it into an executable file), which is not much but irritating as hell. And iterating through a large dataset takes ages.

The same routine, one that basically downloads a few tens of megabytes from the nearest datacenter was rewritten in C++. Why ? It's speed was about 2.6 MB/s (over a gigabit network). The C++ version was about 62 times faster (and faster inside the datacenter, where the rtt was much lower). And we have a java version that's also more than 50 times faster.

While it wasn't impossible to optimize the python version, that made it ugly, and even our best optimizers couldn't get it above about 15 MB/s.

"Language speed doesn't matter" - Sure it does. It basically makes it impossible to use your language for a big range of tasks. And it's such a shame. Python is a great language, strongly typed, with coding conventions that basically say "you must assign with static types", and structured in a way that almost all code can be compiled. And imho, what gives python it's power is the __* functions. It's much more like C++ with garbage collection than most people realize.

Re:Doomed

[rk]

I think you have that backwards. Good programmers know what to write; great ones know what to steal.

C isn't dead...yet.

[Anonymous Coward]

Well there is always been two sides of the medal balancing each other - convenience and performance, and i doubt it will ever change. And i think Ruby is really stands apart from other mentioned languages, a lot more sophisticated and carefully designed.

Re:C isn't dead...yet.

[durrr]

Convenient programming should be prioritized nowadays, most people at an entry level don't plan to code anything massive and performance critical anyway.
While I do love ruby(and processing, and ruby processing) I think there's a lot of room for improvment in convenience, perhaps at a massive expense of performance, but most people have a core or two, or five sitting idle most of the time anyway.

Ideally, programming should be a playground accessible to all, not like today where it's more of a military discipline camp accessible to all.

Re:C isn't dead...yet.

[TheRaven64]

It's also worth remembering that performance doesn't mean the same as it used to. An Erlang program, for example, typically runs at about a tenth the speed of a C program doing the same thing... when you have one core. On the other hand, it's pretty easy to write Erlang programs that scale up to 1024 processors (I've written Erlang code that, without any special effort, scaled almost linearly when moved from my single-core laptop to a 64-processor SGI machine and the profiling data indicated that the load was still pretty evenly distributed between Erlang processes so going to 512 or more CPUs would have been easy). When even mobile phones are multicore, this matters a lot more than single-threaded performance. There are lots of things in C that make it very difficult to get good performance when you go beyond about 16 threads (e.g. no differentiation between thread-private and shared data, no immutable-after-creation data types) but which were not a problem for single-threaded performance.

Re:C isn't dead...yet.

[alex67500]

Ideally, programming should be a playground accessible to all, not like today where it's more of a military discipline camp accessible to all.

I very strongly disagree. Good programming can't allow for lack of discipline. People who go for more "elaborate" languages, with loads of libraries available, should be forced to understand what goes on behind the scenes.

I remember a researcher in a biotech company I used to work for, who tried to get help on forums on the Internet, and published parts of her ruby code (she'd had a 4 hour lessons of ruby once at university). The code included (read-only) account passwords to a research database and her own AD password in the company. Plus the variable names left little doubt as to what she was working on at the time.

Bottom line is: she didn't know what she was doing, but someone trusted her with code, and put the company's research at risk. So no, programming is not a playground, it's a serious matter. And as far as you don't understand what a buffer overflow is (and a load of other things), your employer shouldn't allow you to code.

Re:C isn't dead...yet.

[durrr]

I did not advocate abolishing good coding practice or the "hard" languages, or intelligent thought.

I mean there ought to be a programming language my little sister could use casually. An intially level and smoothly steepning ramp to ease users into the world of coding. Not the current case where it's pretty much a solid veritical wall that is only slowly chipped down.

Example of inexperienced people doing stupid thing with professional grade stuff is common, your example is equivalent to some dense person in a workshop that ruins some woodworking tool by putting metal it in. Which is not an argument for banning all entry grade powertools. It's just an anecdote about a stupid guy, or girl in your case.

Re:C isn't dead...yet.

[bertok]

Good grief... so you're saying that by using Erlang you need a minimum 20 cores to get a measly 2x speed-up over a single-threaded program, which is probably easier to write too?

Multi-threaded programming is not unique to Erlang, writing parallel code in Java, C#, or even C++ is not exactly rocket surgery, so the comparison to strictly single-threaded code is unfair. I can get a program in any one of those languages to scale up to at least hundreds processors without breaking a sweat. Heck, any web application is automatically multi-threaded with both Java and C#, and with version .NET Framework v4.5 or later it can be trivially made asynchronous as well on top of that! You don't need a single lock or threading primitive of any kind to achieve that. If you want to get more advanced, all three platforms give you easy to use and powerful libraries to make multi-threading safe and efficient.

It's only the crappy open-source platforms written by non-professionals that struggle to scale, which is why Erlang looks so good in comparison to a lot of beginner programmers, and why Node.js is so fascinating to them. Ooo... look... we've invented asynchronous calls, which is brand new and fascinating, because clearly nobody has ever done that before...

The real benefit of Erlang is not speed, but reliability and online maintainability. It's designed for non-stop systems where uptime is more important than performance. This is explicitly stated in its documentation as the primary design goal of the language! Using Erlang to improve the performance of code is asinine. If speed matters, any of the three popular languages will run circles around Erlang.

That fancy 64-processor SGI box of yours? You've lost 90% of its performance to Erlang's inefficiency, so I could get the same performance out of a 6-core computer with an efficient programming language. I have 6 cores in my desktop. I bet it cost a few digits less than your SGI box.

Re:C isn't dead...yet.

[Viol8]

"There are lots of things in C that make it very difficult to get good performance when you go beyond about 16 threads"

What on earth are you on about? The language has nothing to do with threading, thats down to the OS. The pthreads API on unix scales to any number of threads and if the threads arn't being spread evenly among cores than thats down to a problem in the OS kernel , not the C library.

Also I suspect Erlang is a managed language and would therefor probably be pretty hopeless when used for multi process as opposed to multi threaded.

Re:C isn't dead...yet.

[TheRaven64]

What on earth are you on about? The language has nothing to do with threading, thats down to the OS

Nonsense. Well, sure, if you have 1024 threads doing totally unrelated things then the language doesn't matter, but then you may as well be using separate OS processes and getting some isolation for free.

Back in the real world, threads need to communicate and they need to share data. How the language represents this has a massive impact on scalability.

Re:C isn't dead...yet.

[lars_stefan_axelsson]

What on earth are you on about? The language has nothing to do with threading, thats down to the OS. The pthreads API on unix scales to any number of threads and if the threads arn't being spread evenly among cores than thats down to a problem in the OS kernel , not the C library.

Not even close. Erlang even uses it's own threading model since Posix threads are much too heavy weight. You can have (perhaps) a thousand threads, but hundreds of thousands; forget it. And a typical "telecom router" (like the AXD 301) Erlang implementation typically has a million or more running.

Also I suspect Erlang is a managed language and would therefor probably be pretty hopeless when used for multi process as opposed to multi threaded.

I don't know what you mean exactly by "managed" here, but no. Erlang was built for dependability, i.e. situations where you need more than one computer. It's built on message passing, and hence works just as well (or badly) all the way to the receiving thread being on another computer across the internet. The difference being that since it's functional and message passing is part of the language, it actually works and gets used. That's why we've seen some pretty amazing scaling at i.e. Ericsson, just by adding more computers/cores.

You'd do well to actually surf over to www.erlang.org and read some of the papers/reports on performance etc. I.e. while it's typically (much) slower than e.g. C on micro benchmarks, it's much faster on real application size projects. (The same as assembly was faster in micro benchmarks in the eighties and C was faster when it came to whole programmes.)

That said. These projects *also* contain a lot of C, it's just used where it's good, i.e. for device drivers and stuff like that. Not code with any "intelligence" in it.

Re:C isn't dead...yet.

[JoeMerchant]

I mean there ought to be a programming language my little sister could use casually. An intially level and smoothly steepning ramp to ease users into the world of coding.

MIT Scratch

Re:C isn't dead...yet.

[scamper_22]

Many people... not just employers don't understand the details of someone else''s craft.

I don't really understand the details of what my mechanic does. I don't really understand the details of a pharmacist's job. I don't really understand the details of a home repair/contractor/plumber/electrician person.

To me, a pharmacist seems like a glorified cashier. All conflicting medications can just be looked at in a database.

But what do I know...

I'm sure to someone else, the care I put into my craft is just extra fluff... and things can be done to work by someone else with much less knowledge and care.

The only question is do you want to regulate it.
You can ensure a certain level of professionalism by making something a true profession and restricting access into it. That's what doctors, lawyers, pharmacists... do. Has a nice side effect of keeping pay and working conditions okay.

But it's downside is less innovation and a lot of self-interest.

Would a web-site like slashdot even exist if it required regulated professionals to write code?

Re:C isn't dead...yet.

[TheRaven64]

Even the, you have problems. For example, Erlang enforces the rule that nothing shared is mutable. This lets it trivially lay out data in memory so that things that are shared are not in the same cache lines as things that are going to be modified. This can cause a big reduction in cache-coherency-related bus traffic.

While it's true that you can implement the message passing of Erlang in any language, it's worth remembering that it's often more useful to take things away from a language than add things. For example, removing pointer arithmetic makes a lot of things possible, such as accurate garbage collection and allows the compiler to rearrange data structures (this can be done in C if you have whole-program analysis and gives about a 10-20% speedup alone in something like the Linux kernel with a fairly naive implementation). A language like Haskell, which disallows side effects except via monads can reorder function calls and even perform them implicitly in parallel.

This is one of the reasons why we're starting to see other languages approach and surpass C for performance for the first time. The reason that C is regarded as a fast language is that it makes the programmer do a lot of the compiler's work. There is a fairly trivial mapping from C code to machine code and a naive compiler can do a good job. Even something like LLVM really does a fairly simple set of optimisations with C code but gets good performance. In contrast, you need to do a lot more to get the same baseline performance with something like Erlang or Haskell, but you then have a lot more headroom too: there are a lot of optimisations that are then possible.

They are not really new either

[DarkOx]

Ruby and python are really just variants of Object BASIC yes they have their unique syntax sugar and slight twists like Ruby where everything is a object even things like literal ints. None of that much matters having an itor on something like 5 does not really alter the design of my program it's just little shorter to type than for I=0 to 5; dosomething(I); endfor.

None of this bad as developer I rather like it, but I agree with the author it's not really innovative

Reinvention of LISP

[Compaqt]

> 'one striking commonality in all modern programming languages, especially the popular ones, is how little innovation there is in them!'

http://c2.com/cgi/wiki?GreenspunsTenthRuleOfProgramming

"Every sufficiently complex application/language/tool will either have to use Lisp or reinvent it the hard way."

So why do people (hotshots) keep reinventing the wheel, instead of contributing to libraries for LISP and/or Scheme?

For non-hotshots, get back to rowing at bottom of the ship with PHP and Java business-logic oars!

Re:Reinvention of LISP

[jelle]

(((((*what))) are(((you)))saying)))?((((there))))?

Wrong premise

[Anonymous Coward]

>under the premise that new languages don't come from academia

http://en.wikipedia.org/wiki/Guido_van_Rossum :

>Van Rossum was born and grew up in the Netherlands, where he received a masters degree in mathematics and computer science from the University of Amsterdam in 1982. He later worked for various research institutes, including the Dutch Centrum Wiskunde & Informatica (CWI), Amsterdam, the United States National Institute of Standards and Technology (NIST), Gaithersburg, Maryland, and the Corporation for National Research Initiatives (CNRI), Reston, Virginia.

Wrong premise.

http://en.wikipedia.org/wiki/Yukihiro_Matsumoto

>He graduated with an information science degree from University of Tsukuba, where he was a member of Ikuo Nakata's research lab on programming languages and compilers.

Again wrong premise.

Re:Wrong premise

[Anonymous Coward]

By "from academia" they probably meant just "pure and untainted by worldly matters".

Some time ago, Pacal and BASIC came from professors and were quite popular until recently.

And this one is undeniably "from academia" in literal sense:

History

The design of Scala started in 2001 at the Ãcole Polytechnique Fédérale de Lausanne (EPFL) by Martin Odersky, following on from work on Funnel, a programming language combining ideas from functional programming and Petri nets.[5][not in citation given] Odersky had previously worked on Generic Java and javac, Sun's Java compiler.[5]

Scala was released late 2003 / early 2004 on the Java platform, and on the .NET platform in June 2004.[3][5][6] A second version of the language, v2.0, was released in March 2006.[3]

On 17 January 2011 the Scala team won a 5 year research grant of over â2.3 million from the European Research Council.[7] On 12 May 2011, Odersky and collaborators launched Typesafe, a company to provide commercial support, training, and services for Scala. Typesafe received $3 million investment from Greylock Partners.[8][9][10][11]

Anyways, it's just too opinionated, from his 4 examples - PHP, JS, Python, Ruby - only PHP and JS are really widespread, with Ruby still rather rare and Python somewhere inbetween.

And then there's this pearl:

the languages designed by academics who are obsessed with internal consistency and correctness include a bunch of mostly dead tongues: Fortran, Cobol, Lisp, C and Smalltalk.

TL;DR: This dude doesn't know shit about history (well, and present as well)

The virtue of solving your own problems

[jholyhead]

When someone designs a programming language to solve a problem that they have, they are designing a programming language that will likely solve the problems of a lot of other people (unless you have particularly esoteric problems).

Matz has said that he built Ruby because he wanted a scripting language more powerful than Perl but more object oriented than Python. He solved his own need and that coincided with the needs of other people, making it a popular language.

Design-by-committee languages tend to feel like they've taken a blind guess at what problems need to be solved without consulting the people experiencing those problems.

Article contians junk

[serviscope_minor]

"Languages designed by academics like FOTRTAN, COBOL, C"

Were apparently desighned by academics obsessed with internal consistency and are now mostly deat tounges.

These are contrasted with languages hacked up by people to get stuff done.

WTF?

FORTRAN was the first ever language and was hacked up by someone who wanted to get stuff done because ASM was too much of a pain in the neck. It was unlike the author's bizzare assertion the easiest to use language at the time of being written. That was the entire point! While its use may be on the decline, it has been in use for 55 years! And major important packages are still written in FORTRAN.

And C? Seriously? Yet another language which was hacked up by a bunch of hackers to get stuff done. Apparently it's mostly dead. Even though it is the main implementation of 3 of the "less academic" languages listed.

I'm surprised there isn't a "c++ is dieing haha lol!1!111" in there too. I'm glad the author never tried to argue that C++ has internal consistency (I do love C++, but...).

And COBOL being an academic language? Oh dear.

Conclusion: article is crap.

Re:Article contians junk

[serviscope_minor]

Like what.

Well, LAPACK, which is central to quite a lot of things, for one. It's not new, but development is in no way static either, especially with SCALAPACK, etc.

I dodn't mean large new widespread things are being developed, but there are important things which are undergoing continuous development.

Also FORTRAN is best at maths which rules it out for quite a bit of popular things. Certainly supercomputer people still work in FORTRAN for new stuff from time to time.

Most visible programs don't do mathematical heavy lifting, and when they do, it's well hidden. Doesn't mean it isn't around, though.

Re:Article contians junk

[serviscope_minor]

are essentially two opposite statements (that both can be true).

And both can be false :)

Such as in the case of COBOL.

In fact COBOL is the perfect example of a language that was designed to be easier to use (I doubt the concepts of consistency and correctness for programming languages had been crystalized into something so formal by that time). Which is why it proved to be incredibly popular for many years.

Re:Examples include

[freedumb2000]

You should at least provide some arguments as to "why" you think those are bad examples. Otherwise do not be surprised to be modded flamebait.

Compiled vs. scripting languages

[Lazy Jones]

The article seems to ignore modern compiled (and carefully crafted) languages like Scala, Limbo, Go and tries to criticize the wide adoption of scripting languages among people who aren't really pure developers (as if they mattered!) and those developers who value development speed over quality, maintainability and performance or in places where network and/or human input latency abolish any other performance concern.

I would worry if important projects with large budgets and generous timeframes switched from Java to e.g. Ruby, but this won't happen. The existing compiled languages for such purposes are obviously very good already, so why should it matter that a new compiled-to-JS-language pops up every day?

Re:"coercing developers"

[jholyhead]

You've never been to a Rails convention have you?

horses for courses

[HarryatRock]

I have programmed professionally in more than 30 languages including machine codes, assemblers, FORTRAN, COBOL, Algol, C,C++, lisp, Prolog, and a variety of "4GL"s. I have used Java and Python since retirement and I can say one thing for sure about them all. Choose the right one for the job and you're half way done, choose (or be forced into) the wrong one and you you are going to pay for it in blood, sweat and eventually tears. On at least two projects (each being more than 50 man years of design and coding effort) it was worth devising a new language with a syntax suited to the problem and writing the compiler. For some jobs, readability of the code by non IT staff can give a huge payoff, for others raw performance is the only criteria. Real time interaction with physical systems usually needs a "lower" level, C or even assembler, Complex data requires object orientated structures and for once off "need it today" jobs, Java might be the answer. Maintainability brings another load of constraints, as does the intended "longevity" of the project, and don't get me started on the whole domain of "proof of correctness".
It is very easy to forget that a language is just a tool. If you only have a hammer you will find screwing a problem, but then you are reading this on slashdot.

Re:horses for courses

[JoeMerchant]

On at least two projects (each being more than 50 man years of design and coding effort) it was worth devising a new language with a syntax suited to the problem and writing the compiler.

Hmmmph.... I guess that's what I've been doing with .XML (and, things very much like .XML before it was named as such) all these years.

Re:"coercing developers"

[Anonymous Coward]

No. As a woman, I'm pretty sure I'm not allowed to attend.

Re:Examples include

[mikael_j]

Register globals has been off by default for I don't know how many years.

Magic quotes is officially deprecated.

What serious developer doesn't use PDO/mysqli and prepared statements?

True creation is from a person alone, usually

[hcs_$reboot]

I had to create a few simple languages during my developer years. I see the creation of a language like the writing of a novel. There is a direction, a style, a set of consistent syntax and rules. C, C++ or Java are for me good examples of consistent languages, lisp and Perl also.
And unlike the examples given in TFA, I don't think PHP represents a language created by a unique person - being too inconsistent on many respects.

Re:Examples include

[Richard_at_work]

The problem isn't "serious developers", it's those that aren't taking it seriously.

You can take all the precautions you like, but short of getting your own dedicated server and running nothing but your own code (or code you have audited), you are always at risk of the issues introduced by someone else. On a shared host, an exploit in someone elses code is only one local exploit away from your data...

Re:Examples include

[TheRaven64]

Any Turing complete language provides an infinite number of ways of solving any given problem. The difference between a good language and a bad one is whether the easiest and most obvious way of doing something is the correct way. The existence of things like register globals and magic quotes that can only be used incorrectly is a good sign of poor design.

Mod parent up

[Viol8]

"o no, programming is not a playground, it's a serious matter. And as far as you don't understand what a buffer overflow is (and a load of other things), your employer shouldn't allow you to code."

Amen to that. If only more people had the same views. Code is what keeps modern society running and the last thing thats needed is amateur hour when writing in critical systems. Just because any idiot can write simple code with a bit of training doesn't mean any idiot SHOULD be writing code. Any idiot could probably learn to fly a plane but I wouldn't want them at the controls of a 747 I'm in.

what does not?

[mapkinase]

>New Programming Languages Come From Designers

What does not nowadays?

I'm sorry but...

[blcss]

there's no way "the best tool for the job" can justify any of:

Java's badly designed core class library, with its lack of logical consistency and its abuse of structured exceptions.
C's preprocessor. There are better ways to implement constants and macros.
Multiple inheritance and operator overloading in C++. *
PHP semantics changing with each configuration.
Perl's horrible syntax. *
SQL's numerous security vulnerabilities.
LISP's non-procedural pretensions, and the contortions that result.

Nearly every language's dependence on its own class libraries, because interoperability is unthinkable. What's the point of living if you can't reinvent the wheel?

* "Well, just don't use those features!" Go tell that to the guys who wrote the code I'm expected to debug. If you can manage to track them down somehow. They're long gone.

So efficiency is no longer a worthy characteristic

[Jawnn]

FTA:

...marred them with ultra efficient syntax in the name of hardware...

I stopped reading right there.

Re:Examples include

[i_ate_god]

indeed, good thing they are removed then isn't it

Re:Examples include

[garaged]

Register_globals was completely removed in the latest PHP version out in the world a couple of days ago

Re:Examples include

[justforgetme]

Which is something that affects every single computation ever done, from meta programming to processor microcode to pen and paper multiplication.
So, yes it is true but also irrelevant.
As is the question of the AC that spawned this debate.

As is the story really (in my very honest opinion). I don't care where the language I program comes from as long as it behaves as I want it to. today languages are designed instead of being engineered. Ok, I'm pretty sure that when some mega corp or institute finds itself in dire need of creating a language, to solve all their computational problems, they will engineer one or design one depending on their needs. Compiler creation guidelines flow freely on the net and are available in books as well, Why wouldn't someone create a new language if he felt like it? And why wouldn't other people adopt it if they felt like it.

Whoever thinks that all technological progress should come out of universities is fooling himself, nothing bad is happening here.

Minor quibble

[brokeninside]

The difference between a good language and a bad one is whether the easiest and most obvious way of doing something is a correct way.

Re:Examples include

[justforgetme]

Come on Raven, this isn't even an argument. The two settings you talk about had a reason to be there, they provided functionality. Sure it is common sense now that this type of functionality has way too many drawbacks and this is why it is being iterated out of the language. All I see being talked about in this whole thread is features of languages that when used by some half informed programmer can have a bad effect.

Dear everybody: Please, get over it. Every language will bite you in the ass if you are going to create a big enough program in it. Every C writer in history has at some point written a buffer overflow, every code monkey an SQL injection, every rails genius a mass assignment vulnerability and don't even get me started on MicrosoftLand...

The fact of the matter is this: "It's not the language it is the DEADBEEF in front of the keyboard."

Re:I dont need to to learn another language just y

[cowdung]

Hey! You plagiarized MY first program!

Re:Examples include

[Richard_at_work]

No, it's not irrelevant, infact it's as far from irrelevant as it's possible to be.

You can use all the correct methodologies you want, but if you haven't secured the environment then you are trusting everything else to be correctly coded.

Now, with OSes etc that's always going to be a factor to a degree, but the situation here is when you are trusting every other developer hosting their code in a shared platform - in that case you can do everything correctly, you can use PDO, you can turn off Globals, but you can't trust someone else to have done the same.

So its utterly relevant that the issue is not just applicable to "serious developers", it's the 14 year old who has banged something out before bedtime and uploaded it to their host - a compromised account is still a compromised account, whether it's a "serious developers" account or not, and their compromised account can expose your data without you ever doing anything wrong (other than picking a bad shared host).

The problem isn't people creating new languages, its people creating new languages with gaping holes to start off with - register Globals should have been rejected from the outset, instead it became ingrained into the language to the point where it's taken a decade to get rid of it in the latest versions.

Re:Examples include

[TheNinjaroach]

What serious developer doesn't use PDO/mysqli and prepared statements?

What serious developer uses mysqli? (Just kidding of course!)

But really, all of our business data is on SQL Server or DB2/400. And the PDO drivers for either SQL Server or ODBC (DB2) are buggy and incomplete. Hell, the entire PHP implementation of ODBC is buggy, it intentionally trashes all numeric data types and instead treats them as strings.

PHP is my bread and butter, but it's also kind of a ghetto.

Sounds Like Someone's Mad...

[Anonymous Coward]

Sounds like someone's mad that they spent a lot of time getting a PhD only to find out that a PhD wasn't necessary to be successful in computing.

From TFA: "[T]here appears to be no correlation between the success of a programming language and its emergence in the form of someone’s doctoral or post-doctoral work. This bothers me a lot, as an academic. It appears that deep thoughts, consistency, rigor and all other things we value as scientists aren’t that important for mass adoption of programming languages. "

If someone doesn't come from a scientific background it's simply impossible for them to have deep thoughts and rigor in what they produce? I doubt it. I'm fairly certain that deep thought, consistency, and rigor were put into the programming languages mentioned in the article.

We need less elitism like that shown in this article. I may be jaded by the fact that at my university, our professors were horribly clueless about seemingly every modern computing concept and were still using Pascal to teach programming. When all academia taught was Pascal and even worse languages and old concepts, it's no wonder that people created other languages to get things done.

Re:Examples include

[Half-pint HAL]

Come on Raven, this isn't even an argument. The two settings you talk about had a reason to be there, they provided functionality. Sure it is common sense now that this type of functionality has way too many drawbacks and this is why it is being iterated out of the language.

But these are the sort of universal errors that computer science has been thumping on about for decades. New languages from within academia are generally rejected because they try to eliminate hacky coding and force good practice from the ground up. Meanwhile languages from outside academia are designed around the coder's own bad habits and reinforce those habits in others.

So what's not an argument? Even if the original designer of PHP wasn't thinking about shared services, the academics were, and people refused to listen to the academics, even going so far as to tell them to enter "the real world".

But sorry, if a job's worth doing, it's worth doing right.

C is lame, but very much worth using

[Medievalist]

C isn't a perfect language? The base language reads like a cross between Macro'd ASM and algebra. This IS the perfect syntax.

It doesn't have a data-type-independent exponentiation operator. It's got plus, minus, division, multiplication... but no exponentiation. Sorry, but that omission is just fundamentally retarded.

And I am a big fan of C, incidentally - I prefer it above other languages for its efficiency and near-universal portability. Only perl comes close to being as portable, and perl is a nightmare of overlapping, gibberishy TMTOWTDI syntax.

C's got serious problems. So does perl. Neither one is anything close to perfect, but they are almost certainly the best languages to write in because of their extreme portability. Using C, I can run code written for a PDP-8 on an MVS mainframe, a linux PC, or a DEC Alpha. Using perl, I can run the exact same code on windows and unix. It doesn't make sense for me to throw away that portability unless I am purposely writing a niche solution to compensate for a specific OS's problems.

Re:what a croc - they never heard of Greenspuns 10

[Surt]

LISP loses, and will continue to lose until they address the fact that the imperative-c-style is the right choice 90% of the time, and that the core advantages of lisp apply only to the other 10%. Which is why the languages that focus on getting the 90% right, and finding some way to manage the other 10% effectively will forever be leaving LISP in their wake.

She is right+++

[gestalt_n_pepper]

The fact of the matter is that not just programming languages, but entire concepts, frameworks and practices in computer science are completely untested for efficiency, human factors and most importantly, return on investment!

Examples include:
1) Patterns (Please include a measured, verifiable example of anyone who has saved or made money on this).
2) Agile (See parenthetical above. Extra points on why it's better than just meeting every day and discussing the problems and schedule).
3) The *new* programming language [insert favorite here]!
4) Programming languages with radically different syntax and models. Please don't bother with responses like, "They're *better* because... um....(mutter mumble) ... I like them!"
5) Unit testing (Qualifier: It is possible to make this useful, except that most developers don't and don't know how to.)