Hi, I'm a little new here

Hi, I hope you are well and having a good day

I'm not entirely sure if this is a good place to bring this up.

I'll get straight to the point. My knowledge of programming languages is almost non-existent. But I still need to start somewhere...

And while researching programming languages, Rust caught my attention.

Now my question is how can someone who knows nothing about Rust (or even programming languages) learn this language? What are your recommendations?

Thank you in advance, be safe...

1 Like

I would start by searching for existing material online that might help you on your journey:

1 Like

I personally do not think Rust would be the best choice as the first language.
I had experience with some other languages before migrating to Rust; though when I started programming, Rust did not even exist!

Anyway, the interactive version of the Rust Programming Language book is a nice place to start.


You need to start at the basics, learn slowly, and practice a lot. Nothing is better learning material than figuring out things yourself.

First, if you are just getting started with programming, you should look for a beginner's programming tutorial.

Do note that you will need to learn about a lot more topics and fields than just "progamming". Hammering out code is only a part of what a "programmer" does. For example, most non-programmers are not familiar with how the hardware works and how to use a command-line interface. So you should aim at being comfortable with the following concepts at a minimum:

  • The brief history of computer evolution, a solid understanding of digital logic, and how modern hardware works at a very fundamental, conceptual level. E.g., binary logic and Boolean algebra, what logic gates are, what a CPU is, how memory is built and how it is addressed, what an operating system is for.
  • What kind of programming languages there are, and where your choice of language (in this case, Rust) belongs in the vast family of programming languages. Given that Rust is a compiled language, you'll need to have a basic understanding of the role of the compiler.
  • How programming tools can be used in your preferred operating system. On most Unix-like systems (which are highly recommended over Windows when getting started due to historical reasons), you will have to familiarize yourself with the command-line environment. You'll need to choose a good code editor. (IDEs are not recommended for beginners, because they hide important details and introduce annoying, unnecessary ones.)
  • And then you can move on to the actual "learning to program" part, the first of which is acquiring a basic skill of creating algorithms and using standard data structures. At first, the point is not learning a particular language, it is instead understanding what "computation" is and how algorithmic tools available in basically all languages can be used. For example, you need to understand variables, values and types; loops, branching, and control flow in general; functions and recursion; arrays, linked data structures (lists, trees), and hash tables.
  • Then, once you know the basics, you can progress to learning the advanced features of the language, with special attention to what problems they solve.
  • Once you have written a large enough amount of code and used the language for long enough (read: years), you will begin to acquire a general feeling for architecture. I.e., how software components work together at the high level, and what general patterns there are for solving the most common big-picture problems.

One more thing: contrary to popular belief, Rust is not a bad first language, and it's not "hard". What is hard is to adjust one's way of thinking in the specific way required for programming altogether. This includes being more precise, exhaustive, and attentive as compared to performing everyday tasks.

Many programming languages hide several important details (e.g., memory management, multi-threading, indirection, "exceptions"/errors related to external factors, and the list goes on), ignorance of which will cause problems later (e.g. runtime errors or hard-to-find bugs), but this makes them look like they are "easier" to write, in exchange for being harder to debug later.

In contrast, Rust makes the very deliberate decision of having the programmer think upfront about potential problems, and be explicit about whether/when/how to handle them. This can make it look like Rust is "harder" to write, in exchange for causing a lot less headache later.


I think that this touches on an absolutely crucial point, especially in the context of someone who is new to programming altogether. One way of putting it might be:

Programming in Rust is very hard in the short term, and easy in the long term.

This is because Rust insists on you dealing (right now, up front) with a plethora of details which would come back to bite you (sometimes much) later on, but are not obviously relevant to your short-term goals.

When learning new things, lack of progress and lots of short-term frustration can lead to the learner giving up. Unfortunately, trying to learn programming by learning Rust does increase the probability that you will give up before you reach the point where Rust starts paying back handsomely on your investment in learning it. Put another way, Rust comes with a greater risk of debilitating cognitive overload early on; with other languages that risk is omnipresent later on.

