Forem: Rust Nigeria

Rust: An odyssey of passion

bolubee101 — Sun, 04 Dec 2022 23:49:30 +0000

He just kept going. From one Rust topic to one programming concept, Akin didn’t run out of things to say. It was almost laughable that I had been worried about how the interview would go. A back story is in order. When it comes to rust stories, Akin usually handled the interviews while I put them into writing. As an experienced Engineer and the most fierce Rust Lang advocate to ever grace the surface of the earth, he knew the right questions to ask to set a conversation going on for hours. There was no one better for the job. But now, he was to be interviewed, big shoes to fill. So I asked the most important question in any tech interview - “How did you get into tech?”

“Back in the days of 2go, a Naruto-themed chat room I was a part of held a competition to see who knew the most Naruto trivia”. Rooms were more or less the Whatsapp group chat equivalent on 2go. “The competition was something I heavily participated in. However, I wanted to find out the top players in this Naruto trivia game so, I had this idea to build a website, a leaderboard of sorts on which the participants would be ranked. This Idea led me to research how to build a website. I explored drag and drop no code tools then eventually HTML, CSS and JavaScript. I remember the first time I saw Javascript being used - it was to turn a light bulb on a webpage on or off. While it was just switching between two images, one representing the light being on and the other off, it still felt like magic to me. I ended up not only creating the leaderboard, but also adding a few extra features to my project. People were able to download games and other media. I built the platform using a popular java phone at the time. I was proud of my project until I made a mistake and accidentally deleted the home page HTML code without having a backup. I didn't have version control set up, so I lost my entire project. Although I was disappointed, my passion for coding continued to thrive. I kept learning and exploring on my own, mostly for fun. I even started building a 2D game with Unity and C# with some friends at one point. Most of my learning until then had been done in isolation. But in 2018, I discovered developer communities in school and then things got a whole lot more interesting. Every chance I got, I wrote code. It was fun and exciting. I discovered Rust in… ”.

“So, how did you discover Rust?” Akin was about to answer the next question I was about to ask, So I interrupted him. That’s the problem with passionate people, they don’t need prompts.

“I discovered Rust in 2019. I can't really remember how I found out about it, but I think I was doing some research on the limits of web performance and how to push them at the time. WebAssembly was a common topic in my research, and its cool name aside, the idea of executing binary code on the web really fascinated me (and still does). Yup, that’s how I found Rust. Not only was it fast becoming the go-to language for web assembly, but it was also the most loved language in a StackOverflow survey. At this point, it’s important for me to say something about myself. I’m ultra-passionate. I run on passion. If there is something I don’t have an interest in, it would be almost impossible to see me doing that thing. But if the flames of passion ignite in my heart concerning anything, it spurs me on indefinitely. I can spend hours on whatever it is. Rust was that thing. It was beautiful. I didn’t have any prior systems programming experience, so Rust took me to a world I hadn’t been used to. Memory management, ownership rules, etc were all shiny things. When people talk about how unforgiving the compiler is with the error it throws, while I do understand, I feel like they are missing the point. The Rust compiler is like a guide in a foreign land giving you a tour of all the landmarks which pulls you back when you are about to break a law. It always feels like I’m learning something new.” At this point, I was already pulled into the conversation. Akin is like that…passionate people are like that. They live in their own world and pull unexpecting bystanders into it. This world was intriguing. “What kind of projects did you work on while learning ?” I asked.

“My first project was the game of life from “the rust book.” The second one was an attempt to implement the Huffman compression algorithm in Rust. I had just watched the Silicon Valley TV series in which their main product was a compression algorithm. That got me curious about compression algorithms, and the Huffman algorithm is the basics of the basics when learning compression. It made me learn a lot. Like box pointers. Anyway, I was curious, Rust was this new toy available for me to play with, and it was beautiful. I love Rust.”

“Rust’s popularity hasn’t always been this high. How did you stay dedicated to learning it?” I asked. I was curious. Very few people would stick to learning something that didn’t seem to offer any immediate reward.

“I created a community. Okay, not intentionally. But looking back now, that’s what happened. As you know, I didn’t write Rust at work at the time. I worked as a front-end developer, and Rust was not included among the tools we used at work. All my learning was solely for my personal gain. Learning rust impacted my outlook on software engineering, and it flowed into how I wrote my code for work, and it also flowed into my conversations. I was already involved in other communities, and I talked about Rust so much that I was becoming an annoyance. I didn’t care much though. I just wanted to talk about Rust. Then one day in March 2020, I came across an article on WebGL in Rust Web assembly. It was so well written and easy to understand. When I checked who the author was, I realized he was a Nigerian. Chinedu Francis. He was the first Nigerian I knew who wrote Rust. I stalked him quite a bit. When I say stalk, I meant I watched his talks on youtube and visited his GitHub page. I just wanted to know who this awesome developer was. Eventually, I sent him mail.”

“Wow, did he reply?” I asked.

“He did. Chinedu was really cool. We exchanged a couple of emails for a while till one day he organized a call. It even became a bit frequent. He would talk about what he was working on and I would try to make sense of it. The funny thing I could see was that he knew I didn’t understand all he was saying, so he would explain things very high level using terms and words I could easily grasp. It was so much fun seeing him talk about his work. Seeing someone even more passionate than me was awesome. I was mind blown by his knowledge. Now to the community creation part of my story. On a group chat, during one of my Rust episodes, someone mentioned that they had a friend that had built some cool projects in Rust. I hounded the guy, and he sent me his friend’s number, Miraculous’ number. I messaged Miraculous one day, and we talked for hours. It was beautiful. A while later, another friend of mine introduced me to a friend of his that contributed to Deno lint, Eze. I was ecstatic to be able to talk to more than two people about Rust. I wanted to share this joy, so I created a group chat called Rustaceans for the three of us. We would discuss Rust for hours. It was a haven. Then we began to grow. Miraculous would add someone who wrote or was interested in writing Rust, and Eze too would add someone too. One of the reasons I wanted the group was to have people with whom I could discuss the troubles of learning Rust in the current developer landscape in a country like Nigeria. Software development was very lucrative. But Rust jobs weren’t as much. So it was hard justifying learning a language that didn’t seem to have financial perks. So I needed people with like minds to help encourage each other.”

“All this was online, right?”

