A great language will make crappy programming harder.

Is that necessarily a good thing? Surely then it's harder to decide who is a good programmer and who is not.

I never said that a good programming language will make a bad programmer write good code, just that it makes crappy programming harder, eg by providing you with a choice of tools and constructs so that you can choose what makes sense for the task, instead of having to force some language feature to do something it really isn't suited for.

If you have nice language features for the various tasks which you are trying to achieve, then the code will be better than if you don't. If these features are designed in a way that promotes good, clean, reusable and easy to understand code, then it makes crappy programming harder.

Bad programmers will always write bad code and good programmers should always be able to write good code. A good language doesn't get in your way, it helps you and so a good programmer can write great code with the same amount of effort as a good programmer writes good code in a lesser language.

Who cares who's a good programmer and who's not? What matters is what gets made, and if people are making cool stuff then I don't care if they're completely inept. Hell, I'm completely inept and I've found it doesn't matter as long as I end up with a product people want to use.

Who cares who's a good programmer and who's not?

The poor soul who has to maintain your crap.

it doesn't matter as long as I end up with a product people want to use

It does matter when it comes to maintaining that code base. When maintaining crappy code, only bad things can happen:

  1. It takes too long.
  2. It costs too much.
  3. It doesn't get done at all.

"cool stuff" and "completely inept" are contradictory terms.

You may not care, but enough of us do that you should get better at your craft and spare the rest of us.

Well, if the code thats produced is good, then I agree with unalone - it doesn't matter if the programmer is good or not.

Of course, if the code IS bad, then sure, but would that not kinda go against what I was saying in my comment? Its all about solving a problem in the simplest, cleanest, most complete (ie, the problem isn't solved when corner cases are ignored) way. If a language is truely good, it will help programmers, good and bad, to achieve this. If the bad programmer then manages to produce good code, then (s)he is indistinguishable from a good programmer. (The difference between the two then becomes that the good programmer can do this with most problems, while the bad one with only a subset).

You're making the assumption that I code things that require maintenance from other people, and that I code for a living. I code for fun, and I make small things that other people happen to enjoy, things simple enough that once I get them working the first time, they don't break. When I work on major projects, my partner's the programmer, not me.

Language designers want to create languages that professionals will use. Maintenance is a problem for any professional. You're lucky not to have to deal with that problem but that doesn't mean language designers are mistaken for engaging in attempting to find a solution to that problem just because it doesn't affect you.

Please let me answer you in one thread before you repeat your counterargument. I've answered this as you posted this second one.

Yes, ease of programmer ability ascertainment should not be a concern of a PL but I don't support your "as long as I end up with a product people want to use" philosophy that belittles the importance of the means used to reach an end. When discussing PLs you are discussing means. If you don't care then I don't understand your interest in this post.

I wasn't saying that programming language doesn't matter. I was saying, in regards to axod's specific point that "great languages make it harder to write crappy code" might make it harder to decide who's good and who's not, that the goal of a programming language isn't to let people judge other programmers. It's to let them write code.

Only true if, by harder, you mean relative to the good practise that it makes easy.

I definitely agree. My comment was vague (and was meant as joking stab at the parent). A good language will aid the programmer with whatever task the language was designed for. A text processing language will make writing bad crappy text processing code harder compared to writing good text processing code. That doesn't mean that writing, eg, a GUI in this language will be easy, however.

I agree, but I did have an intense moment with Fortran II that effectively launched me into a compiler-writing career.

And actually a second point was a zero-knowledge dislike of COBOL. This faded when after a couple years of RPG-III, a COBOL compiler was installed. Felt so much better.