Comment by radicalbyte | Hacker News Reader

Comment by radicalbyte | Hacker News Reader

Parent Full thread

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.

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.

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.

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'.

Reply on news.ycombinator.com