This is not to say that Rust is a bad first language! Whether it is good or bad, very much depends on the individual learner, the time available, the level of motivation and much more.

Rust might be a great first language for some, and an awful one for others. It might be a bad first language for someone today, but perhaps a much better one (because of changes in the person's circumstances, rather than the evolution of Rust) for the very same person a couple of years down the line, or vice-versa!


I have used other languages but they for the most part are less convenient to use compared to Rust as Rust has got some unique features that makes it worth while compared to any other language. One reason why I only use Rust.

My personal suggestion would be to start using YouTube, one great video series is Dcode, he does a good job explaining though it is only for some stuff if you need a quick reference.

Learning a bit from the Rust book can help.

And then practice a bit, make your own dummy code so you get the concepts.

And when you have learn't the basics of Rust, I would suggest you start working on an actual project, something small at first, and you can always consult back with YouTube, chatgpt, rust book, discord, rust form etc. And then you learn as you go through.

That's the best way how I started to learn Rust and even now I still don't know every single thing of Rust.

My advice is to learn Python. This will introduce you to all kinds of good things, such as variables, data structures and control structures. It is also a very important skill in its own right.

Alternatives are Ruby, JavaScript or VBA.

Someone who has programmed a lot in Rust may find it easy. I doubt that anyone else will.

There's a lot to be said for Python as a high-signal-to-noise-ratio means of expressing high-level concepts in relatively simple programs. Which makes it a good vehicle for learning the basics of programming.

One thing I find is that people frequently make too strong a link between syntax and the concepts represented by it. Also, it's easy to fall into the trap of believing that the way things are naturally done in your first language, are the objectively-natural and correct way of doing things in general.

So, from a pedagogical perspective I'd be tempted to add a second, radically different language, fairly early on in the learning process, to reduce the probability of forming such delusions. Maybe one of

  • Haskell, PureScript, Elm, Nix (choice of strict vs lazy, dynamic vs static)
  • something in the Lisp family
  • Forth or PostScript
  • Prolog

Have a look at Easy Rust. It has a series of short companion YouTube videos for most chapters, if you prefer to learn with a tutor.

What I like about this book is that it teaches everything with zero prior knowledge expected. (For instance, one of the first things it introduces is the definition of comments.)


One thing I remember tripping me up a couple decades ago was why everyone kept calling text "strings".

1 Like

I wrote this for this question: How to learn Rust


Good old English!

Writing text to the screen is called "printing". Writing text to paper is also called "printing". print!() definitely doesn't write anything to paper [1].

  1. Not without some help from the OS, anyway. Redirecting stdout to the print spooler, for instance. ↩︎

I don't understand what you are trying to say. How does this relate to text in programming beeing called strings?

It did when C was created though! (Thankfully before my time)

It's tangential. The word "string" has multiple meanings. One definition is a line of text, another is a piece of rope or thread. I used "print" as a metaphor.

1 Like

Python is weird though, for example arrays can have mixed datatypes, and if you did 5/2 normally in any normal langauge it would return a full integer but with python it would return a floating point value, I mean its just confusing.

In some cases it would just confuse users if they want to move onto another language such as Java, its better if they started with any other language which is C-like in terms of syntax.

Hmm... one definition of "string" is "a series of related things or events". So string is perfectly fine for a bunch of characters that form some text. Text is a string of characters.

Of course that means an array of anything could also be called a "string", but never mind.

As for "print" going back in time it had meanings like "to mark by pressure, stamp; to impress on the mind or memory,". So no need for ink or paper, the idea is press the string into your mind.

1 Like

It used to be "a string of characters", in contrast to "a string of bytes", presumably etc., so "string" was what we now would use "array", and you could get the meaning from context quite easily. But the "of characters" was eventually dropped and now it's hard to get the connection that there's a sequence of characters in text, especially given that "string" in the sequence sense is essentially never used without the "of _" phrase in English.

But we are well off track now!

1 Like

All languages are 'weird', different to what you are used to. After all, if they weren't much different, they would be the same language.

Still, people aren't disagreeing with my main point, that a beginner is going to have enough to do with a language like Python, without needing to also tackle the extra complexities of Rust.