MicroPython or CircuitPython have become better entry points than the full language.

Python grew up and has been chosen to solve a lot of complex, important problems. This has lead to the language ballooning to become not just good but excellent for those problems (data science). Some of it might be fluff; much of it might not be relevant to your style or problem space.

Ye for the professional programmers using Python I guess the changes are welcome. It is easier to keep up with additions over time rather than getting them all at once. C++ has the same problem, but it's selling point has never been easy to use.

I'm one of those people who worry that Python - which used to be pretty accessible - is heading in the same direction as C++, and will be buried under archaeological layers of cruft and obscurity.

2.x and 3.x seem to be diverging philosophically, and I'm not convinced that's a good thing.

C++ during the 1990's was easy enough to be learnt by high school kids.

Ease of use and ease of learning are often at odds with performance.

A go-kart is easier to learn and to drive than a Formula 1 car.

Throwing money/time/effort at it sometimes changes things. Javascript and PHP do pretty well on some specific workloads now for example.

Some of the best drivers started out in go-karts, something about the feel of the road and getting the most out of such a limited vehicle.

I would not call python a go-kart I would call python a mini-van. Boring and looked down upon, but is the best vehicle around for doing your daily activities in.

Large code bases are always going to be hard to read for beginners.

As an introduction language, I don't see why you would need to use decorators, generators or anything? You don't need to learn control flow, functions, variables, etc. You can perfectly write python without all the fancy stuff. In fact, there are quite a lot of data scientists who are paid to write python and don't know the first thing about concepts as seemingly basic as classes.

> I don't see why you would need to use decorators, generators or anything? You don't need to learn control flow, functions, variables, etc.

I think the point here, is that when beginners start exploring what's out there in "professional" lands they'll quickly discover that they don't know Python at all, because they were using this primitive subset of a language.

But you always start by using a primitive subset of a language.

But in what language is that not true? You start learning any language by pieces, and just because you know 10% of the language doesn't mean you're ready to write it professionally, this is true for any language.

> and just because you know 10% of the language doesn't mean you're ready to write it professionally

I don't see why not. Plenty of folks learn on the job, including new languages, and the way things work out you might end up implementing some things sort of by kitbashing, knowing relatively little of the concrete details that you end up learning completely more later on. I do this all the time.

At what percentage of knowledge are you ready to use the language professionally?

> But in what language is that not true?

go, but that brings along its own set of bug bear problems

But that’s so exciting! More frontiers to explore!!

To compare, let's look at C. At "only" a couple hundred pages, the C language spec is simple enough. The language doesn't have all those fancy things like decorators, pattern matching, lambdas, etc.

But after 30 years of programming, do I actually know C? Once I dig into C compilers, undefined behaviors, etc. I can also quickly convince myself I actually don't know C at all...

I feel like python has never been a good introduction language. It is simply too abstract and hides too many details that are often required in other languages (Python is simply too flexible). It is good to learn if you are only scripting or calling library API, but I feel like it is a poor starting point if the goal is to transition into languages with more rigid structures such as C++.

Python is a good learning language precisely because it hides those details. This allows people to the learn the basics like variables, loops, strings, etc without getting overwhelmed with too much at once.

This absolutely provides a good foundation to learn lower level concepts later, although going bottom-up and starting with a language like C is also a valid path.

It’s also worth noting that a large proportion of developers will never learn C++, and will stick to higher level languages their entire career. And another chunk will only learn the lower level stuff much later when they have many years of experience to lean on.

If your goal is to immediately become a C++ developer, then you should learn C++, but that isn’t most people learning to program.

>>> Python is a good learning language precisely because it hides those details. This allows people to the learn the basics like variables, loops, strings, etc without getting overwhelmed with too much at once.

I wonder if whether this is a blessing or a curse depends on the person who is learning it. For instance, my first language was BASIC in 1981, and so my gut reaction to discussions about learning languages is that BASIC lets you at least imagine the workings of the machine that's running your program. The teacher can draw boxes on the blackboard to explain 10 LET X = X + 1

And we weren't far from the machine. There were not very many turtles on the way down to the level of logic gates. I also learned how a microprocessor worked, reading books as a high school kid, and articles in Byte Magazine, something that would be laughable for today's big CPU's.

That's a bottom-up approach. For others, a top-down approach might be better, e.g., seeing mathematical equations develop, in beautiful notation, without caring what the machine is doing under the hood.

Another comment in this thread mentions the ability to read code. Python has sprawled. I've been coding in Python for 10 years (as a "scientific" programmer) and recently took a Python skills quiz. I mentor beginners. Yet I scored barely at the top of "average." I can't read the code that's in a lot of the more elaborate Python packages.

A problem is motivating people to learn a learning language when they know that they'll outgrow it.

I'm not sure I understand what's missing in python compared with BASIC.

Sure, you can teach students to write `print(" ".join(str(x) for x in range(1, 11)))` to print numbers from 1 to 10... but you don't have to do that. In fact, `X = X + 1` works just fine. The old school BASIC style like `X = 1; while X <= 10: print(X); X = X + 1` still works in python. (sorry for the lack of indentation)

What am I missing? (besides the misguided social expectation that you need to teach the fancy generator stuff to a total beginner...)

That's a good question. What I'm thinking of (revealing my age) is something more like:

    10 LET I = 1
    20 PRINT I
    30 LET I = I + 1
    40 IF I <= 10 THEN 20
    50 PRINT "DONE"

And because BASIC really is that primitive, you can talk about what each line of code is doing, without too much fiction. The mental virtual machine is not radically different from the real machine.

