After so long I have finally finished the chapter 4 of Rust and will be moving onto chapter 5, I can't wait to continue my journey, here's some of the notes I have made of what I have learnt so far!
- The heap is not bound to mutable data only and the oppsitie is also not true for the stack, but instead the heap can live outside of a function's scope and the data initilised within the function within a stack cannot and therefore will be free'd after exiting that functions scope.
- Every variable in rust has one owneer at a time, when that owner goes out of scope, its value is dropped.
- Ownership can be transferred through moves via assignments and function calls
- Using methods with the syntax '.method()' automatically dereference/reference the variable they are preforming on
- The borrow checker won't allow data to be that is currently being referenced to also be mutated while the reference is still live.
- When referencing an immutable place, the referenced place is still readable. When referencing a mutable place, the referenced place is temporarily unusable until the reference is no longer live.
chapter 4
still pushing through
I thought it wouldn't take this long but I have just gotten through the first half of chapter 4, I will admit the concepts in this book are very dense, majority of yesterday and today were spent trying to pick this apart, I am so shocked at how well the book is written though despite it's dense information. Stay tuned, will complete chapter 4 first thing tmr!
chapter 3 exercises
progress...
Currently completed fibonacci sequence and temperature conversions, starting the last one which requires me to make a twelve days of xmas song in rust using the loops in rust to automate it, it won't be using sleep or any other function but it'll just get me more used to the way loops work, anyway stay posted for more.
posting late
finished common programming concepts (chapter 3)
Finished this yesterday, will start working on the projects for it today and planning to finish chapter 4 by tmr morning, holding my accountability here should be good. As for what I learned it wasn't a whole lot as I already know about data types and conditional flow like if else statements as well as loops like for and while loops, they are basic programming constructs after all so what I really got out of reading it was the syntax used in it, and I will be practicing said syntax more with the chapter 3 projects. Stay tuned.
Posting this very early
Nothing new :)
Still working through the TRPL (The Rust Programming Language), I am at the point in Rust where I know the basic concepts so I haven't learned a lot from this book yet besides small things like the .parse() method returns a result type which can be handled with .expect() but these aren't any new concepts, just ways of handling problems really. Anyway, morale is still strong and I will be finished with the guessing game on chapter 2 very soon!!!
Yesterday
Rust Programming book
Yesterday I started the rust programming book, it's a pretty big book and I mainly spent my first hour just going thru the introduction, not much to say but I'll keep this blog posted on the new material that I learn.
PS, the article from the last post was this one: https://medium.com/@codingguy/14-rust-concepts-every-developer-should-master-d7609f16f937
Finished Rust concepts
More concepts I learned
Yesterday I managed to finish reading and practicing the example code on the article listed below, however I did feel like I wasn’t really able to get a full grasp of the concepts, so I will be delving more into them more as I work through the rust programming book. I will also be building a todo list app on the side, I’ll keep the progress of both up to date here. As for what I learned:
Error handling is great as it explicitly prepares rust for any given situation where something goes wrong and how to deal with it, denoted using `Result` for the output of a function. These parameters dictate the type of the output and the E is usually assigned as String as it correlates to the type of data the error will be managed with as an output.
Strong pointers, specifically `Rc` counts the number of references are being made to one memory address, allowing many different variables to own the same memory address, while bumping up its baked in counter each time, when the counter hits 0, the data gets dropped. The limitation with Rc (aka Reference Counted), is that it’s not thread safe so it’s only possible to use it on a single thread to avoid double frees from two different threads simultaneously.
First post
Rust concepts
Today I learned the rust concepts of toolchains, ownership, lifetimes, match statements, borrowing and references. To review what each of them are:
Toolchains - these are one of 3 categories, stable, beta or nightly. Stable is what most of the world works on when it comes to developing rust projects, beta is for the upcoming stable release, the releases follow a 6 week cycle, and nightly provides even more experimental features.
Ownership - this is done with variables taking ownership of another variables data, this way two variables don't have the same data, therefore making the program more memory safe at compile time by avoiding things like doubles frees.
Lifetimes - this one took me some time to understand but in short, lifetimes are usually automatically applied by the compiler. Sometimes however, they need to be explicitly mentioned (using 'a) and this allows the compiler to end the lifetime of the variable it's applied to when its no longer needed. This is useful for functions using referenced input variables as output variables that can also result in different outputs depending on run time conditions, therefore the program needs to know how long the variable is supposed to live for once it leaves the functions scope.
Match statements - these are similar to switch statements and don't require the break statement to terminate the match. They run like if else statements by checking if the given input matches any of the conditions and if so, can provide a concise result.
Borrowing and Referencing - this describes when a variable points to another variables address in memory, the borrower is the pointer (syntax for a pointer has an & before its name) and the reference is the pointed variable (a.k.a. the original variable that holds the data). This however must not be confused with ownership as the borrowing variable can only live for as long as what its referencing and no longer, on top of that the referenced variable is still valid, unlike ownership.