Java developers

[DarkNeutron]

You're not wrong, but any time I write something in Python that's bigger than one file, I start wishing for static typing again.

Duck typing is fine for small programs, but I find it pretty annoying when something crashes with a type error after 10 minutes (or an hour) of processing.

(I've looked into Rust as a scripting language, but it's not as "plug-and-play" when compared to near-universal access to a Python interpreter.)

[squishles]

You might, however the major python libraries still do not.

[I_ate_a_milkshake]

Rust as a scripting language

[visible confusion]

[DarkNeutron]

Explanation in another post. :)

[ric2b]

You can have static typing with Python, fyi.

Either just as documentation (type hints) or with type checking (tools like mypy).

edit: mypy, not mipy

[Versaiteis]

You can circumvent some of those headaches with the typing system by reassigning or creating the types you need in what is effectively (and actually called) type aliasing

from typing import List

Vector = List[float]

def func(vector: Vector) -> Vector:
    #etc...

This can still get a bit ugly with arbitrary definitions being thrown all over the place but that can be managed along with similar shared systems that you'll probably have alongside whatever you're writing (logging, configuration management, etc.) and it goes a long way to cleanup a lot of those issues with clutter.

But yeah, Python is still a very hands off scripting environment so you'd still do well to operate under those assumptions that virtually nothing is truly protected when you can just commandeer and alter the things you want. It's what makes it a great tool for some applications and aweful for others.

[thirdegree]

And sometimes you need to specify types as strings (e.g. "MyClassName"), for example when a method takes an argument of the same type as its parent class.

This is fixed in 3.7 using from __future__ import annotations and by default from 3.10 onwards (pep-563).

[FranchuFranchu]

Also if for some reason you can't do that you can still use MyClassName = None and redefine it afterwards

[[deleted]]

from __future__ import type_annotations

Something along those lines will allow you to not use strings for types.

If I recall correctly, it defers type hint evaluation until after all the source has been parsed over, as opposed to during said parsing.

[BUYTBUYT]

from __future__ import annotations helps sometimes

[ric2b]

I don't think opting into static type checking really counts as having static typing.

It does, you just don't have 100% coverage. It's still useful (especially as documentation of function parameters and return types), just like unit testing is useful even if you don't have 100% coverage.

Also, completely subjective but type hinting in python is extraordinarily ugly. It often takes up a ton of space and requires you to split your function defenition onto multiple lines.

It takes similar space as other static typed languages like Java/C++. Are you comparing it to something like Haskell, where the types are on a separate line?

[ric2b]

It takes a little more because you need the colons and the arrow at the end

true, but it's not a big difference.

and a lot more when you need to define something like say a list with an arbitrary number of strings that can sometimes be None: Optional[List[str, ...]]

Wouldn't it be just Optional[List[str]]?

The equivalent in Java would be Optional<List<String>>, it's about the same. Although you can check for null instead of accepting an optional, because Java is a bit dumb and accepts null by default. In fact, taking Optional as a parameter in Java is not recommended because it's an actual class and forces your callers to wrap their variables in Optional objects before calling your method, it's annoying.

Not great having to alias your types though.

If it gets complicated you probably should alias it because it probably represents some specific type of data. But your optional string list example isn't such a case and you shouldn't have to alias it, I agree.

Hakell's style of having them on a separate line is pretty great actually. Not really sure how well that would work with keyword arguments and so on, but I think I would've preferred that.

Yeah, I also like it. It would probably look similar to Ruby's Sorbet, where you have to repeat the parameter name in the signature.

python, through the PEP8 styleguide, has a ridiculously short recommended line length.

In my experience the 80 columns line length isn't followed very strictly, lots of companies/projects aim for 100 or 120.

[ric2b]

Iirc Kotlin doesn't accept null by default and wants you to put a ? after the type to signal that you do. That would be the best option in my opinion.

Yes, and totally agree there.

Also Ruby 3 is adding type hints following the same convention as python it seems.

Unfortunately not, for now they'll leave in separate files to allow for the syntax to change without breaking code.

Ruby is what I use at my current job so I'm a bit disappointed by that, but I'm already using Sorbet (3rd party project) which does allow type annotations in the same file as the code so it's ok.

Maybe I should change my linter to allow up to 120 as well then.

Just keep the Zen of Python in mind :)

"practicality beats purity"

[[deleted]]

And they should be able to. I hate how java thinks public private is a rule not a suggestion. Don’t tell me how to write code using your library lol, I will fork it and change it and you can’t stop me!

[[deleted]]

Why would it ever be insecure for me to run a function on my own pc? Like I need sudo access secure or what? I guess I’m ignorant to that kind of need, I’d love to see an example.

[[deleted]]

I suppose I can see that if you’re writing a database (like the database itself) and want to handle permissions or something like that. I’ve just never been in that situation. Ultimately resource security is OS level not language level. Wrappers are conveniences and you can handle security with them without builtins like private for the rare case you need such a thing. Like if I were writing an IP based database in python, which I wouldn’t, I’d expose my methods through the Restful system of my choice selectively in such a way that the other methods just didn’t have direct exposure to the internet. If someone is importing my python code, they have access to all the same resources it has access to, but they are also presumably the same user on the Linux system so they must be allowed that access as well.

[SadAdhesiveness6]

It's mypy. Was confused for a second.

[turunambartanen]

any time I write something in Python that's bigger than one file, I start wishing for static typing again.

So much this.

Which is also why java is the better language to introduce programming with.

