
The most common myth about programming - lisp_me_away
https://www.quora.com/What-are-some-of-the-most-common-misconceptions-myths-about-programming/answer/Max-Ri-1?share=466260cc&srid=aPrS
======
postit
I believe the most common myth about programming is that you have to be a
genius or you won't ever be good enough.

~~~
DamonHD
Careful, logical, thoughtful, and a bit creative are all good.

Thinking oneself to be a genius is generally a handicap from observing hires
and peers who have! Dunning–Kruger ahoy...

------
DamonHD
Cor! That's rather belligerent. There's lots of ways of doing a good
programming job, appropriate to the task in hand, and being able to pass a
lambda as an argument is not the only measure of such. And I speak as someone
lucky enough to have been able to pass and curry lambdas since the 80s, BTW...

~~~
lisp_me_away
I seriously doubt that someone like yourself, who's been currying since the
80s, would invent a language that didn't have multi-line lambdas. And that's
the whole point.

~~~
DamonHD
For shell scripting?

For all (new) DSLs?

For assembly languages?

Functions as first order entities are nice, but plenty of new code gets
written in languages without, eg C, because it's up to the job. Just because a
feature is nice and useful for some high level algorithms and languages, does
not make it indispensable for all tasks.

I've spent most of my professional life managing without just fine for
practical purposes. Unless you'd like to admit special cases such as Java's
single method inner classes for example.

The 30kloc of C++ (11) we now have running an energy-saving radiator valve
(TRV) does have some lambdas, because they're handy, but I'm not sure that any
of them are multi-line to be really specific in rebutting the claim...

~~~
lisp_me_away
This is not about using lambdas everywhere all the time. This is about
recognizing that those who create programming languages are not omniscient.
I'm not sure why you're so adamant about misrepresenting my point.

~~~
eesmith
This isn't about recognizing omniscience not. This is about bad-mouthing
someone who wrote a programming language that doesn't support multi-line
lambdas.

(Bad-mouthing: "not at this level of of programming", "This is a really huge
problem because only 25% of people are capable of thinking for themselves",
with the implication that van Rossum cannot think for himself.)

Explicit in there is the view that one _must_ program with multi-line lambdas
in order to be at a higher level of programming competency. A view I disagree
with.

Your account name is appropriate as this is sort of smug attitude seems common
among Lisp fans. I think they see Lisp (or Scheme) as a jewel of a language,
but feel themselves in the doldrums of the programming world. They can't
figure out why others aren't using it, and decide that others must simply be
sheep.

That's bad-mouthing as well.

