Here are some resources that help you to get into the language!
🧵⬇️
1️⃣ "The Book"
This is the official Rust book. It covers everything the language has to offer and introduces feature after feature while enabling especially newbies to follow along from the simpler to the more difficult topics.
This project gives you small exercises that aim at getting you comfortable writing Rust code. Especially if you don't feel creative enough to think of a new project, this is a great way of still writing code.
What you get here are examples of how certain concepts Rust introduces can be used. There is even an inline code editor where you can play around and let your code run.
Not a tutorial, but the (nearly) full reference to the language. There will come a time where this comes in handier than only searching within the previously listed resources.
The most-loved language, according to StackOverflow's yearly developer survey that not enough people seem to use professionally.
🧵⏬
1️⃣ What Is Rust?
Rust is a systems programming language that is compiled to binary. It has no runtime and instead uses a concept called "borrow checking". Developers don't need to explicitly free memory, the compiler does it for them.
The language itself is multi-paradigm, offering functional, generic, imperative, structured, and concurrent programming with a huge emphasis on performance, memory safety, and developer productivity.
What are NFTs? Everyone seems to be talking about them but what are they, and how can you use them?
Interested? Then this thread is for you!
🧵🔽
1️⃣ What Is An NFT?
Non-fungible tokens (NFTs) are digital assets. Just imagine a trading card where each card has unique information engraved into it. No two NFTs are the same and they are thus not interchangeable.
Other than crypto where one BTC is one and two BTC are two BTC, two NFTs are one NFT and one NFT. Only because you have two NFTs of the same type simply doesn't enable you to sum them up together.
Let's talk about how you can optimize your LinkedIn profile by using keywords.
This approach worked pretty well for me, and it might help you, too.
🧵🔽
1️⃣ Most Recruiters Search For Keywords
LinkedIn offers recruiters the chance to look for profiles of users by using keywords. If you ever had to search in Atlassian Jira, you know how that works approx.
If not, basically imagine it like this:
A recruiter can type in keywords and then use boolean logic, like ("engineer" OR "developer" OR "dev") AND "javascript" AND ("react" OR "vue").
LinkedIn will process this and then return a list of potential profiles for them.
Imagine every device manufacturer created their own plug that only they were allowed to manufacture. You'd need at least one cable for each device to charge. Gladly we have USB as a standard.
The Dependency Inversion Principle solves this issue for software.
🧵🔽
1️⃣ What does it state?
Modules that encapsulate high-level policy should not depend upon modules that implement details. Rather, both kinds of modules should depend upon abstractions.
This may sound a little complicated, but you can break it up, as follows:
1. High-level modules should not depend on low-level modules. Both should depend on abstractions (e.g., interfaces).
Code Reviews are a great way to use the experience and knowledge of a team to create good software. Not all review processes are enjoyable, though.
Here are 6 tips to make your review process better and more enjoyable for everyone!
🧵🔽
1️⃣ Make Expectations Clear
A good review process should both be standardized and individual. The terms of the process should be written down and transparent for everyone on the team. Each team member should know what is expected of them and all team members should agree ...
... on the terms. Changing the terms should always be a democratic process within the team. If the team disagrees on changes or terms, it should discuss the issues until there is consent.
On the other hand, the process should be flexible enough to allow for individuality.