State of programming languages

K.I.L.E.R

Retarded moron
Veteran
So not to pollute the other thread with OT stuff, like a few posters have done, I have decided to continue the discussion.

*sigh* Java needs to catch up....
Java needs to die..

Why is it technology advances so fast and programmers are stuck with only rubbish?
All programming languages that I've seen are rubbish at best.

They can't read your mind, they are either too low level or too high level without control(I want control over this so I can code the way I want), they have too many features, not enough features, etc...

Personally I wish I could just hook my bloody PC up to my head and program that way.
I've read something on Slashdot a few months ago about computers linked to people's heads, how is that going?

When is the next update to C++ and what will it include?
What do future programming languages offer us that current languages do not?
 
K.I.L.E.R said:
Why is it technology advances so fast and programmers are stuck with only rubbish?
All programming languages that I've seen are rubbish at best.
Care to elaborate a bit ?

K.I.L.E.R said:
They can't read your mind, they are either too low level or too high level without control(I want control over this so I can code the way I want), they have too many features, not enough features, etc...
There's no language with TOO MANY features, if you don't like a feature set, just don't use it that's all, and it's way better than MISSING features...

K.I.L.E.R said:
Personally I wish I could just hook my bloody PC up to my head and program that way.
I've read something on Slashdot a few months ago about computers linked to people's heads, how is that going?
Well I think we all dreamt about it, but we are not there yet.

K.I.L.E.R said:
When is the next update to C++ and what will it include?
What do future programming languages offer us that current languages do not?
Did some search a while ago, JAVA is popular, C# is taking off (only because it's MS favorite and Windows rules), C++ is still very common...

Digitalmars D language can be somewhat seen as C++ done right, or C++ corrected.
C++ itself is still being enhanced.
 
K.I.L.E.R said:
Why is it technology advances so fast and programmers are stuck with only rubbish?

Because the technology which evolves is low-level technology; high-level languages exist for the benefit of the human programmer. Humans don't adhere to Moore's Law!
 
Ingenu said:
There's no language with TOO MANY features, if you don't like a feature set, just don't use it that's all, and it's way better than MISSING features...

A language with too many features, too complex of a grammar is a simple of a language that is not expressive enough. Too many features lead to unreadable to hard to understand code (Perl comes to mind). Now C# has anonymous classes, delegates, and lambdas. Does it need all three? No. Lambda functions provide all that is needed. It is better to include generalized mechanisms in a language along with ways for a programmer to build specialized mechanisms, rather than provide 3 separate first-class mechanisms.
 
Just as a possible thought...

How about the platforms/frameworks that allow multiple languages. Something along the lines of "best of both worlds"...

I'm thinking of the .Net/CLR/BCL type stuff (simply because I was reading the spec the other day). I'd find it quite convenient to do my UI programming in C# (or even VB), some low level device stuff in C++ and then implement some algorithms in F# (functional is an oft overlooked form).

Sure, theres plenty of cases where that causes a new set of problems and/or isn't perfect, but just an idea :smile:

Jack
 
Ingenu said:
There's no language with TOO MANY features, if you don't like a feature set, just don't use it that's all, and it's way better than MISSING features...

Well, this is all fine if you only work with your own code. Sadly, quite often this is not the case...and one of the reasons languages like Java and C# are so successful because they are missing (potentially dangerous) language features.
 
K.I.L.E.R said:
So not to pollute the other thread with OT stuff, like a few posters have done, I have decided to continue the discussion.

Why is it technology advances so fast and programmers are stuck with only rubbish?
All programming languages that I've seen are rubbish at best.
Making a good programming langauge is rahter hard. On one hand, you would want to design the language so that people can be as productive as possible in it while still producing programs of acceptable performance; on the other hand, you want to make the langauge simple enough that people can learn to program in it without being an Einstein/Hawking-class supergenius. I tend to get a rather distinct feeling that these goals conflict with each other; in particular, functional languages tend to split programmers into one camp that claims huge productivity increases and another camp that finds them incomprehensible to the point of utter uselessness (one prominent language in this category would be Haskell.)

Also, even if the Ultimate Langauge was unveiled tomorrow, there is still an enormous inertia to overcome, with tremendous amounts of retraining needed, and the Not-Invented-Here syndrome, and the enormous amounts of code written in lesser languages that still needs to be maintained.

