> a big part of my frustration comes from having a JavaScript background
Yeah, I thought so when I was reading the list of "problems". In fact, many of those are features (e.g. lists & tuples being different, list comprehensions, lazy evaluation, distinction between maps/dicts and objects, ...) but the author doesn't actually understand them. I hate to sound so negative, I guess I just didn't realize how bad a programmer knowing (only/mainly) JavaScript causes you to be.
> I guess I just didn't realize how bad a programmer knowing (only/mainly) JavaScript causes you to be.
Hey now - not all of us ECMA devs are total crap, but, I guess I know a fair bit of other languages. This guy is just totally ... I have words for it but I'd rather not get the mods on me.
I struggled with an appropriate way to say this but I think he's super pretentious and just sounds frustrated with learning a new language. I mean, we've all been there but typically we don't post ignorant BS to HN/GitHub about it... Every time I jump into a new language I'm always stubbing my toes on things I find "awkward", only to learn later that there's usually a reason people design languages certain ways.
If he wants to shoot his social media reputation in the foot as a developer then so be it I guess =/
I struggle with learning new languages from time to time and there's always been a learning curve from starting out to being proficient.
But while Python itself I think provides an awesome developer experience, django seems less than awesome, and it's taken a while for me to feel proficient in Django.
Personally, I'm not a huge Django fan, but then again lots of people aren't huge Laravel/Symfony fans which is my web framework of choice if I'm building a monolith web app/API "software bus" sorta solution without roping in Java.
That all said, I do love me some Python though! I use it as a general purpose tool to get semi-complex things done that are more scripting/job oriented vs. needing the orchestration that Django brings to the table. You could say it's a "cog" for me vs. the overall machine/engine.
It's on my TODO list to get into some other Python framework libraries because I've seen lots of promising ones pop up since Django, if anyone has suggestions of what to poke my nose into I'm all ears!
There's some annoyances that have accumulated in python, like the inheritance patterns and too many underscored things. Decorators are kinda weird, too.
I think Python is pretty awesome, but to pretend that it's super clean is a bit of a stretch.
(a,) for a single-elem tuple-- avoiding colliding with (a) as a paren'd expression-- is wonky, too.
The tuple notation is one of those places where the obvious way is a distraction. A non-empty tuple doesn't need the ()s - it's the "," which makes the tuple! The following two are equivalent:
x = 1,
x = (1,)
Of course, then there's no way to express the empty tuple using commas, which is where () comes in.
Using (a,) is the belts-and-suspenders way of saying "this is a 1 element tuple".
All the brackets are currently spoken for:
[] = list
{} = set / dict
<, > = less / greater than
I suppose you could overload <, > but I'm not sure that's much better.
Honestly, the more I've learned different languages the more I've come to the conclusion that little syntax changes like this are minor, for the most part, and what really changes the power and feel of a language are the abstractions that it allows for.
<> avoids syntactic ambiguity just fine-- There won't be an identifier or constant before it. <1,2,3> <1> and <> are all plausible-looking and you don't need to guess how to do 1 element or 0 element things if you know <1,2,3>.
> Honestly, the more I've learned different languages the more I've come to the conclusion that little syntax changes like this are minor, for the most part,
Sure, it's minor. But it's one of the few things I tripped over learning python and had to google repeatedly to get to stick in my head.
The fact that python has relatively few cases of weirdness like this-- compared to say, perl-- is a big part of what makes python nice.
Complaining about things you don't understand is pretty bad practice. The parent poster was pointing that out. Sure, the Javascript dig is unnecessary, but the language currently holds a position as the spot of first language many junior engineers employ.
Most popular programming languages got popular by aiming for the LCD in some capacity, e.g. Java. It's the reason why we're not all writing LISP or Haskell.
I don't think that's the main reason why and is probably a small factor at best.
Java rode a couple of different trends at the same time: it provided a somewhat smooth upgrade path from C++, cross-platform compatibility, and an astronomical marketing budget.
Many languages in the top-10 that we believe are popular or mainstream got there by having one of platform lock-in, smooth upgrade from a prior language, or a killer, exclusive app. It's a lot less about what is good or objectively better and more about being in the right place at the right time.
I've heard some claim that Python got there by being slow and steady. At one point I think I would have agreed but it does have a killer app and that's in the analysis, scientific and machine learning communities.
Yeah, I thought so when I was reading the list of "problems". In fact, many of those are features (e.g. lists & tuples being different, list comprehensions, lazy evaluation, distinction between maps/dicts and objects, ...) but the author doesn't actually understand them. I hate to sound so negative, I guess I just didn't realize how bad a programmer knowing (only/mainly) JavaScript causes you to be.