Rust is a very fun language to program in. At first, you might feel distressed by the brackets that encloses a lot of the lifetime parameters and the fact that you're seeing such a majestically long yet complicated code before you. You might also be put off by the sheer amount of people that told you "Rust is a very hard programming language to learn", or "The learning curve of this language is X amount of times steeper than Python". I say to those who heed these words that they are absolutely right. It's a hard language to get a hold of. You don't just get good at it after several hours of using it. Hell, even I'm still learning the way memory works in Rust through this fantastic tutorial. To better illustrate my point, let's compare my experience of the language with another lovely language. Python.

Clarity

Have you ever come across a problem in your code to the point that you would rather see the source code of the library itself rather than the documentation? Some of us have and you can ask any other person in this world the same thing and they would probably said this to a Python code, "what in the actual hell is this function returning"? I suppose you can eliminate that ambiguity with type hinting but I just don't like the way that it works. Type hinting in Python 3 is an opt-in feature rather than a must-use directive that every single function must obey. Sure, it will make Python some degrees harder to use, but in a serious application/library/frameworks, the benefit of having a well defined code adds up. At the very least you don't need to go to the debug mode to inspect what the hell a function is returning. I know you've done it, don't lie to me.

Meanwhile, Rust and other compiled language doesn't have this kinds of problem. The language itself is surrounded by very good tools that will assist you for more accessibility. For example, if you're defining a variable with the let keyword, you don't really need to specify the actual type unless you're prompted to do it. Some will scratch their heads (most probably the Java programmer), how the hell does this type safe language knows EXACTLY what's the type of a variable? Simple, the answer to that is type inference. A magical concept that to this date I still think it's something that any serious language should do.

Learning Curve

Yes, as you may have guess, Python is a very easy language to learn if you're comparing it to Rust. It has a very gentle learning curve, a lot of libraries and tools ready to use, and many-many-many free tutorials are available online. My advice to a lot of noobs that are trying to get into programming is to not use Rust or C++ as their first language. Never test the water of programming with these languages. C++ and Rust are not easy to use, complicated to use correctly, and will nag you to death whenever and wherever, in compile or running time.

Paradigm

I'm not the first person in the world that admits that there's some issues with using Object Oriented Programming (OOP) implementation in most modern languages (if you're expecting me to bash smalltalk, you're in the wrong blog because i haven't used it yet). For those who are uninitiated, one of the main ways you can structure your code is to adopt a single paradigm. Like, a way of thinking on how things should be organized. In a language that uses OOP like Python for example, you can organize your code by pretending that each combined data/logic called class is a template for a real object. The class could have a child that inherit the attributes of the parent(s). When the class is ready to be used, you can "create"/"instantiate" it and make it a real object that lives in the memory of your computer.

Let me rant a bit about OOP and their practices in the real world based on my experience and others. Most of the time, if not all, OOP is finnicky to use and get a grip of. A very on point example to one of the problem with using object oriented language like Python or Java would be the case of code duplication. In OO languages, one of the doctrine that most people will get when learning is that most of your code must be reusable. But in practice, a lot of the code that you're going to use is probably hidden deep inside of the inheritance hell and can't be refactored out of it because of the tightly coupled nature between logic and data.

There you go, the biggest issue about most of the programming language implementation of object oriented programming. Tightly coupling between logic and data. Don't believe me that this happened often? One of the easiest way to do this is to open up any modern Java IDE and search for a way to generate a get and set method for a class. This in turn made It a norm to have hidden state behind some complicated logic instead of stating it clear as a day that there's something changing1.

Rust though, they're built differently. There's a very clear separation between logic and data. If you want to store things in the memory, declare a struct. If you want to have a function based on a struct, you do it using the impl keyword. And if you need some kinds of contract between struct to improve code reusability, you can always use traits. IMO, this is one of the most easiest to learn and elegant way to solve the problem that plagues OOP. Bravo, Rust Development Team.

Conclusion

Rust is a good language for programmers that have some ability to program in other "easier" languages. The language is explicit in each for every line, complicated to read but clear to understand, and surrounded by tools made by professionals. It's basically a more centralized version (as in most of the tools, frameworks, and packages, are hosted by the language maintainer) of C++. Without the memory headache of C++.

Footnotes:

1 Yes, i'm aware that Rust also have an internal mutability using cells, effectively having a state inside of a seemingly immutable struct. But using cells is an exception to the rule instead of the norm. So yeah, I still hate OOP implementations in most languages.