If you were running a Java shop and was presented with a language that would make your programmers twice as productive for the rest of their lifetime, at the cost of 1/2 year of retraining, during which your programmers wouldn't be duing very much useful work at all, would you stick with Java or retrain your programmers? (this problem is similar to that of retraining your people from QWERTY to Dvorak keyboard layout; while Dvorak has a widespread reputation for being superior wrt typing speed and RSIs, actually getting people to change over is difficult, expensive and time-consuming enogh that few organizations ever actually try such a stunt.)
They can't read your mind, they are either too low level or too high level without control(I want control over this so I can code the way I want), they have too many features, not enough features, etc...
In the absence of mind-reading capabilities, I prefer to have languages with strong static error-checking capabilities - it is much quicker to fix compile-time errors than runtime errors. As such, I find e.g. the rich-but-strict-as-hell type system of OCaml substantially more attractive than the much looser type system of C++. (That does NOT however mean that I find a language like Pascal very enjoyable; it is strict in a remarkably useless manner, to the point where is it just painful rather than helpful.)
Personally I wish I could just hook my bloody PC up to my head and program that way.
I've read something on Slashdot a few months ago about computers linked to people's heads, how is that going?

When is the next update to C++ and what will it include?
What do future programming languages offer us that current languages do not?
Hopefully, future languages will offer facilities that make concurrent/multithreaded programming at least somewhat less painful than death by a thousand papercuts. Langauges like Fortress, as well as the recent Tim Sweeney presentation, are interesting steps in this direction; Java and C# are NOT. This is getting rapidly more important; the difference may not be dramatic with today's dual-core processors, but Intel has 100-core processors on its roadmap and programming THOSE in C-family langauges (C/C++/C#/Java/D) is not going to be pretty.
 
Ingenu said:
There's no language with TOO MANY features, if you don't like a feature set, just don't use it that's all, and it's way better than MISSING features...
Too many features in language leads to a number of problems:
  • Maintainability: too many features will cause programmers to just learn and use the subsets that they are comfortable with, resulting in code that other users of the language cannot take over and maintain in a proper manner.
  • Implementability: too many features makes the language too hard to implement, with the result being half-implemented features, buggy features, odd incompatibilities between implementations etc.
  • Interactions: The features of a language will unavoidably be made to interact with each other as programmers explore the language. An excessive feature count leads to a combinatorial explosion in the number of possible interactions, all of which need to be specified and handled in some semi-reasonable manner.
  • Verifiability/Optimizability: too many features, especially if they interact with each other, makes it extremely hard to reason about a program's correctness. It also can take away guarantees that would have helped the compiler to perform good error checking or decent optimization, thus harming both productivity and performance.
OTOH, making a small language that is super-extensible is not necessarily a panacea either; the great extensibility of e.g. LISP has resulted in a proliferation of incompatible dialects, which AFAICS has substantially hampered the acceptance of the language.
 
JHoxley said:
Just as a possible thought...

How about the platforms/frameworks that allow multiple languages. Something along the lines of "best of both worlds"...

I'm thinking of the .Net/CLR/BCL type stuff (simply because I was reading the spec the other day). I'd find it quite convenient to do my UI programming in C# (or even VB), some low level device stuff in C++ and then implement some algorithms in F# (functional is an oft overlooked form).

Sure, theres plenty of cases where that causes a new set of problems and/or isn't perfect, but just an idea :smile:

Jack
The problem here is of course that each language has its own idea of what kind of world it operates in; if two languages have different ideas in this respect, it can open up a rather substantial can of worms each time you need to interface between the different languages in the framework. For .NET, you can take a look at this paper for a description of some ways in which C#'s view of the world differs from that of the underlying MSIL assembly language and how you can exploit those differences to induce some rather unexpected behaviors in C# programs.
 
Ingenu said:
There's no language with TOO MANY features, if you don't like a feature set, just don't use it that's all, and it's way better than MISSING features...
Unless you are
  • The compiler writer
  • Someone who has to maintain code written by someone else who has used obscure feature #125376 !!!
Did some search a while ago, JAVA is popular, C# is taking off (only because it's MS favorite and Windows rules), C++ is still very common...
I would say that plain-old C is still pretty common as well. If you want something to be portable to multiple platforms then it's a safe bet.
 
I can't really figure out a language featureset that would be a problem... :???:

In C++ you can use plain arrays or STL, also you can have parameters which are references, constant references, pointers, constant pointers, pointers to constant objects, constant pointers to constant objects, would you mean that there are too many way to give a parameter in C++ and it should only have, say, references, just like in JAVA ?

I don't think anyone would design a language with thousands of ways to perform a single operation, so I rule out such extreme cases, that leave stuff like C++ (a real language, nothing hypothetical), with sometimes half a dozen way to do something...
 
arjan de lumens said:
this problem is similar to that of retraining your people from QWERTY to Dvorak keyboard layout; while Dvorak has a widespread reputation for being superior wrt typing speed and RSIs
I don't wish to derail this thread, but do you have any further information on this?

I've got a Dvorak Microsoft keyboard sitting under my bed. Got it free from MS last year, but being a native QWERTY user I couldn't get anywhere with it. Stuck it back in its box and never used it since... but if its supposed to be that much better then I might give it another try...