“Yes. With the pandemic in place, that was the only option. But that changed in 2021. We met for the first time. And guess what? Chinedu was around. It was our first “meetup”. We booked a hall for our event, an event without a schedule. But it was the most beautiful event I’ve ever been to. We sat there and just talked endlessly - what we love about it, what we are building with it, etc. Then, I didn’t write as much Rust as most Rust developers due to the fact that I’m a front-end developer, but I was happy with Rust being the plaything I write to escape the stress of work. It hurts when you get errors, but it’s fun to write and meeting more people who write it is breathtaking. Everyone was ecstatic. Meeting other people that were equally as passionate was beautiful. I treat the Rust community as more than just a community. I care about it. Just seeing Rust developers Interact was a sight to behold. After the event, I created a Twitter account and that’s how the Rust Nigeria community was born I guess. It’s been fun. We even have a newsletter. One thing that has been consistent in the group is passion. When we were 3, it was there, now we are over 200 and it’s still there, growing. On a side note, in the early days of the chat room, I would often have one-on-one conversations with people before they joined. This wasn't a requirement for joining, but rather a way for me to learn more about them and their passion for Rust. I quickly realized that Rust developers are incredibly passionate about their work, and if you sit down and talk to them about a project they're working on, you could be there for hours listening to their stories. This is why I love the Rust Stories idea - a way to share the passion and excitement of Rust developers with the world.”

“As a frontend developer, how does Rust fit into the list of tools you use?”

“Rust was originally designed as a systems programming language, similar to C/C++. However, it can also be used for front-end development. One way I have used Rust on the front-end is through WebAssembly. I previously worked on a project that involved building a fluid simulation in the browser. This involved implementing physics and mathematical equations. However, in order to create a visually coherent simulation, many iterations with different values needed to be performed. I initially implemented the simulation in JavaScript, and it worked well. However, I decided to try implementing it in Rust to see how it would compare in terms of performance. The difference was significant - the Rust version was able to perform more iterations in a fraction of the time it took the JavaScript version. Here's a link to the fluid simulation I built using Percy, a framework created by Chinedu that enables the use of Webassembly and Rust for building frontend applications. Chinedu's contribution to my Rust journey has been unquantifiable. I currently have the privilege of working with him.”

“I see, in the near future, what do you see yourself doing with Rust, and what would you like for the Rust Nigeria community?”

“In the near future, I see myself continuing to use Rust for a variety of projects and tasks. I am particularly interested in exploring its potential for building high-performance web applications. Working with Chinedu would afford me that. As for the Rust Nigeria community, It’s going to keep growing and thriving, fueled by the passion and dedication of its members.”

This story is based on Akin's experience with Rust.

Rust's Defender

bolubee101 — Fri, 05 Aug 2022 11:55:40 +0000

I was first exposed to computer programming in 2015. But please, try not to attach my programming experience to that time. It was through a movie, an Indian movie, I can’t seem to ever remember its title. One of the characters - the bad guy actually - caught my attention. He was a lot of things: a traitor, genius, good looker, and hacker…a hacker. The amount of power he had was ridiculous. With just his laptop, he was able to turn the tide of the entire operation in his favour. There was one problem though, I didn’t have a laptop. Sometimes I used my dad’s laptop but not frequently. My saving grace was “Xeus hack”, a mobile application I installed on my phone. It came with lots of articles - bash programming, zip bombs, etc. My “Hacker career” went along fine till I got to a certain chapter. A line read, “what differentiates a “script kiddie” from an actual hacker was programming experience”. I had no programming experience. Lucky for me, at the end of the article, there was a list of programming languages, and at the bottom of the list were Python and Ruby. I randomly chose Python. I still didn’t have a laptop at that time, so I used a mobile application, “Q python”, to write my python scripts. The moment I wrote and ran my first line of python was the last time I thought about hacking. A world of possibility opened up to me.

At first, I didn’t know anyone else into programming when I was in school so I learnt to keep myself motivated. Eventually, I met other people. In 2018, I got my PC, started learning web dev, hated javascript, and learnt Django. 2018 would be what I term the start of my programming journey. 2019 specifically was a turning point for me. I wanted to build my first web project, so I immersed myself in learning. I like hands-on learning and I guess the challenge at hand spurs me on… see what I did there? One more - and idle hand is the devil’s workshop. Around this time, I met this guy at school, the University of Abuja - Segun. He kept going on about typescript and Go. As the reasonable man I was, I decided not to learn Go. For some reason, his enthusiasm built an internal resistance in me towards the tools. I am not proud of the man I was. Anyway, I googled ‘alternative to Go’. There were a couple of results but one stood out, “The most loved programming language”. At that point, I knew I was going to write Rust. It was even more loved than Go. I found Rust's syntax appealing, it drew me in. I even thought it had a similar syntax to python…I was young and naive. The tears came, eventually. In 2020 I had already gotten a bit used to Rust, but my learning was on and off. My love for it remained. I championed it in every group I was in and tried to answer as many questions as possible. I even managed to push Rust in once or twice into this weekly meeting I used to host. In 2021, Rust seemed to have grown in popularity and people seemed more susceptible to my prompts for them to learn Rust. There’s this javascript group I was on where I became popular because of my shouts for Rust though I didn’t know much about it. Lucky for me, there were a couple of people with more Rust experience than I. Appcypherwas one of them. So they were there to help when prompts came and it was about that time I found out about Rust Nigeria.

In all my evangelism, a major question that people seemed to ask was ‘can you make money with Rust?’ People didn’t find it prospective. ‘You haven’t made any money in Rust’ and I sort of agreed…well not entirely. I had written an article on rust, a paid article. I kept trying to get them to understand that if you write code solely for making money, you might not be able to like rust or a couple of other languages and tools. Its learning curve is steep but the fact remains that Rust gave so much power. Who wouldn’t want that? At the end of 2021, people started writing year-in-review. I noticed a trend - ‘...I plan to learn Rust next year.’ This year, 2022, Rust's popularity exploded. It caught on. Its job availability went up and the antagonising about it went down. In fact, if anyone ever spoke against it in groups I was in, I didn’t have to defend it. There were others who would do that. Backend, Frontend, everyone started learning it.

So far, I’ve been reading the book “Zero to Production”, and I’ve had lots of fun working on the projects in it. I’ve also collaborated with other Rust developers on projects like Lazer Pay’s Rust SDK. I worked with Enochwho I met on the Rust Nigeria group chat. In fact, if the Rust Nigeria community hadn’t been created, I probably would have created it myself. A personal favourite of mine is the Thanos Project - a program that randomly deletes exactly half the number of files in a folder and I still have a couple of features I intend to add soon. That project taught me how to work with Rust’s documentation and I developed the notion, one I still hold, that all documentation should be like Rust’s. Another thing about Rust that makes me an unrepentant champion is the Rust philosophy, the philosophy that went into its design. The philosophy of “no breaking changes”, the compiler design, Just genius. I am not saying somewhere along the line we could not find something wrong, but, right now, it’s the closest thing to perfection in my opinion.

My goal for Rust in the future is to write more Rust. To slip it into as many projects as possible that I can, to give talks on it, and more. Like a donkey baited with a carrot, the fun of battling my way through tons of red lines and compiler error messages appeals to me. Rust has opened me up to meeting new people and having new experiences, so you can be sure that I’d always defend it at any chance I get.

This Rust story is based on Ayodeji Adeoti’s experience learning and using Rust.

Building Nocode with Rustlang.

bolubee101 — Sun, 05 Jun 2022 05:27:20 +0000

I’ve known about Rust for a very long time, as far back as 2015. It was just a brief encounter. When I say brief, I mean, I installed it on my laptop, and never opened it again. The concepts went over my head a bit. So, I focused on other things. And boy did I have a variety of interests. First, I wanted to build my own software for creating visual effects like Adobe or something like that. Then I tried android programming, then game programming, and maybe one or two more things along the way. But, they didn’t work out. I think the reason why they didn’t work out was that I was trying to build things from scratch without leveraging some of the tools that were already available. Building things from scratch, straight from my IDE, seemed fun. Eventually, after some thinking, I decided to focus on web development, as a full-stack JavaScript developer, and with that, I also got into Andela, a software developer placement network.

While waiting for placement at Andela, I started something. I wanted to create a community of developers who had already worked on WebAssembly projects in the past. A bit of a back story is in order now. During my exploratory phase before I settled for web development, Web Assembly was announced. So on a whim, I created a Repo to keep track of languages that compile to web assembly. The repo ended up getting over three thousand stars. I honestly didn’t expect it to blow up as much as it did, but it did. That feat fueled my interest in Web Assembly. As I was saying, I wanted to gather Web Assembly developers together for a purpose - to create a common web assembly runtime, a canonical runtime. My attempt at community building didn’t go so well. I sent a couple of emails, and DMs to no avail, or so I thought. It was during this time that Syrus Akbary reached out to me, he pitched the idea he had to build an awesome web assembly runtime, Wasmer, and that he would want me to be involved. He was really excited, and so was I. The only thing was that he said he had to lay down some of the groundwork first. So he worked on it for about a month. Now that I think about it, I should have stuck to him while he laid down the work because when he showed me the progress he had made, I was awe-stricken, but also disadvantaged. A lot of work had been done. Here we were trying to build the web assembly runtime that would take the world by storm, but my knowledge of Rust was meager. Keeping up was hard. Eventually, I had to leave the project, he was incorporating Wasmer as a company, so relocation was being discussed but I wasn’t interested in going to the US. But I think the major deciding factor for me was that I didn’t really align with the management of the project.

I stayed off Rust in a professional capacity for a while but contributed to some open source projects during that time, I even started some of my own, one of them being Gigamono - The most comprehensive no-code platform you’ve never seen. Yeah, never seen. Right now, due to the intensity of my job, I am not actively working on most of Gigamono. The parts of it that still have my attention are: The web assembly runtime, and a programming language that goes with it.

Currently, I work at fission.codes, and I have to say, it’s right up my alley. I wasn’t expecting to get the job. In fact, I didn’t really take the application seriously. But to my surprise, the CEO reached out to me to schedule a call, which I missed. I was really tired that day, so I slept off. I reached out to the CEO apologizing for missing the call, and trying to reschedule. Thankfully, he did. The interview went smoothly, and I got the job.

At Fission, I’m the only Rust developer, and I love the kind of things we are building. Something we are working on is a web-native file system built on top of IPFS (Interplanetary File system). It is essentially, decentralized file storage. Another thing we are working on is decentralized authentication and decentralized identity. We want to give users total control of their identities. The server wouldn’t need to control anything about the user. From their browser, they can sign the things they send to the server or encrypt it without the server really having any idea of what is going on. I’m really working on the fun stuff, cutting edge. We take research really seriously. What we work on is not something that can be done half-heartedly. I even had to put the development of Gigamono on temporary hiatus.

Despite being on hiatus, I think Gigamono is the future of no code, and in part, serverless. But the thing is it’s too grand an idea to take on as a broke person. With that said, there are parts of it that I still make out time to develop - the web assembly runtime. Gartner, the analytic company, forecast that by 2027, 67 percent of software would be built by nontechnical developers. So, I have no doubt that in the near future the no-code development space will blow past its “twitter bubble”.

My plan with Rust is to get into decentralized identity, I have to say Web3 is really fascinating. I would also be looking at Zero-knowledge-proof. I might not actively participate in it, but I will definitely be keeping my eyes on it. On the low-level side of things, I want to build a programming Language - Racoon to be used in conjunction with my Web assembly runtime. Far into the future, I am going to be deeply involved in no-code AI. I’ve always loved doing low level things, that’s what made web assembly attractive to me, and in recent times because of how much power it gives you when you go low level, Rust. In the near future, most of my projects will be in Rust, and maybe Racoon. The journey so far has really been fun and I'm really excited for the things to come!

This story is based on Appcypher's experience with Rust.

Rust-Time Communication.

bolubee101 — Wed, 04 May 2022 23:16:33 +0000

The final year in school is a trying time for a lot of people, and I was not an exception. I was working on my final year project, a chatting application for my school, the University of Lagos. My goal was to include text chat, video calls, and voice calls into the application which I intended to write in Golang. I did that, and it worked. It was done…or so I thought. During the testing phase, I had a couple of classmates, about 20 or so, connect to my server to test my application out. It lagged and was pretty much unusable. I had to look for an alternative. Then suddenly, the ASUU strike hit, and there was time to rewrite my project 10-50 times, as many times as I wanted. ASUU, Academic Staff Union of Universities, is the body to whom all university lecturers report, and its members went on an indefinite strike. The reason? The government had some unpaid dues or something. Anyway, a strike meant no classes, no classes meant no school, no school meant more time…plenty of time.

I had known about Rust before, and I had done a bit of research myself. A couple of things stood out to me. Its low-level access, the absence of a garbage collector, and its famous speed. It ticked all the boxes I wanted. Also, implementing my project in Rust potentially meant lower costs. Rust is really low level, so it makes the most of the resources available. That meant that I didn’t have to get a powerful server to cater to my project’s needs. So I started learning Rust.

With the strike in session, I had a lot of time on my hands to learn what I needed to learn, and things went on smoothly till I hit a brick wall. I couldn’t find a Web RTC implementation in Rust. Web RTC is a framework that allows browsers and web-based applications to communicate in real-time. It is important to know that while Rust has made a lot of waves in recent times, it is still relatively new compared to other languages and development technology. There were still things that had not fully been abstracted to the level where regular developers could easily access the functionalities without having a deep understanding of how they worked. Web RTC was one of them. Now that I think of it, I found one, but it was basically just C embedded in Rust. While that sort of worked, It wasn’t what I wanted. I searched around a bit more, then I found someone, Rainliu working on a Web RTC implementation in Rust. It was in its early stages though, in fact, all that had been done was a collated list of frameworks that would allow Web RTC to work in Rust. I decided to help out, or at least try to help. There I was, a few weeks into learning Rust, and I wanted to help build a library.

The idea was to port Pion, the web RTC library in Go to Rust, and I played a major role in the early days of the project. I was involved in the RTP library, SRTP, and the Multicast DNS. I put in a lot of time, a commodity the strike ensured I had a lot of, and we made a lot of progress. In fact, a lot of people rallied behind the project making it worthy of the title Open source. It currently has almost 2000 stars on Github.

At my current workplace, Ockam, we work with many languages and stacks. I work in DevOps but Rust plays a major role in it. Amazingly enough, I learned about the job as a result of the massive publicity for the first event hosted by Rust Nigeria in 2020. Ockam put out a recruitment post under one of the publicity tweets. After checking out their website, I was interested so I applied. Ockam deals majorly with IT security, so a lot of their products deal with security issues. In preparation for my interview, I decided to use one of their Rust implementations to secure an application I had made before, particularly my MDNS implementation. There is a known security flaw in MDNS in which in basic terms, identity could be impersonated so I used an Ockam toolkit to secure it. I presented a demo of this for my interview and I got the job.

I cannot imagine ever leaving Rust and I don’t believe anyone who starts with Rust will ever want to go back. The idea that you have the compiler on your side is such an assurance. There are some mistakes that I’d make and the compiler would calm you down, then school you. There are mistakes impossible to take into production if you follow the rules and regulations of the compiler. For example, unless you use unsafe code, memory corruption is not something you’d worry about in production.

My experience with Rust since 2020 has been invaluable. With COVID and the rise in the need for video and voice communication services, the drive to get my project running was at an all-time high. Rust made it easy for me to keep working on what I wanted to, and this led me to open source, and with open source came experience and connections.

This story is based on Micheal Uti's journey with Rust.

The Chronicles of a Web3 philosopher.

bolubee101 — Tue, 05 Apr 2022 08:55:48 +0000

For me, Rust is not about the language, but what you can do with it. One of its coolest applications at the time I started Rust was in blockchain development. Most blockchain clients were written in C, C++, or Go. But Rust was new and used for mainstream blockchain development, so I felt this was the best combination. It was also around that time I started contributing to Rust-based open source projects. I had read and studied a lot of Rust code in 2017, but 2018 was my time writing the actual code. I was exploring the blockchain with Rust and was trying to build a payment system. Its idea was basically what Lazerpay does now, I called it Paysquare back then. The platform was built on Ethereum to collect Ethereum payments. To achieve this, a library called Web3 built by the developers at Ethereum existed. The only problem was that it was only written in Javascript. One of the engineers at Parity, where I later worked, who I would later get to know was pretty big in Blockchain and Rust had a Rust implementation on his Github, but it was unmaintained. Because of what I was building, I had to take over the project and contribute to it, along with other open-source Rust projects. During that period, my portfolio grew quite a bit. I contributed to a lot of open-source projects. Anyway, Paysquare didn’t work out, I think I lost motivation while building it.

In August 2018 or so, I was on the Rust Subreddit, and this company called Parity was hiring and I was interested. I had been writing Rust a lot during that period, so I was pretty confident in my skills. I applied. After a month, and a really weird interview process, I got in. The interview process I went through was not regular as I was not tested technically, rather my open-source contribution spoke for me. That's probably why when given the chance, I always advise new software developers to try contributing to open-source projects no matter how hard it might seem. Like Nike, just do it.

Anyway, My experience at Parity was a mixed one. On one hand, I got to work with really smart people. On the other hand, I was not getting a firm grasp of blockchain concepts like I would have liked to. It’s only now that I’m no longer with them, that I can look upon my time there and appreciate all that I learned. But while I was in the middle of it, I was stressed a lot of the time. I had imposter syndrome too. I was working with people way smarter than me. Anyway, I was there from September 2018 to July 2021. I wanted something new. After working at Parity and being exposed to the inner workings of a blockchain, I felt that I wanted to do something on the application layer. I knew working on the application layer of a blockchain product would bring the things I worked on at Parity into context. I currently work with a Polkadot parachain project called composable. They essentially use the substrate framework I had been working on for the past three years and use the Polkadot network security. So you can imagine the depth of understanding I have concerning the project.

I run an organization called Polytope labs. It’s an environment, a community of people who want to grow - people who want to take their software engineering career to the next level. Personally, I chose software engineering because out of all careers that exist, it was the only one in which you are in control of your trajectory. You don’t need to have a degree, and it’s entirely merit-based. There’s no signaling you have to do apart from the work you already do. I started coding with PHP in 2018, doing gigs on Nairaland, but at some point, I decided it was time to move to the next level. I learned mobile engineering to get to a certain point, then after that, I learned Rust to get to another. The plan has always been to move to the next level by taking on the harder stuff. That’s why I started Polytope labs - to help people advance their careers by taking on the harder stuff. We are currently focused on Web3, but really, we would make use of any field that moves our agenda forward.

As for my career plans, omo, I think my Rust journey will come to an end soon. I feel like I have more affinity towards designing systems rather than implementing them, "being in the trenches" and fighting with the Rust compiler. I think it would be a good experience for people just beginning their careers though. So in the future, I would probably focus on designing systems and growing the developer talent in Nigeria. A healthy goal for me would be to get at least a thousand developers employed in the Web3 space from Polytope labs in potentially the next two years. I know it will take a while, but I’m here for the long haul. This would enable us to build Web3 products for Africa. And really, it wouldn’t be bad if we have the developers building these web3 products to be people you know, people you helped to grow.

This story is based on Seun Lalenge's experience using Rust.

I wrote my way up

bolubee101 — Fri, 04 Mar 2022 20:45:54 +0000

My encounter with Rust was, in summary, fate smiling upon me. I used to write mainly on JavaScript-related technologies, Vue and Node to be precise, on LogRocket, a technical article blog. LogRocket allowed its writers to suggest (pitch) article topic ideas, which would get vetted, and if approved, the writers get to write on. They also have a pool of topics for writers to pick from. Due to its popularity, JavaScript had a lot of articles written on it, and at some point, I found myself without any unique topic to write on. The suggestion board didn't have any JavaScript topic at the time, so I had to explore other technologies. One of the available suggestions was a Rust-related article topic idea. It had been sitting there, unpicked way longer than other articles usually sat. Apparently, there weren't many Rust writers on the platform. After some contemplation, I thought, "why not?". My thought process was, there was google, the documentation, other articles, etc. I was pretty confident in my research skills and since there was really nothing stopping me, I picked two Rust articles and wrote on them.

One of the articles I picked was on Cryptography in Rust. I remember the day I started writing it. I was sitting outside at home writing and researching my article, and I thought, "this is easy". I found the style of writing Rust intriguing. Like I said earlier, I used to write JavaScript, so comparing that new Rust experience to JavaScript, where packages would generally be installed with NPM, I found just writing your dependencies in cargo.tml more instinctual so I wrote the article and submitted it. It was reviewed, accepted, and published. It was the regular "all in a day's work" until the feedback came in. My article was really liked, and apparently, it helped people understand cryptography better. This spurred me to write the second one, then I paused, there weren't anymore Rust topic suggestions. During my break, I learned a bit more about Rust and wrote more on my personal blog.

A while later, an organization put out a call for developers to submit proposals for a talk. I was interested, so I applied. My submission was one of the Rust articles I had written before. "Ownership in Rust", and it got accepted. I gave the talk, and the feedback was overwhelming. It was then I decided to really immerse myself in Rust. I had realized that because the Rust ecosystem hadn't been explored as deeply as other technologies, when I wrote, traffic was enormous.

During my exploration, I discovered two crates - Ether.rs and Web3.rs. I wrote on the differences between the two and shared my article on Twitter. That's when someone reached out to me. He said he loved my article and hoped we could have a conversation. I agreed, I'm glad I did. During our conversation, he brought up an open role in his company that he hoped I could fill. Of course, I had lots of questions which I asked. After a while, he asked me to search for him on the internet. He turned out to be the former CEO of Tendermint. I was excited and mind blown. I mean, before that day, I had chopped plenty of "rejection breakfast" with regards to job applications, so this was a welcome surprise. After I had calmed down, we scheduled something like an interview call for the next day.

Hehe, I almost missed my interview. I forgot to take the time zone difference into consideration while preparing for the interview. I first argued that the call wasn't due for another 1 hour 30 minutes before my attention was drawn to the time difference. I was not ready. I mean, I still had my hair net on and was still in my PJs. Anyway, I had my interview like that. At the end of the interview, the interviewer said he was seeking to hire a junior Rust developer, and he thought I was a perfect fit. He then asked what my expected remuneration would be. I laughed; that was new, hadn't been asked that before. I reflected on the question a bit then asked what they wanted to pay. That turned out to be one of the best questions I've ever asked before. He mentioned what they had planned, and when I did my calculations, I could barely contain my excitement.

The company I work for is Sommelier. We help users and market makers to invest their funds to increase the chances of making a profit. At work, I write Rust as a Protocol Engineer. My job is basically to write applications for the Blockchain, managing how contracts behave. Work has been really interesting, and I've had the opportunity to grow. The fact that we are writing Rust has played quite a role in this. We have this thing when a person is working on a feature, we allow the person to work on it from start to finish. We don't have to worry much about code quality amongst the different developers. Rust's opinionated style forces everyone to conform to a single style, allowing for code uniformity among features even if they were written by different developers. The opportunity to handle a feature alone has contributed to my growth.

When I think of my journey so far, I have to admit I was fortunate to have encountered Rust. When I got my job, I was just in my final year of university; it was my first role. I did not expect such good fortune. I was just doing my thing, writing articles, Rust articles, and it happened. I've been here for 8 months now, and it has been awesome.

This story is based on Ugochi Ukpai's experience.

Deploying Your Rust Apps in the Cloud

Austin Aigbe — Fri, 04 Mar 2022 05:13:48 +0000

Introduction

In this article, I provide a step-by-step guide on how you can easily deploy your Rust application in the cloud with Amazon AWS EC2. Depending on your system requirements, you can deploy your application in the cloud to save you the hassle of managing the hardware infrastructure yourself so you can focus on what matters - your application and the customers they serve.

Prerequisites

I am assuming you already have an AWS account, if not please create one and login as root user. We will be using the AWS EC2 Free Tier t3.micro compute, as our virtual server in the cloud.

Step 1

After logging in as root to your AWS account, switch to the new view and nagivate to EC2 as shown in the screenshot below. Select Services, Compute and then click on EC2.

Step 2

Click on Launch instances as shown below.

Step 3

Under choose AMI, first check the Free tier only box on the left side of the window and then select any image. I selected Ubuntu Server 20.04 LTS image. You can experiment with any of the images.

Step 4

Make sure you select the t3.micro (it is the free tier instance type) and then click on Review and Launch then Launch. This will display a window asking you to select or create a key pair. Select the applicable option and then click on Launch Instance

Step 5

Give your virtual server a name. Mine is named server-01. Wait for your server to change Instance state to Running before you connect to it.

Step 6

Now, you can connect to your virtual server using PuTTy, Powershell, Bash (if you are using Linux), CMD or any client application that supports SSH. I am using PuTTy. To connect to the compute or virtual server, ssh to the Public IPv4 DNS address specified under the Details tab.

Step 7

The user name is ubuntu. The virtual server has access to the internet and you can install any package you need. Now, let's install the Rust compiler.

Step 8

Install Rust and buid-essential (sudo apt install build-essential).

Step 9

We will be deploying two types of application on the virtual server - a telecoms application (a GTPv2-C server) and a web application based on the warp crate. GTPv2C protocol is used in the 3GPP based 3G, 4G and 5G networks for signaling and it uses port 2123 and the UDP transport protocol. We will configure our Rust GTP server to listen on UDP port 2123 in compilance with the 3GPP TS 29.274 (GTPv2-C) standard.

The web server will listen on TCP port 3030.

Configure the Inbound rules as shown below. AWS EC2 will apply these rules to our virtual server and it will allow our Rust applications to send and receive messages using these rules.

Step 10

Create your web server application using cargo new web_server and edit with nano as shown below. The original code is available here:https://github.com/seanmonstar/warp and it has been slightly modified for this tutorial. Run the web server with cargo run.

After this step, you will have two Rust applications running in the cloud. You can use the ps aux | grep target to check the two processes running (gtp and web_server)

Step 11

Open another PuTTy session and connect to the virtual server. Clone the GTPv2-C server from https://github.com/eshikafe/ngc and edit the ngc/common/gtp/src/main.rs so that the server listens and accepts conections from any IP address (i.e 0.0.0.0) as shown below. Run the application with cargo run

In the screen shot below, a simple Python script (the client) sends a message to the gtp server application using the Public IP address and port 2123. The script sends a GTPv2-C Create Session Request message from my Windows PC, through the internet, to the Rust GTPv2-C server application running in the cloud. This implies that you can deploy a telecom application (based on Rust) in the cloud to serve multiple devices concurrently and efficiently. The sample gtp application uses the tokio crate to achieve concurrency. Concurrency is a key requirement for a 4G/5G telecom server application.

Step 12

Lastly, open a web browser and paste the following URL in the address bar:{Public IPv4 DNS}:3030/hello/Rustacean. Replace Public IPv4 DNS with the domain assigned to your compute. You should see the message below.

You can also use curl to test your web server as shown below.

To deploy your applications securely in the cloud, you need to understand how the AWS EC2 security group works. Please read the AWS EC2 security group documentation before you deploy your application as a production system in the cloud.

Reference

AWS Tutorial for Beginners - Full Crash Course | Neal Davis

Rust-y Memory. How Safe?

Austin Aigbe — Fri, 04 Feb 2022 20:03:34 +0000

By Austin Aigbe

Introduction

The Rust programming language is said to be memory-safe but how does it achieve this? Why should we even care about memory safety? It turns out that the major cause of security vulnerabilities in modern day software systems (including Desktop and mobile applications) is due to memory safety issues and to address this, there is a general consensus, which I personally agree to, that a memory-safe systems programming language like Rust is required. This is one of the reasons big tech companies have decided to invest in Rust and re-engineer some of their key products and services with it.

How does `Rust` Achieve Memory Safety?

Memory safety is achieved through three key concepts: ownership (a language feature the compiler uses to free and allocate memory based on the scope of a variable binding), borrow checking and lifetimes. All these analyses are done during compile-time.

For simplicity, I will focus more on the ownership concept and show us how the compiler guarantees memory safety at compile-time using the scope of a variable binding to determine when to allocate and deallocate memory on the stack.

Before we proceed, let's review how our code is analyzed by the Rust compiler (rustc) for memory safety.

Code Compilation With Memory Management

In simple terms, a memory is a storage space (e.g RAM) on your computer where instructions to be executed by the computer's CPU are stored. These instructions are the lines of Rust code you have written and compiled with rustc (the Rust compiler) or cargo into a machine executable file (e.g .exe file format on Windows and elf on Linux). The executable file tells the Operating System how to load your Rust program into memory for execution by the CPU.

Now, let's compile a very simple Rust program with rustc and examine how memory management (ownership) works in Rust.

// hello.rs
fn main() {
    let rust_edition = 2021;
    let message = "Hello, Rust";
    println!("{message} {rust_edition}!");
}

Compiling the above code with rustc .\hello.rs on Windows will produce an executable file,hello.exe (about 148KB in size), in the same directory as the .rs file.

Next, let's see how the hello.exe was produced by rustc and how the memory-safety checks were done.

The Rust compiler, rustc, performed several analyses on the hello.rs file before it produced the hello.exe executable file. I will give a high-level overview of this process so we understand how memory safety is achieved by the compiler and at what phase of the compilation process it is done.

Figure 1: An simplified view of rustc compilation process

Phase 1: hello.rs was translated to basic tokens using the rustc_lexer crate and then to Rust tokens using the rustc_parser crate. Tokens are easier for the compiler to work with than the text format of your .rs file.

Phase 2:Tokens were translated to AST (Abstract Syntax Tree) format. Syntax analysis is done here. Use cargo inspect --unpretty=ast-tree .\hello.rs to examine the AST output.

Figure 2: AST tree of hello.rs with cargo-inspect

Phase 3 The println! macro was refined (or desugared) to a std::io::_print statement and core::fmt::Arguments function calls.The data type of our expressions were inferred and checked. We can say that type safety is guarateed at this phase of the code compilation. The HIR (High-Level Intermediate Representation) is the output of this stage. You can use crago inspect --unpretty=hir .\hello.rs to view the HIR representation of your Rust code.

Figure 3:println! macro desugared in the HIR.

Phase 4 HIR was converted to MIR (Mid-level Intermediate Representation). Ownership, borrow-checking and optimizations are done here. In fact, the MIR shows the scope of each variable and helps the compiler know at what point a variable binding (or ownership) is out of scope and when to dellocate memory from the stack. How the compiler tracks the scope of each variable is indicated in the screenshot below. In fact, the assembly code generated by LLVM (in phase 6) is the machine representation of the MIR (after the ownership, borrow checking and optimizations have been done). In the next phase, the asm .S file is examined to see how the variables are allocated on the Stack when they are in scope and how they are deallocated when they are out of scope. In this phase, memory safety is guaranteed by the compiler.

Figure 4: MIR representation of hello.rs

Phase 5 and 6 This is the code generation phase - LLVM was used to generate the final executable file hello.exe from the optimized and memory-safe MIR representation. Further optimizations can also be done by LLVM.

Let's briefly examine the assembly code (.S file) generated by LLVM. You can use rustc --emit asm .\hello.rs to generate the file. To keep things simple, I will only examine how the ownership memory-safety feature was achieved by the allocation and deallocation of memory on the stack.

Figure 5: A simplified memory layout of the stack from the perspective of the compiler generated main function.

The assembly code for the main function is shown above (in Figure 5). The entry point is not our hello::main function. As we will see later, Rust has a runtime (std::rt::lang_start_internal). This runtime handles a lot of complexities for us that we don't need to bother about when writing our Rust code.

Line 516: The compiler generated main function is the entry point for our program.
Line 518: 40 bytes of memory is allocated on the stack.rsp is the 64-bit stack pointer register for x86_64. It always points to the top the stack.
Line 523: _ZN5hello4main17h0767239aa2b5c6caE is the mangled symbol for our hello.rs main() function. The address of our hello::main function is stored in %rcx and then passed to the runtime function as a reference in line 103.
Line 524: This line calls the Rust runtime function std::rt::lang_start (defined in line 94) and subsequently, the internal runtime function std::rt::lang_start_internal (defined in line 104). Rust has a runtime that executes our hello.rs main() function.

Figure 6: Rust runtime function executes our hello::main function

Figure 7: Execution of hello::main (part 1)

Figure 8: Execution of hello::main (part 2)

Figures 7 and 8 show how sufficient memory (200 bytes) was first allocated on the stack by the compiler before allocating memory to the two local variables rust_edition (an i32), and message (a &str). Before returning from the hello::main function, the compiler deallocates memory on the stack and frees up resources.

Conclusion

We have seen how Rust guarantees memory safety during compile-time by examining the compilation phases and how memory is allocated and deallocated on the stack in assembly code. A very simple Rust program (hello.rs) was used to examine the output of each compilation phase and the memory management of the stack in assembly code.

We also learnt that the Rust compiler generates a main function for us as the entry point of our program. This main function uses the Rust runtime to execute the main function of our Rust program.

In summary, Rust tries to guaranty memory safety during compile time and it does a pretty good job in ensuring this.

References

My Rust Book: Language for the next 40 years

bolubee101 — Wed, 02 Feb 2022 13:03:55 +0000

Chapter 1: Discovery

My Rust story started when a 17-year-old me found some articles about it on Stack Overflow. Rust had built a bit of a reputation, that prompted me to do some research on it even though I had no use for it at the time.

A bit of a back story. Before Rust, I was working on Byte Stash, a decentralized file system. The plan was to write a Proof of concept in JavaScript, then write the actual program in an ahead-of-time compiled language. The thing is I didn't know what language to use. Of course, C/C++ was the first option that came to mind, but the second thing that came to mind was the possible pitfalls that one could encounter while using it. So, I decided to search for another option.

Whenever I discover a new programming language, there’s this thing I do with it, it’s probably not the best way to judge a language, but when I see a “-.lang” website, I go in and try to reason about the semantics. If I find it intuitive I can say I am already a fan of it, and if I don't find it intuitive then, hehe. That’s the problem I had with Golang and its walrus assignment operator at the time, its use just wasn’t as intuitive to me as I’d have wanted it to be.

That didn’t mean Rust was without qualms. Rust is beautiful, and things make sense as you learn. But in the early learning phase, when writing it, it can be hard to follow. With the static type system, the compile-time optimizations, it’s possible to lose track of what you’re actually working on. When you get the hang of it though, the feeling is ecstatic. In the Rust book, there was this exercise, “12 days of Christmas” I rewrote that particular piece of code over and over again. The aim was to write it in as few lines as possible, eliminating all the default scaffolding code. When I was done, “beautiful” was what I’d describe the end result as. I took a screenshot and kept it on my Whatsapp status for like 3 days (even though I didn’t think anyone cared to see it).

Chapter 2: The Holy grail

Back to why I learnt Rust, byte stash. I put the project aside. Hold on, hear me out. After building the proof of concept in Javascript, my search for the ahead-of-time compiled language for the main project began, then I found Rust. In the time I took to learn rust, and finish up on the proof of concept, I burnt out and took a break from writing code. So I decided to put it aside till I had other people pitch in. Instead, I started rewriting my JS libraries in Rust. Xbyte is one of them. Xbyte was a tool I made to convert bytes into human-readable sizes and vice versa. For instance, 4747 → ('4.75 KB'). When I built this in Javascript, it was relatively easy. But in Rust, it was another ball game. I didn’t need a 64-bit integer, or a 128-bit integer so I invented my 91-bit integer. I spent a lot of time on it, reading what was in the standard library and adapting it to my 91-bit integer. I did abandon it later though and go with the 128-bit integer. But I learnt a lot while working on it. When you are not used to working with core primitives, and you get to touch the holy grail, you feel like you have to advocate for the holy grail. I hadn’t spent much time optimizing for performance previously, but when I started writing Rust, I got to think about optimization, the feeling was exhilarating, a bit frustrating, but definitely exciting. For instance, in javascript, everything is on the heap, you don’t think about it. But with Rust, you are conscious of what you are doing. That’s what I love about Rust. Even if you don’t go to MIT to learn about how computers work, you can’t help but think about some of these things. Not because if you don’t things would go bad, but because these concepts are baked into the type system.

Chapter 3: The expression of knowledge, and possibilities.

In 2019, I scoured YouTube for every video on Rust, watching conferences, and tutorials. At some point, I doubt there was any video content on Rust I had not watched. It was fun. But there is one thing I found out. The more knowledge you have in your artillery, the more you’d be able to express yourself while writing code. As you learn more about a language like Rust, what you can do, how you can do it expands. And it slipped into how I did everything, including writing my documentation.

Around that time, I started working on Freya, a software that would pull all the metadata from various music providers. You paste a link it would grab the metadata of the track, playlist, or album and present it to you so that you'd be able to do anything with it. It was written in Nodejs, but I wanted to write it Rust, or at least create a GUI in Rust. I created a UI component library for it, but didn’t get to using it, I burnt out. But after taking a brief break from coding, I went back to learning Rust. I kept building things, not because I had to, but because it was an idea, and it was possible.

Chapter 4: Near

January 2020, I was on my way to computer village (A place where gadgets could be bought or repaired), when I received an email from a recruiter from Near on LinkedIn who had seen some of what I had been working on and wanted to get more information about me. He explained the whole thing and brought up the issue of work, and I was interested. A couple of interviews were set up, and I did research on who my interviewers were. Guy, one of them was a professor. I started to wonder what I brought to the table. All I had were some CLIs and some libraries. It was later I found out from one of my interviewers that one of the things that drew them was how I wrote my documentation which when I thought about it made sense. I spent a lot of time on the Nodejs documentation, so I wrote mine in a similar way. Near builds and maintains a blockchain, something I had no experience about when I joined. This is something I have to talk about. A lot of people think you have to be a blockchain god to join a blockchain company, well I wasn’t, and neither were a lot of the people who work at Near. We were all just a bunch of good engineers from different fields who would just bring their expertise to the table. The blockchain side of things is just something they picked up when they join.

Chapter 5: Different and good.

At NEAR, one of the things I was excited about was the kind of people I work with. Aleksey Kladov, the author of Rust analyzer, and the person who reviewed his first PR code work at my company. In the time I’ve worked with them, I have come to realize that they both write Rust differently yet, they maintain almost the same level of aesthetically pleasing elegance in their code. Another thing I’ve come to realize is that there are people that have such a deep understanding of how the language works that even before running the code, they know what assembly output would be, how it would work, the possible errors the rust compiler would flag. It’s crazy.

Chapter 6: Change and letting go.

Change is good. At some point in my journey, I realized due to my interests, my language set wasn’t what was going to get me hired. Most people were interested in Backend, Frontend, etc. But building system things was what I was interested in. There were times I just put aside my fascinations to just get the job done, but those experiences were not rewarding. So for me, moving to Rust was the logical thing to do. While I had to learn the language and all, my focus didn’t really change. In my initial days, there were times I wrote Rust like JavaScript, but there were times Rust wouldn’t even let me. I had to have a lot of shifts in my programming paradigms. For instance, as JS devs, we learn a lot about Object-Oriented Programming. But when you start writing Rust, Structs and traits take over. I found that it's harder to leave things you have learnt for new things even if they are more convenient. But dread it, run from it, change still arrives.

Chapter 7: Language for the next 40 years.

Rust really is an amazing language. I bet at some point in the life of any Rust developer the statement, “Rust has taught me to write better X” has been made, where X is any other programming language. The paradigm shift when writing Rust is amazing and its benefits cut across the board. Rust has practically changed my life, and I don’t see myself really writing any other language for the next 40 years the way I see myself writing Rust.

The Beloved Crab

bolubee101 — Mon, 03 Jan 2022 13:08:09 +0000

I had seen an error message before. I mean, I had been coding for well over 2 years, but what I saw that day was no error message. It was a guide, a tutorial, a lifeline.

Take this example below gotten from “the rust book”(Probably one of the best documentation in existence). With just the basic knowledge of the programming language, it is quite easy to figure out what the problem is from the message. I mean, I’m not pointing fingers, but I’ve seen JavaScript's error messages.

The Rust compiler error message was something I had never encountered before. It reminded me of the Youtuber, Mosh’s explanations. I write a lot of JavaScript, so I learnt a lot from him. The Rust error messages were comparable to Mosh fleshing out a JavaScript error message. No wonder Rust has topped the stack overflow survey for most loved language almost six years in a row.

A bit of a backstory. I found a Stack Overflow survey on the most loved programming languages, and Rust topped the list. I did a bit more digging and got an understanding of why Rust is loved. No programming language that user-friendly should have that much power. At that point, my interest in Rust and its associated technology had almost consumed me. The finishing blow was when I saw the average salary of a rust developer, and well, here we are, I’m telling my Rust story.

I’ve been actively learning Rust for about two months now, a combination of books, videos, and help from the Rust community. Rust developers are easy to spot on Twitter, just watch out for crabs - the red emoji with two pincers raised, and a species of users called Rustaceans. Example:

They are everywhere and are the most accommodating set of people you’d ever meet. Also, I find that they - and when I say “they”, I mean, “we”, at this point - always have something to say about Rust. The community is really passionate. I’d say I feel really passionate about Rust too. I mean, I spend about 12 hours a day actively learning. I intend to become a Rust beast. I’d probably soon go on a break from writing other languages to immerse myself fully in learning Rust.

I see C/C++ people(developers) as wizards, making magic with complicated spells. A forbidden terrain for the simple. But with Rust, I have the power to create magic with simple things (simple compared to C, and when fully understood at least). Simple(semi simple) syntax, simple error messages, and guides like memory safety features, safe concurrency, and memory management, that protect you from the complications that could arise when building applications with C. The thrill of learning something new is still very much with me.

I don’t know what the future holds, but I bet there’s a red crab in it.

This story is based on Ademola Tomiwa's experience with Rust.

Rust: Rewriting Experiences

bolubee101 — Mon, 03 Jan 2022 07:42:20 +0000

Before I begin, let me get one thing out of the way. Rust isn't a programming language, it is an experience. Okay, it is a language, but who doesn’t like an epic intro?

Two years ago, Eze came across Deno. Don’t worry, this is still a Rust story. What caught his attention was that Deno, originally written in Go, was rewritten in Rust.

Why? How? Go, supposedly one of the “big boys”, was replaced. He did some research and thought:

heck, everything should be rewritten in Rust

A quest he seems to have taken upon himself to begin.

He set time apart to learn Rust, and in the process realized the potential of what he could eventually do with it was endless. His first real contribution with Rust was to Deno, then Deno-lint. He did get some help though.

It wasn’t easy at first honestly. Finding what I could contribute to, then even contributing to it. I couldn’t have done it without the help of one of Deno-lint's main contributors, Bartlomieju, who put me through.

Along the line, Eze joined Hasura, and a mission in the quest to rewrite everything in Rust opened up. The mission was to rewrite the Hasura Graphql engine currently written in Haskell with Rust. A friend of his started the project, and he joined in on it. Although he said right now it’s just on the side, it has the potential to become a really large scale. The experience so far?

One thing is for sure though, writing it in Rust makes me feel like superpowers have been bestowed upon me. Really, compared to other languages I have written, no experience comes close.

His case in point - Eze was on an adventure in December, an adventure of code (advent of code). 5 programming languages - Kotlin, Rust, F#, Clojure, Haskell - and a pool of algorithmic exercises.

My experience during advent of code further increased my love for the programming language. For a relatively new programming language, it’s amazing how many resources there are on the internet. The rust community keeps churning out resources at unbelievable rates. When you search for the solution to a problem, you’re almost sure of finding the required solution in the first 3 results of the search. Run into an issue in Clojure…only the heavens would be able to save you.

Apart from the power, and possibility with Rust, there was something else that stood out to Eze - the community.

I am about to say something that might sound cringe, but writing Rust and engaging in the rust community has made me a better person, a more considerate person.

According to Eze, the community is full of nice, and passionate people, always ready to help.

Chances are the nicest developers around you, have come in contact with Rust.

Also, for the optimal Rust experience, there are coding practices and patterns that are ingrained into the language that makes you think of how the piece of code you are writing would hold in the larger scheme of things. How it would affect other contributors, and code refactoring if need be.

Then there’s the confidence boost. While working on the Graphql engine in Rust, Eze, and his team mate, had had to refactor quite a number of times.

Remember how I said Rust makes you conform to some patterns, they are for our own good. Refactoring has never been easier. You are almost certain that after a proper refactor, following Rust patterns, as long as it compiles, your code will do what it is supposed to do. That kind of experience does a thing to a man…It sends your confidence through the roof.

You know what, I reiterate what I said at the beginning. Rust isn't just a programming language, It's an experience.

This story is based on Eze's journey with Rust.

Forem: Rust Nigeria

Rust: An odyssey of passion

Rust's Defender

Building Nocode with Rustlang.

Rust-Time Communication.

The Chronicles of a Web3 philosopher.

I wrote my way up

Deploying Your Rust Apps in the Cloud

Introduction

Prerequisites

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

Step 8

Step 9

Step 10

Step 11

Step 12

Reference

Rust-y Memory. How Safe?

Introduction

How does Rust Achieve Memory Safety?

Code Compilation With Memory Management

Conclusion

References

My Rust Book: Language for the next 40 years

Chapter 1: Discovery

Chapter 2: The Holy grail

Chapter 3: The expression of knowledge, and possibilities.

Chapter 4: Near

Chapter 5: Different and good.

Chapter 6: Change and letting go.

Chapter 7: Language for the next 40 years.

The Beloved Crab

Rust: Rewriting Experiences

How does `Rust` Achieve Memory Safety?