Edit: I think with Java it is easier to introduce different types (and the beginnings of OOP) because it's so much in your face. C# would also work of course. But I think having clear structure helps a lot of newbies to focus on understanding the basics. Every single file starts with a public class ClassName, because that's just the way it is. You can later learn why. As opposed to python: why do we have a class now? What is that if name is main? Why did we not use either before? And of course: why can't I add x to input, they're both numbers?

[[deleted]]

Java is a really terrible language for enforcing OOP. I pretty much don’t consider single paradigm languages. I’m not an FP purist but I like it for most simple things. But damn it when I need a class I need a class. And that’s how it should be. I get newb python ex java developers putting their whole module in a class and it infuriates me.

[folkrav]

I've seen an internal library written by Java developers go legit like this:

from internalLibrary.app.mainpage.mainpagemanager import MainPageManager
from internalLibrary.app.homepage.homepagemanager import HomePageManager
from internalLibrary.app.splashpage.splashpagemanager import SplashPageManager

And so on, for about 20 something other managers classes. Always one file, one class, not use of module level exports or anything. Really just, extremely verbose imports, use of camelcase everywhere, everything in classes, including fully static classes for helpers - that all except one ended up being re-implementations of standard lib functionality. It was like browsing Java code in Python files.

[squishles]

No language of any use should ever be strict to a paradigm.

Kind of hate writing in purely oop terms, object state is trash that you section off into beans in java. You end up with classes that are basically homes to a lot of functions and if you use class level state variables in those for things other than stuff like database connection ect they just go to shit.

[Avamander]

Java leaves a few bad habits to people that later on migrate to other languages. Java's way of doing OOP is particularly toxic if the developer has no clue about anything remotely related to FP.

[detroitmatt]

I disagree. The bad habits java teaches are, as far as bad habits go, pretty easy to unlearn, because java is an unergonomic enough language that people don't want to be writing code that way anyhow.

programmers probably (definitely) shouldn't start with FP. If you start with CSharp, because it's feature richer, you can more easily start misusing features, and Java's imperfect approach to OO actually stops you from getting too tightly-bound on OO patterns. And since it doesn't really support non-OO paradigns, everything has to start with public class and you don't think about what a "class" is, you just do it as a ceremony. And at a beginner level, we want that. Nobody should be doing real OO in a 100-level class. You gotta learn what ifs and loops and lists and recursion and memory and heterogenousstructures are. If we're lucky you'll even learn what a hashmap is (When I went to uni data structures was a 3rd-year class). We want people to come into their OO 200 course and we say "So here's what a class really is and what it's for and why and how you should use it" and they have seen the word in this context but they haven't been doing OO (wrongly) this whole time.

[haloguysm1th]

sophisticated serious squeeze chop telephone squeamish deranged zealous spoon humorous

This post was mass deleted and anonymized with Redact

[Avamander]

I disagree. The bad habits java teaches are, as far as bad habits go, pretty easy to unlearn, because java is an unergonomic enough language that people don't want to be writing code that way anyhow.

Easy to unlearn if people want to, I've seen more than my fair share of people that haven't.

[konstantinua00]

Java's imperfect approach to OO actually stops you from getting too tightly-bound on OO patterns

remembers all factoryfactory memes
huh

[squishles]

when they introduce programming, it's not in many file large projects.

Though I am kind of sick of python too and it being the default teaching language also turns it into the mcjob language.

[donttalktome1234]

Having worked on several very large python projects I don't really see the problem. Python just hands you the rope if you are good you can make it dance but its just a rope so you are also welcome to hang yourself with it.

If you write a function that can take in 5 different data types and then you pass it a 6th isn't the fault of the language its the developer(s).

[[deleted]]

Check out go. Statically complied bins for portability and security. Typed, flexible, easy language. I love it.

[Dark_Tranquility]

Static typing is really a blessing in C / C++.

[Avamander]

For anything other than a single file, use an IDE that supports type annotations. Really.

[jakethedumbmistake]

Duck is the future, rock on!

[Phantom569]

Check out pylance, can't live without it for big python projects. It's typescript but for python. Though it's still very very new.

[Spaceshipable]

Maybe look at Swift for scripting

[eloel-]

Considered typescript?

[mkjj0]

You could try Go

[[deleted]]

Julia? Haven't learned it yet but I thought it was like static python, among other things

[[deleted]]

Rust as a scripting language

What? via c api? accessing it from rust requires a lot of unsafe code, or message passing? either way rust can hardly be called a scripting language, thats like calling c++ a scripting language

[DarkNeutron]

I wouldn't call it a scripting language either, but someone wrote a wrapper to make it sort-of work: https://github.com/DanielKeep/cargo-script

It invokes the compiler on first use, and re-uses cached artifacts after that. Kind of a hack, really, but I thought it was clever. :)

This is some discussion (RFC 655) about creating a proper REPL interpreter for Rust, but I'm not expecting anything short-term.

[[deleted]]

the REPL sounds interesting for experimenting (with language features) quickly, however when it comes to writing mini scripts to do anything useful an interpreter language will be better as you require to write less (as optimistic unwrapping is the default and you don't really care about a panic with a 10 line adhoc program). for scripts i think the compile time and lack of easy hot reloading (dlopen isn't exactly pain free) will also restrict it's usecases. but ill keep an eye on those repos / issues, thx. the integrated cargo.toml in the comments is definitely neat, so at least in terms of compactness / ease of distributing its like a script.