Hacker News Reader

Comment by noelwelsh | Hacker News Reader

Reading this I can't help feeling that Python puts the "simplicity" in all the places that don't matter. Simplicity is the reason given for not having useful language features like pattern matches as expressions, or lambdas with multiple expressions, but I've never seen these features[1] cause problems in other languages. And then we have this... Surely semantic simplicity is the simplicity that actually matters, but the way the simplicity argument is used in Python is often to enforce arbitrary syntactic and semantic complexity.

[1] It's almost ridiculous to call these features as they're just a consequence of the underlying language model. E.g. if you have expression blocks you have lambdas with multiple expressions with no extra work.

View on HN

Python has plenty of complexity. It tends to stick it in places where new programmers don't run into it. Python is one of the few languages I know that lets you just... poke at the internal machinery like this.

Have you ever messed around w/ Julia? It doesn't really have much "internal machinery" since it relies on a data-oriented/functional language structure. I find myself reading the Julia source code on a regular basis since it's very readable and succinct. I often find it more useful than the documentation itself.

It can take a bit to fully understand/appreciate Julia's multiple dispatch, but once you do you pretty much understand the entirety of the machinery.

These are fair examples, but 'Python puts the "simplicity" in all the places that don't matter' is a bold statement that isn't well supported by these. I work primarily writing hit-and-run R&D code that has a shelf-life of about 6 months - python is either one of, or the best scripting languages for this, precisely because it puts a lot of simplicity in places that DO matter.

Python is hands down the best ecosystem for "hacking something together to prove a point but won't be maintained".

It's (a) extremely easy to learn (takes about 2hrs for a Java/C# dev to be productive) and (b) has a very deep ecosystem and wrappers for pretty much any native library you want. Then (c) it works great under Windows/OSX/Linux as long as you're on an x86/x64 platform. The clincher is (d) it's the de-facto beginners language so all the newbies can at least read it and hack away.

The competition:

* PHP is similarly easy but very limited.

* Ruby is in my experience a slow and buggy mess with a community who are welcoming but suffer from a reality-distortion field (might be different now, my experiences were 15+ years ago).

* Java has accidental complexity getting started.

* C# is competitive but for the low-skilled / newbies too hard and still has an irritating NIH syndrome (e.g. pushing people to MS's half-baked crypto APIs instead of first-class ports/wrappers of libsodium / BouncyCastle).

* Javascript/Typescript are probably the closest, they have better package management for the "hack it together" use-cases but the language itself poorly designed what with all of the unintuitive "surprises".

My kids are just about old enough to learn coding and I'm going to start them with Python before moving on to C, ASM then if they want to develop anything serious; C# / Java / Rust / TypeScript.

I agree thoroughly with this - it's fantastic for building something quickly. If I need a quick script to do one-off data processing there's nothing better. My biggest problems with it IMO with respect to maintainable software are:

- The syntax required to build libraries feels like messing with the internals of the language. Defining various methods with reserved names that have 4 underscores each doesn't really feel like something you are supposed to do. The code becomes harder to read and messy IMO.

- Runtime type checking is great for iterating quickly, but bad for stable software.

- Encapsulation is only enforced through external tools, so if you aren't using those religiously you end up with problems with tightly coupled modules.

- Dependency management is not a good experience. Understanding the different rules about where python pulls modules from is hard. Venv makes things a bit better, but even then it's still a bit opaque. It means that I often spend more time on getting external dependencies aligned properly than writing any python when working on a python codebase locally.

I have to admit - I use C# for that nowadays, at least as long as I don't have to follow the standard coding guidelines (which are great for software with a mid/long life-cycle). Once you get over the learning curve and don't have to apply good engineering practices (i.e. write code comparable to Python/Go norms) then it's way more productive (time-to-working-solution) and dependency management is great. The best bit - a huge amount of effort is going into reducing boilerplate so it's getting better and better with each release.

If I'm working with less experienced developers or people for whom software engineering is a side issue (researchers/academics, security experts, data-scientists) then it's Python all the way.

What about Julia? It's as readable as Python. Julia is arguably easier than Python in some programming aspects. Both languages can be complicated in more advanced scenarios, but both languages tout an easy start for quick scripts.

Every time I've looked into Julia (it's been a while, last time was around last year), I've hit one or more speedbumps or outright roadblocks in something which comes fairly naturally to python stdlib, or has a library ready to go. If I'm doing just mathy, data-sciency type work, it's usually pretty great. But domains like IO, http (servers or clients), IPC/RPC, database work, AWS, stuff like that always felt at best a bit unpolished.