The teacher would draw the variables as boxes with numbers in them, and update the numbers in the boxes with the eraser and chalk (further revealing my age).

In contrast, Python starts with everything is an object, with properties and methods...

But I agree about the fancy generator stuff. I think you can teach Python in the same fashion by limiting yourself to a few basic (sic) features, and adopt the same virtual machine fiction while remembering that it's a few more layers of abstraction away from reality.

  40 IF I <= 10 THEN 20

Do mean "GOTO 20"? Because if you don't that line either makes no sense or has a "magic" implicit goto that has to be explained. Assuming you meant that as a loop then the equivalent in Python is hardly difficult to understand:

  i = 1
  print(i)
  while i <= 10:
    i = i + 1
  print("DONE")

Same number of lines of code, `while` has a clearer meaning than the magic of your goto-less line, and is still somewhat clearer (more comprehensible control flow) than the goto version of that line. The only missing thing is the explicit line labels, but that can become a presentation format when discussing the code. Every editor you'd start a student with can show line numbers (and many show line numbers by default).

You don't have to start with "everything is an object", but you will get there quickly. Teaching procedural programming centered on numbers and strings and basic control flow in Python is not a challenge for a competent teacher. And then the language can grow with the learner as they gain understanding of computing and programming.

Indeed the GOTO was implicit. Putting other things after THEN came later, as did the while loop.

Properties do change things because they change the data representation, but i.print() is really no more complex than print(i).

While learning, hiding details is important, but Python overdoes the abstraction. `for` loops and iterator based loops have been merged into one thing, and I am sure people write `for i in range(10)` without a good understanding of what the `range` function does. Even strings blur the line between individual characters and actual strings. The lack of clarity at these basic concepts is precisely why Python is not suitable as a first language, since it hides concepts that are prevelant in all other mainstream languages. As a result, I have often seen students develop bad coding habits and poor mental model of why their code works. Instead of learning proper programming concepts, they just know the syntactic sugar and abstractions that Python offers.

I do agree that Python provides a very small startup cost to writing code, the details are sacrificed to acheive this. This may be useful to capture interest/generate motivation and get a quick prototype/"helloworld" out, learning Python is only good for learning Python, not for programming in general.

If you can understand the “for i in” part means then range should not be hard to grasp. I would argue that someone new to programming with even a modicum of logic might be able to guess what range does easily .

Frankly I think classic c-style for loops are a terrible abstraction for beginners. Iterator based loops make sense on a high level ("I don't care how it works, I only care what it does"). While loops make sense on a low level ("I can see how each piece works"). To a beginner, c-style for loops are just an obscure, implicit syntax for while loops.

> Even strings blur the line between individual characters and actual strings

IMO that's better than what C++ does, where it pretends that a character is a single byte. Whereas most code nowadays is using unicode, which means that code will break as soon as they try to store a non-ascii character in it.

Range is horrific for beginners. Try explaining to a kid learning coding why his times table program needs to say ```range(1,13)```. There are excellent reasons for this construction, and to prefer half-open ranges, but providing a good on-ramp for kids ain't one of them.

C++ is way too big to be an introduction language, and modern C++, especially with STL, also hides a lot.

You could choose a subset of C++ or just teach C (which would be my preference)

I upvoted you even though this is wrong because it raises a good point.

If I was teaching beginners I’d do 1/3 python assignments and 2/3 C.

They need some easy wins at the start and to learn control flow and basic concepts. But mixed in with that we’d do C and learn what’s happening under the hood.

The easy wins are so key. I remember my intro class and we had to just copy some C++ code and compile it. Even though I felt like I copied the code exactly I got these incomprehensible error messages and just felt overwhelmed.

I actually quit the class after feeling like nothing would work and not having any fun.

Only years later doing a project in Visual Basic did I realize coding could be fun.

> It is not possible for a from zero beginner to read ordinary Python code with decorators, generators or what not and understand it.

Having taught beginners both python and other languages, I’d say it’s significantly easier to teach decorators than it is to teach higher order functions normally. Because in python the students have already seen, used and understood what the cache decorator does before we even touch the concept of a function returning another function, which they always need some time to grok, both in python and other languages.

As for generators I’ve never seen anyone struggle with them. What do you find difficult to understand about generators?

Generators have a few footguns even for seasoned developers, calling len(mygen) or mygen[4] works, but after that it's empty when trying to iterate it. Particularly problematic is when someone adds a log of the generator content, exhausting it before before it is used. All this leads to people shotgunning mygen=list(mygen) on everything, without understanding what really happens.

How one could solve this i don't really know, generators are such useful concept that you can't really remove them either, and you still want them to be compatible everywhere other lists and iterables are. Even with type hints, it's not exactly obvious when you type the code whether a certain variable is a generator or a concrete list, both of them mostly adhere to the same protocol.

I still love the interactive interpreter. It's such a fantastic, no friction, teaching tool, especially for in person demonstration of fundamentals with immediate feedback. Its been an invaluable tool in showing my daughter (9) concepts I have difficulty describing in a way she can understand.

Many of those concepts were already present in the language for the last 20 years.

A zero beginner doesn't need to read ordinary Python code with decorators etc. The beauty of Python as a teaching language is that none of those things are necessary to explain or handwave to write simple apps that just input and print strings and numbers - which is just enough to teach basic concepts like conditionals, loops, functions etc. For bonus points, it even has turtle graphics out of the box, which is an excellent visual explainer for more advanced concepts like recursion.

And when they've learned the basics on toy stuff and want to start writing real-world apps, that is when you explain decorators, generators etc. And yet they don't have to switch to a whole new language - all the basics they've learned still work exactly as they did before.