Overall I agree with what the author says, though I have a few further thoughts:
One might argue that writing types are time consuming, and the bugs are not an issue when programmer can cover those cases with automated tests.
These two arguments contradict each other and together are an argument for static typing, not against. Which just shows how weak these arguments are.
but a more powerful type of inference that can actually infer the whole type of a function by analyzing the body of the function.
This bit I am not convinced by. Inferring the API of a function from its body makes it harder to see breaking changes when you refactor the body. It can be useful for internal private helpers, but IMO public APIs should be explicit about their signature.
Functional Programming
I would go one step further here. It should support OOP and procedural paradigms as well. No single programming paradigm is best suited to all problems. Sometimes a mixed approach is best. Any language that heavily leans oneway at the expense of the others limits itself to the problems it can best solve. I do admit the far too many languages lean too much towards OOP at the expense of functional style.
So it is easy to push for a functional style over OOP in new languages. But I would be weary of purely functional language as well.
I don’t understand how types could be time consuming.
It can be nice not to have to worry about types when you are doing exploratory programming. For example, I once started by writing a function that did a computation and then returned another function constructed from the result of that computation, and then realized that I’d actually like to attach some metadata to that function. In Python, that is super-easy: you just add a new attribute to the object and you’re done. At some point I wanted to tag it with an attribute that was itself a function, and that was easy as well. Eventually I got to the point where I was tagging it with a zillion functions and realized that I was being silly and replaced it with a proper class with methods. If I’d known in advance that this is where I was going to end up then I would have started with the class, but it was only after messing around that I got a solid notion of what the shape of the thing I was constructing should be, and it helped that I was able to mess around with things in arbitrary ways until I figured out what I really wanted without the language getting in my way at intermediate points.
Just to be clear, I am not saying that this is the only or best way to program, just that there are situations where having this level of flexibility available in the language can be incredibly freeing.
And don’t get me wrong, I also love types for two reasons. First, because they let you create a machine-checked specification of what your code is doing, and the more powerful the type system, the better you can do at capturing important invariants in the types. Second, because powerful type systems enable their own kind of exploratory programming where instead of experimenting with code until it does what you want you instead experiment with the types until they express how you want your program to behave, after which writing the implementation is often very straightforward because it is so heavily constrained by the types (and the compiler will tell you when you screwed up).
Some things are very easy to do in loosly typed languages - just as letting a function take a string or int, and then parsing that string into an int if a string was passed in. In a loosly typed language you can just call something like
if typeof(input)but in a strongly typed language you often need a lot more boiler plate and extra wrapper types to say the function can only take an int or string - for instance in rust you might need to wrap them in a enum first or some how create a trait and implement that for each types.This is quite a bit of extra upfront cost some of the time that really rubs people that are used to loosly typed languages the wrong way. So they think it is slow to work with types. But what they never seem to count is the countless hours you save knowing that when you read a value from something and pass it to a function that wants only an int, that the value is an int and you dont end up getting
2 + "2" = "22"and other suprising bugs in your program. Which results in less time debugging and writing tests for weird cases the compiler does not allow.But all that extra time if often not counted as that is dissociated from the original problem at hand. And they are already used to this cost - people often notice a new cost, but don’t notice a possibly bigger saving else where.
Typescript. Runs everywhere. Very active community. It’s the modern day Java.
I don’t know I really hate when jumping to definitions in libraries, I often just land in the “typings” file. I also think that the type-system is often incoherent, has some weird side-effects and often leads to overengineering your typings… I just generally avoid Javascript based languages (which unfortunately is not really possible in frontend…)
With regards to immutability and pure functions, I don’t really care where the language falls on the scale the author defined so long as there is a way to easily express deeply immutable objects and pure functions. There are a ton of benefits of those two things and a lot of optimizations and assumptions that can be made with them. So I don’t really care if everything is immutable by default but just being able to tell the compiler/runtime “Hey listen, this thing won’t change ever, got it? So go crazy with passing it to threads and stuff” or “This function will 100% definitely return the same value if given the same input so if it takes a long time you can cache the result if you’re able to.” both seem very appealing.
Hey listen, this thing won’t change ever, got it? So go crazy with passing it to threads and stuff
I don’t really care about that - none of the code I write is compute bound anyway. The CPU is generally twiddling it’s thumbs idle for millions of cycles with occasional brief moments of activity when the SSD finally responds to the read operation that was requested an eternity ago. Or worse, it might be waiting on a network request.
I want immutability so I can, for example, make a copy of it and know my copy will always be the same as the original. In other words I want to be able to do my own caching/etc (possibly to avoid SSD access).
my opinion is a good language needs these qualities. Portable, Safe, Fast, Easy.
which seems to be similar to the author of the article. the language I have found to match the criteria the most is the D programming Language, its so mediocre in every area.
3 separate compilers, gcc llvm and mars backends. can be as safe as you want it to be, with constructs for purity, GC, and contracts built in. can be as fast as you want it to be it is a systems language and gives you all the necessary tools to go down to C level or below with a good in line assembly, but generally the idiomatic code is fast enough you dont need to go to the C level.
it is also very easy, you have a lot of C libraries and D libraries you can use and with a built in C compiler (currently beta) you can import C libraries easier, it also has a similar syntax to C so its very easy to rewrite C code in D, it has an optional GC so if you are going for max performance you can beta test algorithms quickly using the GC and when you are ready for max performance you can do it all manually, or you can use the feature to test what is using the GC so you can avoid the GC in loops, I did this in a game recently, I used the GC to setup all memory at the beginning and turned off the GC so I would never use it in a loop,
another nice feature is functional features that make the language cleaner to write. I dont think this approach of being perfectly mediocre is necessarily the best but at least on paper its very good, and in practice there have been companies (specifically Weka Digital) that swear by the approach, they can use one language for both testing out ideas and the final product. but again in a lot of cases you dont want a language that is good at everything you want one that is good for your use case.
also the article was very interesting, language design fascinates me and the article was a good read really enjoyed it. currently planning on learning Haskell and Zig soon should be fun to compare these once I am comfortable with them.
I so wish that D would have taken off :/
I used it at the time of the library split (there was a split in the community regarding the standard library, where Tango was the alternative). The compile time features of D were fantastic and they are still unmatched; as an example: For OpenGL (back then OpenGL 2.x) I could define the vertex attributes and had them checked at compile time when I started to fill the data with glMap! D templates and compile time code generation are on a whole new level, although it made tooling more difficult. If you know constexpr in C++, then this is nothing compared to what D has to offer.
yeah it has a really good blend of features, I think that it could have saved quite a few large companies a lot of money, as well, like facebook who keep re programming stuff, with D they could have used the same language and they would have very rarely re programmed anything, and when they did they would have been able to re use some code. so I am quite surprised it didnt catch on, but it did have a few problems, one being it got relatively popular too quick before it could mature. GC problems, and being too experimental, a very good language is hidden behind a lot of features.
Python is basically (IMO) C/C++ made easy.
Billions of libraries, works on even obscure hardware, simple syntax, no compiling(it’s behinde the scene and just like always works) or linking etc. etc. etc.
Edit: this implies that C/C++ is the best language ever of course. Let the flame wars begin!
I very much disagree. In Python almost everything is abstracted away from you and it’s dynamically and weakly typed. It’s also interpreted.
Compare that to C which is literally one step above assembly, strongly and statically typed, as well as compiled.
They’ve got completely different use cases and have almost no overlap imo.
Agree except Python is strongly typed.
In what way? Python has type hinting, but it’s purely for linting and is not enforced at runtime. Python has always had dynamic duck typing.
Hi there! Looks like you linked to a Lemmy community using an URL instead of its name, which doesn’t work well for people on different instances. Try fixing it like this: [email protected]/u/theherk) [@programming](https://programming.dev
Wow I pretty much disagree with everything you said haha. E.g. packaging/venv in python is absolute hell compared to something like cargo/crates in Rust. Try to manage a large project in python and you’ll likely revise your answer (if you actually know all the nice alternatives out there…)
In my experience managing a large project comes down to having a consistent process/standards and enough experienced engineers in that language. Remove that and every single language leads to abominations.
I agree, that having a consistent process and good engineers is definitely most important, but a language itself definitely can guide you in the right direction. I think ironically Rust and C++ are good vice versa examples (unrelated to their target area, which happens to be the same (systems programming)), C++ has zillion ways to program in, finding the right and best way is definitely no easy task and requires massive experience in all kinds of paradigms, while Rust generally promotes you to do things in one/the “right” (IMHO) way, otherwise the borrow-checker annoys you all the time.
Kotlin