That's not to say these are impossible in Julia, but there was enough friction to make me not really wanna use it, when python can do all that and more.

Lua needs mentioning here, on a 1-5 scale where more is better, I rank it (a): 4, (b): 2, 3 if you're using LuaJIT, (c): 5, and (d): 5.

That last one is the surprising one: we're about to see a generation of programmers who learned Lua via Roblox when they were 8-13 years old. Roblox is singlehandedly in the process of making Lua the #1 beginners language, and if not the most popular language by number of developers, then at least the most undercounted.

I use Lua all of the time, since it's such an easy language to embed in other projects.

I use it in embedded systems (think 128MiB of memory -- not tiny, but not enormous either) and it's fantastic. I can make changes to logic on the device without cross compiling things and I can make changes quickly to test things out.

I'm in my 40s, and definitely not part of the Roblox generation. I just really like the simplicity of the language and how it's small enough to pick up in an afternoon. More complicated topics like coroutines and upvalues might take a little longer to fully grasp, along with ffi in LuaJIT if you're going that route.

Tcl is my go-to embedded language. I tried Lua a while back but butted heads up against it's "just use a table as a list" idea (that didn't work quite right; but that was a long time ago) and became frustrated with it.

libtcl8.6.so is 1.8MiB on my desktop, and liblua5.1.so.5.1.5 is 186KiB.

Maybe there are ways to shrink libtcl or cut pieces out, but that's quite a difference.

I've found that for most of my tasks the order of things is not terribly important. I suppose that if I really needed this I could add my own ordered list data type to Lua.

Most of my quick one time hack projects involve cleaning up text or gluing different text oriented command line programs together for things that are beyond my shell skills.

For that I still quite often use Perl.

Go is a good candidate too for bridging productivity benefits of Python with performance benefits 'C# / Java / Rust'.

Indeed it is a bold statement, but if one can't make overly grand claims on the Internet then where? :-)

I'm interested to know to where you find the simplicity in Python. My guess:

- the ecosystem

- portions of Python that date back over a decade + perhaps some of the modern string handling and maybe data classes

My overall point is that the Python community relentlessly beats the drum on simplicity, but modern Python is not a simple language for any reasonable definition. I believe they have increased the complexity of the language while claiming that these complexity-increasing changes are in service of simplicity. I further believe that mountains of this complexity could be avoided with better language design and a better implementation.

If Python isn't simple, which of the dominantly used programming languages is?

Simpler than Python? Definitely Go. Probably Java and JavaScript. Maybe even C, although the whole "undefined behaviour" thing is a different kind of complexity.

I'd consider the complexity of Python comparable to that of C# and Swift - it's a similar "kitchen sink" language.

C++, of course, is in a league of its own.

In what world java is easier than python?

Doing an ssl connection in java is a daunting task

Not easier, simpler. There are many things that are very easy to do in python, but the language itself is far from simple. However you only need to know maybe 20% of python to start being productive.

That being said, I'm not convinced Java is actually simpler.

Java and C are neither simpler nor easier than Python where the rubber meets the road: making the computer do something you want it to do. Not even close. Java requires a fair amount of arcana just to get started (relative to python) and C is a simple language which pushes all the complexity onto the programmer. Java, like python, has some really deep rabbit holes when you dig into internals, and C has so much complexity in the necessary tooling.

I think Go is possibly simpler than Python. The syntax is smaller, no method overriding, and does not really have internals to the same depth as a VM language.

I can hold the entire Lua spec in my tiny mind all at once, simplicity-induced quirks and all.

Matlab is pretty simple. I've taught it to kids with no programming experience in the morning, and they were productive with it by the end of the day.

But if your code has a shelf life of 6 month, then your code is probably not read and changed as many times, as code, which goes into production settings and might be there for the next couple of years. So actually many things do not matter as much for such throwaway code.

Or performance! There's lots of low-hanging fruit in the Python interpreter that doesn't get improved to preserve the purity of the runtime, or whatever. (Well, at least this might see improvements now. But for a long time people would point at it and laugh.)

Or to enable the kind of extreme dynamism that is illustrated in TFA. How to optimize code properly when even core relationships like "x is of type T" may be nondeterministic.

As someone that follows Python since the 1.6 days and occasionally uses it for scripting, the language is simple only on the surface level, it provides the same magic capabilities of languages like C++, but apparently not many people find their way into the runes tablets.

Reply on news.ycombinator.com