arjan de lumens said:
The problem here is of course that each language has its own idea of what kind of world it operates in; if two languages have different ideas in this respect, it can open up a rather substantial can of worms each time you need to interface between the different languages in the framework. For .NET, you can take a look at this paper for a description of some ways in which C#'s view of the world differs from that of the underlying MSIL assembly language and how you can exploit those differences to induce some rather unexpected behaviors in C# programs.
Yup, won't disagree with what you've said. I used the .net example just to get my point across (and I couldn't think of any other examples other than old-school COM/COM+/DCOM) - I wasn't necessarily trying to say .NET is a particularly good example of such a paradigm.

Cheers,
Jack
 
Simon F said:
I would say that plain-old C is still pretty common as well. If you want something to be portable to multiple platforms then it's a safe bet.
The industry standard software I was working on at IBM was still 20% assembly language, then a bit of C (not C++) and the rest was all PL/X... Yet a large number of customers accessed said API via Cobol/Java...

Jack
 
I like Boo *blush* It is really convenient somethimes. The collection handling is very nice...

BTW, what about such cool features as aspects and extendable classes? Does anyone use it?
 
Simon F said:
That sounds like a marriage made in .... an asylum!:oops:
haha, yeah - the software is over 35 years old now... so its bolted on the newer technologies as/when they popped up.

I forget how many times the senior engineers went off on rants about how interfacing with Java was a nightmare. These were the types that liked writing in pure assembler and saving any/every cycle they could.

Jack
 
arjan de lumens said:
OTOH, making a small language that is super-extensible is not necessarily a panacea either; the great extensibility of e.g. LISP has resulted in a proliferation of incompatible dialects, which AFAICS has substantially hampered the acceptance of the language.

I'm not sure that's what hampered LISP's acceptance. Languages don't exist in a vacuum, languages exist on runtime platforms. The situation is no different with C/C++ and other languages where you have a proliferation of incompatible *libraries*, since for languages without extensive metaprogramming, it is library APIs which provide the pseudo-language extension.

Now, I would say that one of the big reasons for the success of Java, Python, Ruby, et al, is the fact that the libraries are mostly 100% portable and included by default bundled with the language tools. With C/C++ you get the Standard Library, but if you want XML parsing, or cryptography, its always some unbunded third party library that may or may not ship with your environment.

The fact that LISP and Scheme can be extended via macros to make other dialects IMHO is not what torpedoed them. Historically, a combination of poor performance (not true any longer), default environment bindings driven by academia not commercial interests (how do you write a business GUI database app?), and plain ole aversion to prefix syntax, that I think eroded support. Nowadays LISP/Scheme are viable, run fast, have good IDEs available, but the damage has been done, and Java/C# stepped into the vacuum. It will be hard convincing the enterprise world to drop them so quickly.

The lesson of Java/.NET is that programmers derive value not just out of the language, but out of the runtime libraries and devtools, and that if you want a a language to be successful, excellent syntax and semantics of the grammar is not enough to succeed.
 
DemoCoder said:
I'm not sure that's what hampered LISP's acceptance.

Perhaps it's syntax is the problem? There is a reason why people call it names like "Lots of Irritating Stupid Parenthesis". :D
 
I think the next major language cannot be entirely textual like virtually all languages today. I think things like auto-complete and auto-refactoring are a crude attempt towards this. Eventually they will morph into a language that's more like a relational database that describes your program, and it will be possible to view this description from a multitude of persepectives. This will be facilitated by automatic language conversion tools and many other things. For example, you'll be able to look at a particular piece of program as C++, C# or any suitibly descriptive format, or go with something completely different like a directed graph, a representation of abstraction layers or a metaphorical model using symbols, images and maybe plain English. That is, the next major language will be inherintly transmutable.

As such, I think the real measure of a language is it's covertablity into other languages. If it's universally convertable, then it's a universal language. This includes both conversion into human conception and machine conception, although not necessairly at the same time. As an example of what I mean, XML is a universal data descriptor and while it can be converted into human understanding fairly well, the same can't be said for machine conversion. However, since it is a universal format, it can be converted a machine friendly form. In general, data, which includes a program's description or code, should be natively stored in a universal format that is most sensible to what primairly interacts with it, then transformed into other appropriate forms when necessary. In other words, the image of data should suit the viewer, and to do this it must be able to morph into all its equivalent variations.

In my personal study of language design, my goal is to create something powerful enough that, when approprate, people will prefer to express themselves using that format rather then their native language. My motivation is that many times there are complex inter-depentand ideas and thoughts I wish to express where the linearily of English is simply not suitable. Organising bookmarks and files is another example of this, where a heirarchial file system is limiting, but so is the flatness of pure tagging ala del.ici.ous. What I desire is a format where I can contruct, disseminate and parse ideas in both ways. Simply state my relationships and dependancies, regardless of their linearily or non-linearity. Now, I have a system designed to do this already, but not the time to program it, lol. Maybe I should post it here.
 
Last edited by a moderator:
Back
Top