FizzyOrange @ FizzyOrange @programming.dev

Posts

1

Comments

473

Joined

2 yr. ago

Linters 100% won't. A static type checker is not a linter.

Yes because you used static type annotations. This thread was about code that doesn't use static types (or static type annotations/hints).

It's an example to demonstrate that linters cannot reliably detect variable name typos - you need static types. None of the stuff you mentioned is relevant.

The typo in your example is also undetectable by linters. I think you're missing the point.

What's awful about this example? The only thing I do is access an object member. Does your code not do that??

Yes you can use static type hinting and the static type checker (Mypy or Pyright) will catch that. Linters (Pylint) won't.

If you use VSCode, open both files and then ctrl-shift-P "Compare active file with ..."

You're welcome.

    
def foo(x):
  return x.whatevr

  

No linter is going to catch that.

...for people who refuse to use static types.

Hilarious.

This is the sort of thing you have to learn by experience, like how you can't really learn good coding taste from reading a list of rules (though some lists are helpful).

Anyway in my experience documentation is quite different in public (i.e. seen by customers) and private (inside your company). For internal stuff there's a much smaller incentive to document things because:

1. documentation tends to be inconsistent (as you discovered), so people give up looking for it. Instead they just ask other people. This actually works fairly well inside a company because you can generally easily access whoever is responsible (as long as they haven't left).
2. there aren't customers to keep happy and away from support.

I think the best thing to do is to accept that people aren't going to expect documentation internally. There's zero point writing guides to tools on your company wiki or whatever, because nobody will even try to look for it - they'll assume it doesn't exist.

Instead you should try to keep your documentation as close to the user as possible. That means, don't have a separate docs folder in your repo - put your docs as comments in the code.

Don't put deployment instructions on your wiki - add a ./deploy.sh script. It can just echo the instructions initially.

Yeah, honestly you should stick to if/else until you're really sure you want to do something more complex.

This is really terrible advice. Sometimes it's better to do that, but definitely not in the example from this article.

If anyone says you should always prefer polymorphism to switches they are a bloody idiot.

There’s no value for the higher ups in fixing it

Well there is, it's just long term value that they don't even understand.

Really you should just make fixing technical debt part of your regular job. Don't ask for permission, just do it. (Except for really big things obviously.)

For Python PyQt is the obvious choice. For Rust there isn't really a mature option yet. Egui is decent, but it's immediate mode which isn't to everyone's taste. Dioxus is pretty popular too but I haven't used it.

No idea for Java. Is Swing still the standard?

What language are your apps written in? Generally the best options are:

1. Qt (C++) or PyQt (Python wrapper if you hate yourself). Old school desktop GUI. Works extremely well though.
2. Web based, then you can pick from a gazillion frameworks, most popular is React. You generally have a Typescript based frontend and a backend in whatever language you want. The downside is you have to deal with the frontend/backend communication which can be a pain.

There's also Flutter which is pretty nice, but again you have to use Dart for the GUI so if the rest of your app is in another language you'll have some friction.

But yeah, I would say the language you want to write your "business logic" in is the biggest factor to choosing. Also if you care about exposing your app over the web.

Definitely agree with tech debt. Seems like nobody except me cares about improving things, which is surprising given this survey!

Also definitely agree about reliability of tools/systems, but again it feels like it's just me that cares about robustness - everyone else is very happy to churn out hacky Bash scripts, dynamically typed Python and regexes with abandon.

Either you're all a bunch of hypocrites or the SO survey is quite a biased sample!

I would probably recommend not trying to understand the whole field of programming initially. It's huge, you won't understand what the terms mean (e.g. OOP, functional programming, etc.) and it's not very motivational.

Instead I would pick one or two popular languages to learn and actually make something in. The no-brainers are Python and Typescript. They're hugely popular, not difficult, and let you get a lot done.

I think I would consider learning both at the same time. If not, at least don't stick with Python too long. It is immensely popular but also has a lot of brain dead design decisions. Especially a) it's reaaaally slow, you easily get a 50x speed up just by switching language, and b) the "infrastructure" around it - installing Python, adding libraries etc. is completely awful. There are attempts to fix that but they're nascent.

Above all I think a good thing to have is a realistic goal of something to make. For Typescript the obvious thing is a web site. I really like this way of making web sites - you can get started with literally 2 command - but it may be a little too much for a beginner.

For Python I would look into some kind of automation or maybe web scraping thing. It's decent at that.

Or if you have more specific project ideas you could use the most appropriate language for those, e.g. a microcontroller project you probably want to start with Arduino (C++). C++ was my first language (apart from QBasic which doesn't count). Probably not for everyone though. I was very young and had free time.

lol imagine...

The only Git GUIs that I've ever liked:

• GitX, and its many forks. Mac only though.
• Git Extensions. Terrible name, but this is actually a standalone Git GUI and is surprisingly decent. I think it started Windows only but maybe there's a Linux port now.
• VSCode's "Git Graph" extension. It's not quite as fully featured but it integrates well into VSCode and is pretty nicely designed.

I've tried almost all the others (SmartGit, Sublime Merge, GitKraken, etc.), and didn't really like how they worked.

It's sooo sloooow though.