1. IMO Rust has the closest thing in "imperative" languages to haskell's type system in a recently released "mainstream" language.
2. Rust brings an entirely new value (memory safety), and accordingly an entirely new hurdle called the borrow checker. This feature is so advanced that languages like Haskell are catching up (it's not a competition really) by introducing things like Linear Types[0]. That's really impressive.
3. Rust is targeting system programmers -- they move the slowest (as they should) in the ecosystem and are the most risk averse (as they should be).
4. Compare Rust to relatively recent systems-level languages (I won't name any), it's doing great.
5. Staying at the same place in the rankings is actually moving forward -- it may not seem like it, but it's hard to stay both effective, liked, and relevant in the world of programming languages (see: Dart).
I don't think rust is the kind of language to just shoot up the rankings -- it contains both higher level techniques that aren't quite mainstream yet and is targeted at a smaller community (though they're kind of going after web people with the wasm stuff).
I think rust is the kind of language that shows up to be consistently near the top of the rankings in 10 years (and I've said it numerous times but I think Go will displace Java and Rust will displace C/C++ where possible).
Yes, I will concede to a slight bias in favor of rust :).
Julia? Nim? That's about all that comes to mind.
I wish I could read the Haskell documentation, but the code examples are straight up black magic to me. I really need to dig into some proper functional programming at some point!
Just get the basics down and write some stuff. For a lot of things, you don't need to know how they work underneath in order to use them. It is helpful to implement functors, applicatives and monads for some of the basic data structures to get a feel for things, but then beyond that, just use what has been provided. Don't try to write your own monad transformers, just use the mtl library. Lenses are really complicated to understand, but really simple to use. The servant web library uses some high end type level stuff in order to work, but it is really easy to use. The compiler has your back.
If something just doesn't work and doesn't make sense, just move on and find a different way. After a while you will understand more and can return to it.
Don't try to understand the academic papers that have been written with Haskell. There is a really tradition of making the Haskell code as incomprehensible as possible. It will just get you down.
That is what I do: I use a subset of the language, don’t dive too deeply into the theoretical stuff, for anything imperative I find an example to follow, and just enjoy writing pure code in a comfortable interactive environment (VSCode or Emacs).
It is possible to just use Haskell ‘lightly’ and enjoy it. The only problem for me is that it can take me a while to understand other people’s Haskell code when I read it.
Luckily Haskells type system means that you can understand a lot about what is going on just by looking at the type definitions. Most code includes these. Although rather frustratingly, however, a lot of documentation doesn't include the type definitions. It is good to see languages such as Idris make it mandatory to include type definitions for all functions.
I still don't completely understand what is going on in the route definitions, but I have no problem with setting up a route.
Granted something like this is a gnarly type :
type UserAPI2 = "users" :> "list-all" :> Get '[JSON] [User]
:<|> "list-all" :> "users" :> Get '[JSON] [User]
But really you don't need to think of it as a type, just think of it as setting up a couple of routes. The ':<|>' is the route separator. ':>' represents a '/'. The bit after the final ':>' is what your function needs to return. If you get it wrong the compiler will complain at you.With an incomprehensible error message. Beginners will of course get it wrong.
I would rather put beginners on a path that makes them feel like the compiler is helping them, one of the core strengths of Haskell, rather than it just telling them No.
My original point was don't get bogged down in complicated stuff. If someone just doesn't get Servant, there is always Scotty, which is much more straightforward. Servant is not a reason to feel intimidated by Haskell.
Haskell definitely has a high early threshold that you need to get over. After that it's pretty much just fun and smooth sailing until you try to do something bigger, at which point there's another threshold.
The learning experience is the most fun I have had programming.
As absolutely suitable for self study I would recommend:
https://www.amazon.com/Elements-ML-Programming-ML97-2nd/dp/0...
The term "systems language" is almost certainly not precise enough. What I mean to convey was a language that you could write performance critical low level code in. In my mind though, Rust satisfies both that definition and the vaguer "backend service" (i.e. the thing spinning behind some interface doing the hard work in your architecture) -- it works very well from very low level all the way up to application programming.
If we're taking the second definition (vague backend-service-y) then Rust has lots more good competition -- if you can afford a runtime then the right language can give you some pretty good safety for less than the cost of learning Rust's borrow checker.
BTW I hear you on the haskell docs, how to start with Haskell is one of the hardest things. I personally took this path:
- http://learnyouahaskell.com (a fun read, introduction to basics, good prose)
- Writing some euler solutions (quickly stopping, they become just a mathematics fest after a while)
- http://book.realworldhaskell.org/ (excellent examples for real-world code)
- http://adit.io/posts/2013-04-17-functors,_applicatives,_and_... (when you feel like you really want to understand the big M)
- Writing the backend for a project in haskell
- Watching lots and lots of talks and attempting to read papers to just headbutt certain concepts over and over till I could somewhat begin to understand them.
I've found the secret is just to let the stuff go over your head at least 2-3 times until you start finding it useful.
But I want to stress that you don't have to write 5th order polymorphic dependently-typed whatever to get lots of value from haskell, here is some low hanging fruit:
- Haskell has the type system you thought/wish Java/C# had (i.e. `type AorB = A | B`, `newtype PositiveNumber = N { _posNum :: Int } -- guaranteed through constructor to be >= 0`). The ease with which you can have types express intent is mentally revolutionary.
- Behavior and object structure are separate, like Go's structs + interfaces or Rust's structs + Traits, and constraints (dependencies from one typeclass to another) are really easy to use -- ex. `class Thing a => BigThing a where { ... }` expresses the dependency that for a to be a `BigThing` it needs to first fulfill the requirements of being a `Thing` -- this is how you can force the existence of certain functionality on with polymorphism. Once you get used to this everything else (well, subtyping at the very least) will look primitive.
- Concurrent programming is amazing, both due to STM and the very good threading model (lightweight routines multiplexed to system threads)
- I will say that I think there's lots of low hanging fruit out there though -- Haskell has the type system you thought Java/C# would have. They really have "class" systems rather than type systems.
C++ is safer but heavier than C, and Java is safer but heavier than C++. If C/C++ are systems programming languages but Java is not, then I posit that Go is also not a systems programming language. If use in resource constrained environments (where C/C++ can happily go) isn't a huge factor, then lots of things are systems languages that I wasn't considering
Wiki says:
> System programming (or systems programming) is the activity of programming[1] computer system software. The primary distinguishing characteristic of systems programming when compared to application programming is that application programming aims to produce software which provides services to the user directly (e.g. word processor), whereas systems programming aims to produce software and software platforms which provide services to other software, are performance constrained, or both (e.g. operating systems, computational science applications, game engines, industrial automation, and software as a service applications).[1]
> System programming requires a great degree of hardware awareness. Its goal is to achieve efficient use of available resources, either because the software itself is performance critical or because even small efficiency improvements directly transform into significant monetary savings for the service provider (cloud based word processors).
Last sentence of the first paragraph seems to kind of two cases I kind of mentioned -- providing services to other software, being performance constrained, or both. Assembly/C/C++ are obviously often the only choice for the "performance constrained" use case, but not necessarily the best choice for the simple use case of "providing services to other software".
https://www.aicas.com/cms/en/JamaicaVM
https://www.ptc.com/en/products/developer-tools/perc
And a tracing GC isn't a deciding factor for being a systems programming language or not.
Besides the examples shown above,
http://www.astrobe.com/default.htm
And the now long gone Lisp Machines, Mesa/Cedar, SpinOS, Singularity, Midori,...
"Resource constrained" doesn't even mean the same thing anymore either...
it could also compete with go and python for command line tools but I think the mental overhead of the syntax makes it hard. i would rather write rust then go or python though.
Rust also feel like a very work in progress language, especially with useful features only in nightly often.
The rust community seems to be slowly but steadily working through a bunch of bigger use cases (all in the open as well, so you can see exactly what they're doing and why). For networking use cases, see projects like tokio[0] and hyper[1] to see how the community is moving (here's an awesome talk on it[2]). To me, it looks like the rust community is actually trying really hard to build things modularly and slowly from the start, taking tons of time to "measure twice cut once".
All that said, building networked systems in Rust is definitely extremely usable right now (and in many cases without nightly, I don't turn it on for any of my projects) -- maybe you won't find a gopher-server crate (rust's packaging mechanism) but for regular HTTP/HTTP2 you're going to find a lot of production-ready software (rocket[3], actix-web[4], tower-web[5]). I'd love to be pointed to some recent post where someone spelled out their issues writing some basic HTTP/HTTPS REST-ish backend servers (which I think is what the majority of people are writing/maintaining in their day jobs).
Side note (I'd love for someone to correct me), but generally when people want "performant" multithreaded network services, I take that to mean they want the combination of all system cores utilized and IO treated asynchronously -- in my mind this is basically all it takes, everything else is application/solution-space level optimization (parse your JSON a little quicker, maybe use a better data structure, do more things concurrently, etc). Rust has both of these things (system threads, libraries with async support) -- for example async/await syntax is landing soon, and from what I know the state of the art has progressed in this manner: callbacks->deferred/promises/futures->async/await -- rust is already 2/3 and async/await support is landing soon. And on top of all this -- rust is going to make parallelism & concurrency safer -- this is huge because while it might have been easy to `#include <pthread>` in C/C++, it sure isn't/wasn't easy to write correct concurrent/parallel code without the support of a runtime.
[0]: https://tokio.rs/
[1]: https://hyper.rs/
[2]: https://www.youtube.com/watch?v=4QZ0-vIIFug
[3]: https://rocket.rs/
[4]: https://actix.rs/
How are Rust SQL drivers for distributed computing with Oracle, DB2, SQL Server?
I can talk about some SQL drivers though -- I've used `postgres` (postgres), `rusqlite` (sqlite), `r2d2` (connection pooling) and others to great success building some relatively small codebases. For a more pre-baked approach `diesel` is the ORM that everyone is generally on if that's your speed.
Just in case I misinterpreted the question -- were you meaning to say that distributed computing using Oracle/DB2/SQL Server are examples of contradictions to my statement of "everything else" being "application/solution-space level optimization"?
- calling PL/SQL on an Oracle RAC cluster using distributed transactions at driver level.
- define data structures where the driver does the mapping into PL/SQL User Defined Types.
rust-oracle is listed on the shared programming interface page though (https://oracle.github.io/odpi), so maybe it's close if not already possible.
I doubt the second one more though -- how many languages even have an oracle driver with integration that tight to begin with? I struggle to find drivers that map PL/SQL user defined types to in-language types (even with something simple like enums)...
Java certainly isn't perfect today and it certainly wasn't perfect when it gained the mindshare it has now. I think it's pretty impressive that Golang has achieved anywhere-near-JVM speed with easier concurrency primitives and ease-of-use in the time it has. What standard are we holding Go to that Java would have fit at the time?
If you meant Ecosystem-wise there are very few ecosystems that can compare to Java, since it's been around so long and has been the workhorse of (I think) the majority people being paid to write code for so long. If this was the way we picked languages, no new languages would ever emerge.
People are being productive in Go, and they're using it to write lots and lots of software. It's a good tool and is already production worthy, at the very least based on the fact that it's already running in production in many places and hasn't spectacularly failed anyone yet.
somewhat related rant
Also, I think Go changed it's official logo (from the gopher) in an attempt to fit this kind of language, and I think it's stupid. Who cares if their logo is of a worm -- if it's a good piece of software, then the right people (who value good software and craftsmanship over some appearance/facade of professionalism) will use it. People pay us to write good performant software, most of the time they wouldn't care if you wrote it in Brainfuck as long as it worked and worked well (of course, there's also the fact that someone has to maintain it, but let's pretend that doesn't exist).
end rant
It needs to catch up a lot with Java 12.
Also I'm not sure missing a GUI toolkit is an indictment of a growing language these -- systems programming very often does not involve a GUI.
GUI libraries are just one of the easiest examples to come up with.
I can list many more missing features in Go land that we have been enjoying for the last 20 years in Java land to drop them just because of Google's cool factor.
I do think eventually it could replace C though -- because rust with `unsafe` blocks still has the possibility of being safer than C. This could be a boon to security critical software, as long as the performance margin isn't too hard. Shops that have found ways to write safe C will likely never move (they don't need to), but new ones might pick rust where they might have picked C otherwise.
BTW, the embedded support in rust is really impressive for such a young language: https://github.com/rust-embedded/awesome-embedded-rust
But Rust is so overwhelmingly better than C, Go, Java, and C# for things people use those for, it may have a bright future replacing them, once its libraries and tooling mature enough. It will be competing with C++ on that, but there's room for both.
I'm using https://github.com/BurntSushi/ripgrep which is rg, like ack or ag (TheSilverSearcher). I've been using it for a few months, and I like it just a little bit more than ag, because I find its help and interface a bit easier to use. Like ag, it's incredibly fast.
Just this week I started using https://github.com/watchexec/watchexec to run rsync to sync from my mac to my vagrant box, because I was switching from using neovim on vagrant to using Visual Studio Code. It works great and has a very nice command-line UI.
Another tool that's written in go that I thought maybe was written in rust that's handy is https://github.com/shenwei356/rush which runs multiple commands in parallel, like xargs. I'm using it to transfer images between folders on s3 using aws-cli.
Based on this, and Servo, which is unstoppable with its Doge logo, I think Rust is going to be a very widely used language. https://github.com/servo
Edit: I remember part of why I liked rg more than ag - I got to use cargo rather than go, which is a much more intuitive and less opinionated way of downloading libraries than using the go cli. go is coming around though: https://blog.golang.org/modules2019
C and C++ have been stable for years, and so has all the little UNIX tooling that was built using them. People are excited by Rust, and take it upon themselves to re-build these tools, as they have well defined requirements and characteristics.
The reason these tools might be better is because thought has gone in to modernising and enhancing existing features. That might not be so feasible/ easily doable if you were juggling a decades old codebase to start off with.
I'm not sure what my point is, entirely... But ripgrep is good! I have replaced awk and grep with it, because it just feels more... user friendly?
EDIT: remembered my point. Are you switching to Rust tools because they are written in rust/ benefit from Rust in some unique way, or because it's a common platform people are re-implementing and re-imagining classic UNIX tools in?
I think it's a little bit of both for me.
The Rust tools tend to have a nicer UX (pretty-printing, colouring by default, with smart detection whether output is to a terminal, subcommand-oriented CLI a la git, etc). This is probably a consequence of nice library defaults but also a matter of culture. They also tend to be very fast. Again, Rust is inherently inducive to writing fast tools, but you also have to do things the right way.
Perl? Please, Perl was SO huge that I'm surprised it's as low as it is (which makes me suspect the methodology, actually ...).
In addition, if I remember from the TIOBE index there is the "Top Ten" and "everything else" where 10-20 is basically 1%+some noise and 20-50 is like .3%+noise.
> Kotlin is doing really well for its age especially, I'm guessing mostly used by Android devs (so far).
I wish the Android ecosystem would finally pick something and just stick with it. Having tooling, samples, and documentation that don't go out of date every 6 months outweighs any mythical "advantage" that switching language, build system, etc. actually gains.
This is exactly why I didn't stick with Android for too long. Everything's too... in flux, but in a weird way.
"YAY, Google released this feature I've been dying for! Can't wait to use it in 4 years, when enough phones actually support it :)". It's either that or have API level dependent code.
Maybe Dart will fix some of these pains, by abandoning all they have built up? It is Google, so I'd say it's unlikely, but still.
Hell, I was trying to build an analog clock widget as a tribute to a certain sports team, and Google had deprecated the AnalogClock class. Its successor was, well, nothing. So a few community efforts took its place, and the fragmentation only got worse. Thanks, but no thanks!
The only good part about Kotlin getting entrenched is that JetBrains is MASSIVELY invested in not letting Google switch to something else--so we may finally get some stability for a change.
I think that's what we're seeing here but the graph isn't really making that clear. I doubt Pascal is used nearly 50% as much as java (unfortunately) for instance, it's a logarithmic scale.
For Kotlin that is Android. I am more interested to see what will happen to it if Google has one of their usual project reboots with Android.
Rust still fails short in several domains, but now with Google and Microsoft's additional love we might see some improvements there.
I now use Kotlin on Android, and it’s mostly a tidied-up Java that’s slightly better in every way. The one big difference is checked exceptions -- Kotlin doesn’t have them.
My question is, do Kotlin users prefer unchecked exceptions, or do you find yourself avoiding exceptions entirely now? Or even dropping back to Java when you need exceptions and you want compile-time checks?
I find myself mostly trying to avoid exceptions entirely in Kotlin -- maybe not such a bad thing!
I can't speak for Kotlin users en masse, but personally I don't miss checked exceptions one bit, same as I didn't miss them in C#. And I've never encountered the practice of "dropping back to Java" for checked exceptions of all the reasons.
A compelling way of emulating the presumed benefits - without the bad parts - in Kotlin would be to go sort of functional and use a Try return type from Arrow-Kt: https://arrow-kt.io/docs/arrow/core/try/
I was trying to figure out if people are happily using unchecked exceptions, or not using them at all.
I would deliberately throw exceptions as a "fail fast" safety switch, when I actually want the thing to burn down in flames. That's typically about violating some sort of a contract which indicates an implementation error - like an illegal argument. In such case to have them unhandled is sort of the point.
I found that following these principles by itself leads to a very limited role of exceptions in code.
I generally find that I avoid exceptions, but where they are necessary I try and catch at the right level to handle them.
Kotlin is doing really well for its age especially, I'm guessing mostly used by Android devs (so far).