Hacker News new | past | comments | ask | show | jobs | submit login

> 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!


After reading what the author wrote, including gems such as

> Too many other weirdo bits of magic syntax, like [list comprehensions].

I sadly have to agree with you.


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


Which is just further elaboration on the syntax being excessively special cased.


Oh, agreed. Just wanted to point out that I think the transition from "()" to "a," is the underlying problem, not from "(a)" to "(a,)"


I think there exists a lot of space between being “not a great programming language” and “not being super clean” though.


For the single element tuple case - what else would you suggest? You can always do Tuple(3) instead of (3,) if you'd like.


Could use something other than parens for bracketing tuples, so you don't have the conflict with the order-of-operations use of parens.


Such as?

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.


How about how condescending of a programmer not knowing JS causes you to be :-)

Either way, if the number of idiosyncracies in your language is confusing to junior developers it's absolutely something worth considering.


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.


>Either way, if the number of idiosyncracies in your language is confusing to junior developers it's absolutely something worth considering.

Why? Aiming for the lowest common denominators and the simplest systems tends to not create scalable long term solutions.

You also seem to really undercount what a properly trained junior developer is capable of understanding.


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.


I don't think Python has any issues with popularity.


JavaScript is full of idiosyncrasies.


What drives me nuts about doing JS is that the browser execution model seems vague.

In python, I can have the

if __name__=='__main__': main()

at the end if a script, and easily import the script's functions into

- pytest for testing

- some other module for larger modules

- into a cli.py file to slap a Click interface on it.

What a great blend of flexibility while retaining coherence.




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: