Why programming community should be serious about RUST

I have been exploring Rust from the last few weeks, as it has been declared the most loving language in 2018. As a Scala/Java developer, I worked on many applications, which were related to the banking domain, web applications, mobile applications, e-commerce, social media, etc. But I was not able to find what kind of applications should be built in Rust? I have searched Rust’s Continue Reading

Different ways for `Error Propagation` in Rust

Error Propagation means the code, that detects the problem, must propagate error information back to the caller function so that it can handle the problem. In the real world, the practice of Error Propagation is necessary. One of the benefits is that your code will look cleaner by simply propagating error information back to the caller that can handle the error and another benefit is Continue Reading

Hawk: Image Recognition Application using Rust and AWS Services

Rust is one of the newest kid on the block in the modern programming languages. We tried to take advantage of its great features by using it in an Image Recognition blueprint project. This project can be traded with any existing security system deployed at any organization. Hawk uses AWS services integrated with Rust. Starting with Rust Rust is blazingly fast and memory-efficient: with no Continue Reading

Another way of creating instance of `struct` in Rust

Till now, I knew only one way of creating instance of struct in Rust , which is mentioned in Rust’s official programming book, by adding curly bracket after the name of the struct and add key-value pairs inside curly brackets like below example. I explored another way of doing this using derive-new. This will add an impl fn new(…) -> Self method generated from the Continue Reading

Non-lexical lifetimes in Rust

This blog is for new Rustacean, who just started exploring Rust. I was exploring Rust’s Vector collection, but got confused while testing one of the Vector example of Rust Programming book. Above code won’t compile because we can’t have mutable and immutable references in the same scope. But if we write println! before pushing element into v, code will compile and execute. Here I got Continue Reading

Implement ‘unimplemented’ feature of Rust

The headline looks weird. Isn’t it. Well, there are some hidden corals in Rust sea, which you won’t find in Rust documentation. In the continuation of my exploration about Rust language, I found a useful feature unimplemented!. This feature lets you write a not-yet-implemented method, like this: The methods you define can also take input parameters and specify a return type, like this: Although your Continue Reading

Lifetime in Rust – Part 1

Rust can be a tricky language to work with and one of the prime reasons for that is the way it manages its memory. In my previous blogs, Ownership, and References I discussed how Rust works its memory management and how it manages to refer to a variable without actually taking the ownership of the variable. Now, let’s take a step further. What happens when Continue Reading

How to Write Better Compilation Error Message In Rust

While exploring Rust’s standard libraries, I came across a beautiful feature of RUST – compile_error. However this feature is useful for only specific use cases, for example:- when you are defining macro_rules! or conditional compilation strategy. Let’s see both use cases, one by one. 1) macro_rules macro is a very powerful feature in Rust. We use it for metaprogramming for reducing the amount of code. Continue Reading

Welcoming RUST to the world of IoT

Breaking away the stereotypes of a blog, let’s start with a question. What’s our future? If I was asked this question, it has to be IoT. Internet of Things has already taken the technology world by a storm and is continuing to do so. While learning about IoT, its uses and all that stuff, a desire to make my own IoT framework arose. I started Continue Reading

Loggers in Rust

Don’t Worry… I hugged it first – Loggers In Rust

Loggers play the most significant role in the software development community that not all developers take it seriously. Due to this, all have lost countless hours while debugging the code. So it is helpful to use logger. So, lets explore how to use loggers in Rust. Importance of Logger? Logger provides tremendous help to the developer while understanding the code. But also some developer assumes Continue Reading

No more run time !! Enjoy Compile time function evaluation using `const fn` in Rust

Sometimes we want the compiler to pre-compute values at compile time. If you have ever done programming in C++, you would have heard about constexpr which is used to improve performance by doing computations at compile time rather than run time. A few days ago, I was exploring Rust’s Unstable Book and found pretty much same feature in Rust, which is const_fn. I started exploring Continue Reading

Knoldus Pune Careers - Hiring Freshers

Get a head start on your career at Knoldus. Join us!