DEV Community: Chetan Mittal

The Power of Rust in Automotive Software Development

Chetan Mittal — Sun, 28 May 2023 09:10:39 +0000

The automotive industry is experiencing a significant transformation driven by the integration of software in vehicles.

From safety-critical systems to in-car entertainment and connectivity, software development has become a key driver of innovation in the automotive sector.

Rust, a programming language renowned for its emphasis on safety, performance, and reliability, is playing a pivotal role in this revolution.

In this article, we will explore the diverse applications of Rust in automotive software development and delve into how it effectively addresses the challenges encountered in this dynamic field.

Enhancing Safety and Reliability in Automotive Systems

Safety-critical systems lie at the heart of automotive software development. The reliability and security of software directly impact the well-being of vehicle occupants and other road users.

While traditional languages like C and C++ have long been utilized in this domain, they come with inherent risks such as memory-related vulnerabilities and undefined behavior.

Rust provides a compelling solution by offering robust safety guarantees through features such as ownership and strict compile-time checks.

The ownership system in Rust enables precise control over memory allocation and deallocation, effectively eliminating common issues like null pointer dereferences and buffer overflows.

By enforcing these safety measures at compile-time, Rust mitigates risks and enhances the overall reliability and robustness of automotive software, instilling confidence in its performance even in critical scenarios.

Unlocking Performance Optimization Potential with Rust

Performance optimization is a critical aspect of automotive software development, particularly in real-time systems where quick response times and efficient resource utilization are vital.

While languages like C and C++ have traditionally been favored for their low-level control and performance advantages, manual memory management poses challenges such as memory leaks and dangling pointers.

Rust strikes an ideal balance between performance and safety.

Its ownership and borrowing system allows for efficient memory management without the need for explicit deallocation, mitigating common memory-related issues.

Furthermore, Rust's concurrency model ensures safe and efficient parallel execution, harnessing the full potential of multi-core processors.

This unique combination of control, efficiency, and safety makes Rust an excellent choice for developing high-performance automotive software that meets the stringent demands of modern vehicles.

Empowering Connectivity and In-Car Entertainment Experiences

In the era of connected vehicles, software development for in-car entertainment systems and connectivity features presents its own set of challenges.

The software must seamlessly integrate with a wide array of hardware components, facilitate secure communication with external devices, and ensure reliability and data privacy.

Rust's reliability and robustness make it well-suited for addressing these challenges.

Its ownership and borrowing system, coupled with strong compile-time checks, help eliminate common bugs and vulnerabilities, enhancing data security and reducing the risk of potential breaches.

Rust's expressive type system empowers developers to create clear, maintainable code that effectively handles complex interactions between various components, ensuring seamless connectivity and enhanced in-car entertainment experiences.

Moreover, the extensive ecosystem of libraries and frameworks available in Rust provides specialized tools and resources tailored specifically for connectivity and entertainment applications in the automobile industry, facilitating rapid development and innovation.

Enabling Advanced Driver-Assistance Systems (ADAS)

The development of Advanced Driver-Assistance Systems (ADAS) is revolutionizing the automotive industry, with the aim of improving vehicle safety and enhancing the driving experience.

ADAS systems rely heavily on software to interpret sensor data, make real-time decisions, and assist drivers in critical situations.

Rust's safety and reliability features make it an excellent choice for ADAS software development.

The ownership and borrowing system in Rust minimizes the risk of memory-related errors, ensuring stable and predictable behavior.

This is crucial in ADAS systems where precise and timely response is paramount.

Additionally, Rust's strong compile-time checks and expressive type system aid in developing robust and error-free code, enabling the creation of ADAS software that meets the stringent safety requirements of the automotive industry.

Supporting Over-the-Air Updates and Maintenance

With the increasing complexity of automotive software, the ability to provide over-the-air updates and maintenance has become essential.

Software updates are necessary to address security vulnerabilities, introduce new features, and improve system performance.

However, ensuring the integrity and reliability of these updates poses challenges due to the critical nature of automotive systems.

Rust offers a secure and reliable platform for over-the-air updates and maintenance.

Its emphasis on memory safety and strong compile-time checks minimizes the risk of introducing bugs or vulnerabilities during the update process.

Furthermore, Rust's lightweight runtime and efficient code execution enable seamless and efficient updates, minimizing downtime for vehicles and enhancing the overall user experience.

By leveraging Rust, automotive manufacturers can ensure the timely delivery of updates and maintenance, keeping vehicles up-to-date and secure throughout their lifespan.

Driving Innovation Forward

Rust's presence in the automotive industry is driving innovation and pushing the boundaries of what's possible in software development for vehicles.

By leveraging the safety, performance, and reliability advantages of Rust, software programmers can create cutting-edge automotive software that enhances safety, optimizes performance, and delivers seamless connectivity and entertainment experiences.

As the automotive landscape continues to evolve, Rust's role in shaping the future of automotive technology will only grow stronger, enabling the development of smarter, more efficient, and highly connected vehicles.

Conclusion

By harnessing the unique features and advantages of Rust, software developers can create robust, secure, and high-performing automotive software that pushes the boundaries of innovation in the automobile industry, enabling the development of safer, more efficient, and highly connected vehicles.

Rust is not just making its importance felt in the automotive industry but is important in many other use cases as well such as Industrial Automation, IoT Devices, Embedded Systems, Robotics Industry, etc.

Industrial Automation Made Safer with Rust

Chetan Mittal — Mon, 22 May 2023 12:38:54 +0000

In the world of industrial automation, the reliability and security of software are of utmost importance.

As a software programmer currently learning Rust to build embedded systems for industrial automation, I would like to introduce you to the incredible capabilities of Rust and how it can transform the way we build these automation systems.

In this article, we will explore how Rust's memory safety and concurrency features work together to minimize risks, downtime, and vulnerabilities, ensuring smooth and secure operations.

Problem

When it comes to traditional programming languages like C and C++; they offer low-level control and high performance, but they also come with their own set of challenges.

Memory corruption, data races, and undefined behavior are common pitfalls that can have severe consequences in industrial automation systems, compromising safety, causing downtime, and creating security vulnerabilities.

This is where Rust comes to the rescue.

Leveraging Memory Safety

One of the standout features of Rust is its strong focus on memory safety.

Rust's ownership model eliminates many common programming errors that can lead to crashes or security breaches.

Every value in Rust has a single owner, and the ownership is transferred explicitly, preventing unexpected modifications or concurrent access to memory.

This ensures that the system remains stable and secure.

Rust also enforces strict borrowing rules, which means that the compiler analyzes the code at compile-time to ensure that references and borrows are always valid.

This eliminates the possibility of dangling pointers and null references, reducing the likelihood of runtime errors.

Concurrency Made Easy

Industrial automation systems often require concurrent execution of multiple tasks and efficient coordination of various components.

Rust provides powerful concurrency abstractions that make it easier to handle parallelism effectively.

With Rust's built-in support for threads, channels, and locks, we can express concurrent behavior explicitly, ensuring that data shared between threads is protected by default.

Rust's compiler actively detects potential data races, helping us identify and eliminate them early in the development process.

Additionally, Rust's concurrency model allows for safe and efficient communication between threads through channels, which act as synchronized message-passing mechanisms.

This helps prevent data races and ensures that threads can communicate reliably and without data corruption.

Robust Error Handling

In complex automation environments, errors are inevitable.

Rust's robust error-handling mechanism allows us to handle and recover from errors in a controlled manner, promoting fault tolerance and system resilience.

With Rust's Result and Option types, we are encouraged to handle errors explicitly, reducing the chances of unchecked errors that can destabilize the system.

The language's support for pattern matching and exhaustive match statements further facilitates comprehensive error handling, enabling us to cover all possible error scenarios.

Example

Here's an example in Rust that demonstrates the use of memory safety and concurrency features in the context of industrial automation:

use std::thread;
use std::sync::{Arc, Mutex};

// Define a struct representing a sensor reading
struct SensorReading {
    sensor_id: u32,
    value: f64,
}

// Function to simulate sensor reading
fn read_sensor(sensor_id: u32, shared_data: Arc<Mutex<Vec<SensorReading>>>) {
    // Simulate sensor reading and add it to the shared data vector
    let reading = SensorReading {
        sensor_id,
        value: 42.0, // Simulated sensor reading value
    };

    // Lock the shared data using the mutex
    let mut data = shared_data.lock().unwrap();

    // Add the reading to the shared data vector
    data.push(reading);
}

fn main() {
    // Create shared data using an Arc and Mutex
    let shared_data = Arc::new(Mutex::new(Vec::<SensorReading>::new()));

    // Create multiple threads to simulate sensor readings concurrently
    let num_sensors = 5;
    let mut threads = Vec::new();

    for sensor_id in 0..num_sensors {
        let shared_data = Arc::clone(&shared_data);

        // Spawn a thread to read the sensor
        let thread = thread::spawn(move || {
            read_sensor(sensor_id, shared_data);
        });

        threads.push(thread);
    }

    // Wait for all threads to finish
    for thread in threads {
        thread.join().unwrap();
    }

    // Print the collected sensor readings
    let data = shared_data.lock().unwrap();

    for reading in &*data {
        println!("Sensor {}: {}", reading.sensor_id, reading.value);
    }
}

In the above example code, I have defined a struct called SensorReading to represent a sensor reading with an ID and a value.

The function read_sensor simulates a sensor reading and adds it to a shared data vector, which I have protected using a Mutex wrapped in an Arc (atomic reference count) to enable concurrent access.

In the main function, I have created multiple threads, with each thread representing a sensor.

By using Arc::clone, I have passed the shared data to each thread. These threads simulate sensor readings concurrently by calling the read_sensor function.

After the threads have finished, I acquire a lock on the shared data using the Mutex and iterate over the collected sensor readings to print them.

This code example demonstrates how Rust ensures memory safety through the use of a Mutex to protect shared data, allowing for safe concurrent access.

The ownership model and borrowing rules in Rust prevent multiple threads from unexpectedly modifying or accessing the same memory concurrently, effectively preventing data races.

Conclusion

Rust is a game-changer in the field of industrial automation.

Its memory safety and concurrency features address the challenges faced by traditional languages, ensuring the reliability, security, and efficiency of industrial automation systems.

By adopting Rust, we can minimize risks, eliminate common vulnerabilities, and build software that operates smoothly and securely in complex industrial environments.

Along with industrial automation, there are many other use cases where Rust can be used to develop Robust software solutions such as IoT, Embedded, Robotics, etc.

Powering Embedded Systems Development with Rust

Chetan Mittal — Thu, 18 May 2023 12:38:10 +0000

Introduction

Embedded systems development requires a delicate balance between performance, reliability, and safety.

With the rise of complex and interconnected devices, developers face numerous challenges in creating robust solutions. Enter Rust, a systems programming language renowned for its memory safety, concurrency, and expressive syntax.

In this article, we will explore how Rust's unique features, including zero-cost abstractions and low-level control, empower developers to overcome the intricacies of embedded systems development and build resilient and trustworthy solutions.

The Need for Robust Embedded Systems

Embedded systems are at the heart of countless modern devices, from smartphones to industrial machinery.

These systems operate in resource-constrained environments, demand high performance, and often require real-time responsiveness.

Additionally, they must exhibit fault tolerance and be resilient to hardware failures.

Such requirements necessitate a programming language that combines efficiency with safety.

Rust's Memory Safety and Concurrency Guarantees

Rust's strong emphasis on memory safety helps eliminate a significant class of bugs that plague embedded systems development, such as null pointer dereferences, buffer overflows, and data races.

The ownership and borrowing system of Rust ensures that memory safety is enforced at compile-time without the need for garbage collection.

This characteristic not only enhances the reliability of embedded systems but also simplifies the development process by catching potential issues early on.

Zero-Cost Abstractions and Performance Optimization

Embedded systems demand efficient resource utilization, making performance optimization crucial.

Rust's zero-cost abstractions enable developers to write high-level, expressive code without incurring any runtime overhead.

The language achieves this by minimizing abstractions during compilation, ensuring that the resulting machine code matches the performance of hand-written low-level code.

This capability enables developers to strike a balance between productivity and performance, creating efficient embedded systems without sacrificing safety.

Low-Level Control and Hardware Interfacing

Embedded systems often require low-level control to interact with hardware directly.

Rust's features, such as raw pointers and inline assembly, provide developers with the necessary tools to interface with devices at the hardware level.

Additionally, Rust's support for writing device drivers and accessing registers through safe abstractions simplifies the process of hardware interaction, reducing the potential for bugs and vulnerabilities.

Building Trustworthy Embedded Systems

Reliability and safety are paramount in embedded systems. Rust's strict compiler checks and static analysis tools, combined with its expressive type system, contribute to building trustworthy solutions.

The language's ability to detect and prevent undefined behavior, memory leaks, and data races at compile-time significantly reduces the risk of runtime errors in embedded systems, ultimately increasing their resilience and dependability.

Conclusion

Rust empowers developers in the field of embedded systems development by providing a unique combination of memory safety, concurrency guarantees, zero-cost abstractions, and low-level control.

Its ability to create efficient, reliable, and trustworthy solutions makes Rust an ideal choice for building complex embedded systems and also other systems in various use cases such as IoT solutions, Robotics, etc.

By embracing Rust, developers can unlock the language's power and harness its features to overcome the challenges of embedded systems development, delivering innovative and robust solutions for the future.

Unleashing the Power of Rust in Robotics: Security and Real-Time Excellence

Chetan Mittal — Sun, 14 May 2023 10:25:28 +0000

Introduction

In recent years, the field of robotics has witnessed remarkable advancements, with autonomous systems becoming increasingly prevalent in various industries.

As robotics technology continues to evolve, the choice of a programming language becomes crucial in ensuring safety, reliability, and real-time performance.

In this article, we will explore how Rust, with its exceptional safety guarantees and real-time capabilities, is revolutionizing the world of robotics.

We will discuss the benefits that Rust brings to robotic systems and how it empowers developers to create advanced autonomous machines.

Safety: A Paramount Concern in Robotics

When it comes to robotics, safety is of utmost importance. Autonomous systems operate in dynamic environments, interacting with humans and physical objects.

Any failure or error in their operation can have severe consequences.

Rust, a systems programming language, was explicitly designed to address safety concerns.

Its unique set of features and principles make it an ideal choice for building robust and reliable robotic systems.

Memory Safety

One of Rust's standout features is its strict memory safety guarantees.

Rust's ownership model and borrow checker ensure memory safety by preventing common programming errors such as null pointer dereferences, data races, and memory leaks.

By eliminating these risks at compile-time, Rust significantly reduces the probability of runtime crashes and vulnerabilities, making robotic systems more dependable and resilient.

There are many other use cases where Rust's memory safety features are really valuable in building scalable and robust solutions.

Error Handling

In robotics, errors are inevitable. Faulty sensor readings, unexpected environmental conditions, or communication failures can all lead to errors during runtime.

Rust's powerful error handling mechanisms, built on the concept of "Result" and "Option" types, enable developers to handle errors explicitly and gracefully.

This approach promotes fault tolerance, allowing robotic systems to recover from failures and continue operation even in challenging situations.

Concurrency and Parallelism

Robotic systems often require concurrent and parallel processing to handle multiple sensors, actuators, and decision-making tasks simultaneously.

Rust provides excellent support for concurrent programming through its ownership model and lightweight thread abstraction, allowing developers to write concurrent code that is safe and free from data races.

Furthermore, Rust's "async/await" syntax and "futures" library facilitates efficient and scalable asynchronous programming, essential for real-time applications in robotics.

Real-Time Capabilities: Empowering Autonomous Systems

Many robotics applications demand real-time responsiveness, where actions and decisions must be executed within strict time constraints.

Real-time capabilities are crucial for tasks such as controlling robots in dynamic environments, processing sensor data, and coordinating multi-agent systems.

Rust, combined with appropriate real-time frameworks and libraries, offers a compelling solution for building performant and deterministic robotic systems.

Predictable Performance

Rust's emphasis on control over system resources and its ability to eliminate runtime overhead allows developers to achieve predictable performance in robotic applications.

By minimizing unnecessary abstractions and providing low-level control, Rust enables fine-grained optimization and efficient resource utilization.

This predictability ensures that robots can meet stringent timing requirements, enabling them to operate reliably in time-sensitive scenarios.

Real-Time Operating Systems (RTOS) Integration

To fully leverage real-time capabilities, Rust can seamlessly integrate with real-time operating systems (RTOS) commonly used in robotics.

RTOS provides deterministic scheduling and resource management, critical for time-critical applications.

Rust's minimal runtime and compatibility with bare metal programming allow developers to write low-level code directly targeting specific hardware or RTOS environments, opening doors to real-time robotics with Rust.

Ecosystem and Tooling

The Rust ecosystem offers a wide range of libraries and frameworks that cater specifically to real-time and embedded systems.

Libraries like rust-rtic and embassy provide real-time task scheduling and hardware abstraction, while frameworks like smoltcp offer low-level networking capabilities.

These libraries and frameworks, combined with Rust's safety guarantees, enable developers to build complex robotic systems with real-time requirements efficiently.

Furthermore, Rust's rich tooling ecosystem enhances the development process for robotics.

The Cargo package manager simplifies dependency management and facilitates code reuse.

The Rust compiler's error messages are renowned for their clarity, helping developers identify and fix issues quickly.

Additionally, tools like the Rust Analyzer provide powerful IDE support, ensuring a smooth and productive development experience.

Advanced Autonomous Systems: Unleashing the Potential

With Rust's safety guarantees and real-time capabilities, developers can unlock the full potential of advanced autonomous systems.

Rust empowers robotics engineers to tackle complex challenges and build sophisticated robots that push the boundaries of innovation.

Perception and Sensor Fusion

Perception is a fundamental aspect of autonomous systems.

Robots rely on sensor data from cameras, lidars, radars, and other sensors to understand their environment.

Rust's safety guarantees and performance characteristics make it an excellent choice for implementing perception algorithms.

Rust's memory safety ensures that sensor data processing is robust and free from memory-related errors, while its performance characteristics allow for efficient and real-time sensor fusion, enabling robots to make accurate and timely decisions based on comprehensive environmental understanding.

Planning and Control

Autonomous robots must navigate through dynamic and uncertain environments, making real-time decisions for path planning and control.

Rust's safety guarantees and concurrency support make it well-suited for implementing planning and control algorithms.

Developers can leverage Rust's strong type system and expressive syntax to build complex decision-making systems while ensuring safety and reliability.

Rust's ability to handle concurrent and parallel tasks enables efficient coordination of sensor data processing, path planning, and control loops, ensuring smooth and responsive robot behavior.

Human-Robot Interaction

As robots become increasingly integrated into human-centric environments, ensuring safe and intuitive human-robot interaction is crucial.

Rust's safety guarantees provide confidence in the reliability and security of the underlying systems.

By leveraging Rust's error-handling mechanisms and concurrency support, developers can implement robust communication protocols and interfaces that facilitate seamless and safe interaction between robots and humans.

Example

Let me walk you through a small working code example in Rust that showcases a simple robotic system:

// Example code demonstrating a simple robotic system in Rust

// Define a Robot struct
struct Robot {
    name: String,
}

impl Robot {
    // Method to perform an action
    fn perform_action(&self, action: &str) {
        println!("{} is performing action: {}", self.name, action);
    }
}

// Main function
fn main() {
    // Create a new Robot instance
    let robot = Robot {
        name: String::from("Rusty"),
    };

    // Perform an action
    robot.perform_action("Move forward");
}

In this example, I have a Robot struct representing our robot. It contains a field called name to store the name of the robot. Within the impl block, I define a method called perform_action() that enables the robot to execute various actions.

To see the code in action, I create a new instance of the Robot struct named Rusty within the main() function. I then call the perform_action() method on the Rusty robot, providing the action "Move forward". This simulates the robot performing the action of moving forward.

When you run the code, it will print the message "Rusty is performing action: Move forward" to the console, indicating that the robot named Rusty is executing the action of moving forward.

This example provides a basic understanding of how you can structure a robotic system in Rust.

However, in real-world scenarios, the codebase would typically be more intricate, encompassing additional functionality and interactions among various components of the robotic system.

Conclusion

Rust's safety guarantees and real-time capabilities make it a game-changer in the field of robotics.

By providing memory safety, error handling, concurrency support, and integration with real-time systems, Rust empowers developers to build advanced autonomous systems that are reliable, performant, and safe.

Embracing Rust in robotics development opens up exciting possibilities and paves the way for the next generation of autonomous machines.

The power of Rust Lang shines in developing solutions for hardware-constrained environments such as IOT solutions, Embedded Systems, etc.

Rust's safety guarantees and real-time capabilities make it a game-changer in the field of robotics

Chetan Mittal — Sun, 14 May 2023 10:25:28 +0000

Introduction

In recent years, the field of robotics has witnessed remarkable advancements, with autonomous systems becoming increasingly prevalent in various industries.

As robotics technology continues to evolve, the choice of a programming language becomes crucial in ensuring safety, reliability, and real-time performance.

In this article, we will explore how Rust, with its exceptional safety guarantees and real-time capabilities, is revolutionizing the world of robotics.

We will discuss the benefits that Rust brings to robotic systems and how it empowers developers to create advanced autonomous machines.

Safety: A Paramount Concern in Robotics

When it comes to robotics, safety is of utmost importance. Autonomous systems operate in dynamic environments, interacting with humans and physical objects.

Any failure or error in their operation can have severe consequences.

Rust, a systems programming language, was explicitly designed to address safety concerns.

Its unique set of features and principles make it an ideal choice for building robust and reliable robotic systems.

Memory Safety

One of Rust's standout features is its strict memory safety guarantees.

Rust's ownership model and borrow checker ensure memory safety by preventing common programming errors such as null pointer dereferences, data races, and memory leaks.

By eliminating these risks at compile-time, Rust significantly reduces the probability of runtime crashes and vulnerabilities, making robotic systems more dependable and resilient.

There are many other use cases where Rust's memory safety features are really valuable in building scalable and robust solutions.

Error Handling

In robotics, errors are inevitable. Faulty sensor readings, unexpected environmental conditions, or communication failures can all lead to errors during runtime.

Rust's powerful error handling mechanisms, built on the concept of "Result" and "Option" types, enable developers to handle errors explicitly and gracefully.

This approach promotes fault tolerance, allowing robotic systems to recover from failures and continue operation even in challenging situations.

Concurrency and Parallelism

Robotic systems often require concurrent and parallel processing to handle multiple sensors, actuators, and decision-making tasks simultaneously.

Furthermore, Rust's "async/await" syntax and "futures" library facilitates efficient and scalable asynchronous programming, essential for real-time applications in robotics.

Real-Time Capabilities: Empowering Autonomous Systems

Many robotics applications demand real-time responsiveness, where actions and decisions must be executed within strict time constraints.

Real-time capabilities are crucial for tasks such as controlling robots in dynamic environments, processing sensor data, and coordinating multi-agent systems.

Rust, combined with appropriate real-time frameworks and libraries, offers a compelling solution for building performant and deterministic robotic systems.

Predictable Performance

Rust's emphasis on control over system resources and its ability to eliminate runtime overhead allows developers to achieve predictable performance in robotic applications.

By minimizing unnecessary abstractions and providing low-level control, Rust enables fine-grained optimization and efficient resource utilization.

This predictability ensures that robots can meet stringent timing requirements, enabling them to operate reliably in time-sensitive scenarios.

Real-Time Operating Systems (RTOS) Integration

To fully leverage real-time capabilities, Rust can seamlessly integrate with real-time operating systems (RTOS) commonly used in robotics.

RTOS provides deterministic scheduling and resource management, critical for time-critical applications.

Ecosystem and Tooling

The Rust ecosystem offers a wide range of libraries and frameworks that cater specifically to real-time and embedded systems.

Libraries like rust-rtic and embassy provide real-time task scheduling and hardware abstraction, while frameworks like smoltcp offer low-level networking capabilities.

These libraries and frameworks, combined with Rust's safety guarantees, enable developers to build complex robotic systems with real-time requirements efficiently.

Furthermore, Rust's rich tooling ecosystem enhances the development process for robotics.

The Cargo package manager simplifies dependency management and facilitates code reuse.

The Rust compiler's error messages are renowned for their clarity, helping developers identify and fix issues quickly.

Additionally, tools like the Rust Analyzer provide powerful IDE support, ensuring a smooth and productive development experience.

Advanced Autonomous Systems: Unleashing the Potential

With Rust's safety guarantees and real-time capabilities, developers can unlock the full potential of advanced autonomous systems.

Rust empowers robotics engineers to tackle complex challenges and build sophisticated robots that push the boundaries of innovation.

Perception and Sensor Fusion

Perception is a fundamental aspect of autonomous systems.

Robots rely on sensor data from cameras, lidars, radars, and other sensors to understand their environment.

Rust's safety guarantees and performance characteristics make it an excellent choice for implementing perception algorithms.

Planning and Control

Autonomous robots must navigate through dynamic and uncertain environments, making real-time decisions for path planning and control.

Rust's safety guarantees and concurrency support make it well-suited for implementing planning and control algorithms.

Developers can leverage Rust's strong type system and expressive syntax to build complex decision-making systems while ensuring safety and reliability.

Rust's ability to handle concurrent and parallel tasks enables efficient coordination of sensor data processing, path planning, and control loops, ensuring smooth and responsive robot behavior.

Human-Robot Interaction

As robots become increasingly integrated into human-centric environments, ensuring safe and intuitive human-robot interaction is crucial.

Rust's safety guarantees provide confidence in the reliability and security of the underlying systems.

Conclusion

Rust's safety guarantees and real-time capabilities make it a game-changer in the field of robotics.

Embracing Rust in robotics development opens up exciting possibilities and paves the way for the next generation of autonomous machines.

The power of Rust Lang shines in developing solutions for hardware-constrained environments such as IOT solutions, etc.

Disclaimer: Human Edited, AI Generated.

Build Effective IoT Solutions by Unlocking the Power of Rust Lang

Chetan Mittal — Thu, 11 May 2023 07:11:59 +0000

In IoT solutions, where there is a need to connect countless devices and to make them communicate with each other, security and efficiency are a necessity.

As IoT continues to expand and transform various industries, the choice of a programming language becomes crucial in ensuring the development of secure and efficient solutions.

This is where Rust shines as a type-safe software programming language providing us with many features such as memory safety, etc.

Rust Lang emerges as an excellent choice for building cutting-edge IoT solutions that deliver enhanced security and efficiency.

In this blog post, we will explore how Rust's unique features make it a game-changer in the world of IoT solutions development.

The Importance of Memory Safety in IoT Solutions

Memory safety lies at the heart of developing secure IoT solutions.

Vulnerabilities arising from memory-related errors, such as buffer overflows and data races, can leave IoT devices susceptible to hacking and compromise.

Rust's ownership model and strict borrowing rules ensure memory safety by preventing common programming errors, effectively eliminating the risk of memory-related vulnerabilities.

This robust memory safety feature acts as a robust defense mechanism in the IoT landscape, making Rust an ideal software programming language choice for developing secure IoT solutions and many other use cases such as Robotics, etc.

Performance Optimization for Efficient IoT Solutions

In addition to security, efficiency is also a critical aspect of IoT solutions development.

IoT devices often operate under resource-constrained environments, demanding optimal performance and minimal resource utilization.

Rust Lang's emphasis on zero-cost abstractions and fine-grained control over system resources enables developers to write code that runs with exceptional efficiency.

By eliminating runtime overhead, Rust allows IoT devices to perform at their maximum potential, ensuring a smooth and seamless user experience.

Safe Concurrency and Parallelism

IoT systems often require concurrent execution and parallel processing to handle multiple tasks simultaneously.

Rust's ownership model, coupled with its robust concurrency primitives , enables developers to write safe, concurrent code without the risk of data races or other synchronization issues.

Rust software programming language's lightweight threads, known as "async/await" , facilitate efficient and streamlined handling of concurrent operations, making it an ideal choice for IoT systems and solutions development that demand high-performance parallel processing.

Easy Integration with Existing Codebases

For IoT solutions, it is crucial to integrate with existing codebases and libraries to leverage existing functionalities and reduce development time.

Rust Lang's interoperability with C and C++ allows developers to seamlessly integrate Rust components with existing codebases, leveraging the strengths of both languages.

This unique capability empowers developers to enhance the security and efficiency of IoT solutions without the need for a complete overhaul, making Rust an excellent choice for both greenfield and legacy IoT projects.

Conclusion

When it comes to developing secure and efficient IoT solutions, the choice of programming language plays a pivotal role.

Rust Lang's unrivaled focus on memory safety and performance makes it an excellent choice for IoT solutions development.

Embrace the power of Rust for developing IoT solutions along with building solutions In Rust Lang for multiple use cases as well such as Embedded Systems, Robotics, Industrial Automation, Automobiles, AR/VR, Machine Learning, Gaming, etc.

Disclaimer: Human Edited and AI Generated.

How to Build Effective IoT Solutions by Unlocking the Power of Rust Lang?

Chetan Mittal — Thu, 11 May 2023 07:11:59 +0000

In IoT solutions, where there is a need to connect countless devices and to make them communicate with each other, security and efficiency are a necessity.

As IoT continues to expand and transform various industries, the choice of a programming language becomes crucial in ensuring the development of secure and efficient solutions.

This is where Rust shines as a type-safe software programming language providing us with many features such as memory safety, etc.

Rust Lang emerges as an excellent choice for building cutting-edge IoT solutions that deliver enhanced security and efficiency.

In this blog post, we will explore how Rust's unique features make it a game-changer in the world of IoT solutions development.

The Importance of Memory Safety in IoT Solutions

Memory safety lies at the heart of developing secure IoT solutions.

Vulnerabilities arising from memory-related errors, such as buffer overflows and data races, can leave IoT devices susceptible to hacking and compromise.

Rust's ownership model and strict borrowing rules ensure memory safety by preventing common programming errors, effectively eliminating the risk of memory-related vulnerabilities.

Performance Optimization for Efficient IoT Solutions

In addition to security, efficiency is also a critical aspect of IoT solutions development.

IoT devices often operate under resource-constrained environments, demanding optimal performance and minimal resource utilization.

Rust Lang's emphasis on zero-cost abstractions and fine-grained control over system resources enables developers to write code that runs with exceptional efficiency.

By eliminating runtime overhead, Rust allows IoT devices to perform at their maximum potential, ensuring a smooth and seamless user experience.

Safe Concurrency and Parallelism

IoT systems often require concurrent execution and parallel processing to handle multiple tasks simultaneously.

Rust's ownership model, coupled with its robust concurrency primitives , enables developers to write safe, concurrent code without the risk of data races or other synchronization issues.

Easy Integration with Existing Codebases

For IoT solutions, it is crucial to integrate with existing codebases and libraries to leverage existing functionalities and reduce development time.

Rust Lang's interoperability with C and C++ allows developers to seamlessly integrate Rust components with existing codebases, leveraging the strengths of both languages.

Conclusion

When it comes to developing secure and efficient IoT solutions, the choice of programming language plays a pivotal role.

Rust Lang's unrivaled focus on memory safety and performance makes it an excellent choice for IoT solutions development.

Top 50 Best Practices to Follow while Building Web Applications in NodeJS

Chetan Mittal — Sat, 06 May 2023 07:59:07 +0000

A majority of the web applications were developed in PERL, PHP, ASP, and other frameworks such as Ruby on Rails before the introduction of NodeJS.

Launched in 2009 by a Ruby developer, Ryan Dahl, to execute Javascript code outside the browser, NodeJS gained instant popularity and quick adoption by developers to develop server-side applications in Javascript.

I have listed the top 50 NodeJS web development best practices , such as best practices for NodeJS app security, etc, and have also explained in brief detail the 5 must-follow best practices for NodeJS web application development.

Which are the Top 50 Best Practices for Developing NodeJS Projects?

Below are the top 50 best practices which you can follow during your NodeJS web application development:-

Follow modular programming principles and write modular code by using the CommonJS module pattern.
Use a package manager like npm to manage dependencies.
Use environment variables to store sensitive information such as API keys and database credentials.
Use a linter like ESLint to maintain code quality and consistency.
Use a logging framework like Winston or Bunyan to log application events and errors.
Use a configuration management system like nconf or dotenv to manage application configurations.
Use a testing framework like Mocha or Jest to write and run tests.
Use a code coverage tool like Istanbul to track code coverage.
Use a debugging tool like Node Inspector or Chrome DevTools to debug your code.
Use a profiling tool like Node-Prof or Clinic.js to identify performance bottlenecks.
Use a caching framework like Redis or Memcached to cache frequently accessed data.
Use a load balancer like Nginx or HAProxy to distribute incoming requests.
Use a reverse proxy like Nginx or Apache to serve static files.
Use a secure socket layer (SSL) certificate to secure communication with clients.
Use a content delivery network (CDN) like CloudFlare to serve static assets.
Use compression middleware like Gzip to reduce the size of HTTP responses.
Use rate-limiting middleware like Express Rate Limit to protect against DDoS attacks.
Use a web application firewall like ModSecurity to protect against common web attacks.
Use an API gateway like Kong or Apigee to manage API traffic and security.
Use a message queue like RabbitMQ or Kafka for asynchronous communication between services.
Use a process manager like PM2 to manage Node.js processes in production.
Use an error monitoring tool like Sentry or Rollbar to track and analyze application errors.
Use a performance monitoring tool like Scout APM to monitor and optimize application performance in production.
Use a containerization platform like Docker to package and deploy applications.
Use a single responsibility principle (SRP) to ensure that each module or function is responsible for a single task.
Use dependency injection to make modules more reusable and easier to test.
Use middleware to handle cross-cutting concerns like authentication and logging.
Use promises or async/await syntax to write asynchronous code in a more readable and manageable way.
Use the Event-Driven Architecture (EDA) pattern to build highly scalable and loosely coupled systems.
Use the Circuit Breaker pattern to prevent cascading failures and improve the fault tolerance of your system.
Use a database connection pool to manage database connections efficiently.
Use a session store like Redis or MongoDB to store session data in a scalable way.
Use an object-relational mapping (ORM) framework like Sequelize or TypeORM to interact with the database.
Use a schema validation library like Joi or Yup to validate incoming data and prevent injection attacks.
Use a task queue like Bull or Bee-Queue to handle background jobs and offload work from the main thread.
Use a process manager like systemd or PM2 to ensure that your application restarts automatically in case of a crash.
Use a security auditing tool like Node Security Platform or Snyk to scan for vulnerabilities in your dependencies.
Use a static code analysis tool like SonarQube to identify and fix issues in your code.
Use a Continuous Integration/Continuous Deployment (CI/CD) pipeline to automate the deployment process and ensure a consistent and reliable release process.
Use a monitoring and alerting system like Prometheus or Grafana to monitor application performance and send alerts in case of issues.
Use a distributed tracing system like Jaeger or Zipkin to track and analyze requests across multiple services.
Use a Content Security Policy (CSP) to mitigate the risk of cross-site scripting (XSS) attacks.
Use a JSON Web Token (JWT) for authentication and authorization.
Use a load-testing tool like Artillery or k6 to simulate heavy traffic and stress-test your application, identifying performance issues and ensuring that your application can handle a high volume of requests.
Use the Strategy design pattern to decouple authentication and authorization logic from your application logic.
Use the Node.js Cluster module to take advantage of multi-core CPUs, improving performance by creating multiple child processes that share the same server port.
Use the Node.js Buffer module to handle binary data efficiently, improving performance when working with large files or streams.
Use the Node.js Streams API to handle large amounts of data efficiently, avoiding unnecessary memory usage and improving performance.
Use the Node.js Event Loop to handle asynchronous operations efficiently, avoiding blocking code and improving performance.
Use the Node.js Crypto module to encrypt sensitive data like passwords, protecting them from unauthorized access.

Disclaimer: AI Generated and Human Edited

Glad to be using Ruby since 2005

Chetan Mittal — Thu, 13 Apr 2023 14:01:11 +0000

I randomly reached OCaml while searching some stuff on Google. I had heard of this software programming language before during my Uni days, however, I never learned and used it.

Maybe I picked up a scripting language TCL more quickly than some typed functional language OCaml.

Anyways, I thought it would be a good idea if I pick up OCaml today and try writing a simple program in it that I had written using Ruby earlier.

The Ruby program is very simple. It just goes to my blog by using open-uri gem and then just accesses the DOM by using nokogiri gem, and then just iterates through all the img tags and prints their URLs with alt-text on the console. Here it is:-

require 'nokogiri'
require 'open-uri'

url = 'https://blog.chetanmittaldev.com/'

html = URI.open(url)
doc = Nokogiri::HTML(html)

image_count = 0

doc.css('img').each do |img|
  image_count += 1
  puts "#{img['alt']}: #{img['src']}"
end

puts "Total images: #{image_count}"

The above code just prints all the image links with their alt-texts from my blog as shown below:-

There are a total of 38 images as of before publishing this blog post.

The same code to write in OCaml; first it is pretty hard to find in its documentation which library does what; second, configuring a program's compile build with libraries is such a pain.

And, third, each time I installed a library using its package manager called opam, which doesn't even try to find, fetch, and install a package's dependencies if the package you are installing hasn't been updated for a long time, I had to run two commands $ opam user-setup install and $ eval 'opam config env' that configure and evaluate respectively the OCaml environment I guess.

Anyways, I asked ChatGPT to generate a program in OCaml from my Ruby code and it generated some non-working code below:-

open Nethttp_client.Convenience
open Tyxml.Xml

let url = "https://blog.chetanmittaldev.com/"

let () =
  let conn = new Nethttp_client.connection url in
  let html = http_get conn in
  let doc = parse_string html in

  let image_count = ref 0 in

  List.iter (fun img ->
    incr image_count;
    let name = attrib img "alt" in
    let url = attrib img "src" in
    Printf.printf "%s: %s\n" name url
  ) (children (List.hd (children doc)));

  Printf.printf "Total images: %d\n" !image_count

I used OCaml's build system called dune to generate a new project structure as below:-

Then I configured my dune build file with the required libraries, and wrote some code:-

(executable
 (public_name scrape)
 (name main)
 (libraries netclient curl lwt)
 (preprocess (pps lwt_ppx)))

Oh, I forgot to mention, I spent a few hours, finding "how to install OCaml", and then installing it on my EndeavourOS.

And, when I tried to build or compile my OCaml code by running $ dune build then I got these errors as below:-

Hmm, I tried installing the curl package for OCaml:-

$ opam install curl

The package was "NOT FOUND". Amazing, right? curl is not available.

What can I say, the whole ecosystem of OCaml is not right if it doesn't have the curl package and ChatGPT writes OCaml programs using it.

The Ruby software programming language is the best for me. Just 12 lines of code to scrape my blog. I am happy. Python and Javascript are equally good. Easy to read and write.

How to Easy Install Odoo 16 on Ubuntu 22.04 hosted on a Digitalocean Droplet

Chetan Mittal — Tue, 11 Apr 2023 06:22:27 +0000

Odoo, previously known as OpenERP, is one of the earlier open-source ERP systems launched in 2008 by Belgian software programmer Fabien Pinckaers.

Fabien started developing an ERP system, TinyERP, based on Python in 2005 which was later renamed to OpenERP in 2008 and then later renamed to Odoo in 2014.

I experienced OpenERP for the first time in mid-2010 when I needed to install it for a client of mine who was in the business of wine manufacturing in Italy. This client of mine had many of his business friends and competitors using OpenERP at the time.

I still remember marketing India-based ERPNext to the client but she was really interested in getting OpenERP for her business. ERPNext lacked many features at that time and didn't have a nice responsive UI.

Since then both ERPNext and Odoo have grown into full-fledged ERP systems competing with SAP, and the like.

The only thing I don't like about Odoo is that it is not 100% Open Source like ERPNext. I would always prefer using ERPNext myself over Odoo because I get almost all the features Odoo Enterprise has in ERPNext for free.

However, it is always a personal choice to pick one software over the other.

Let us move on to installing Odoo on Ubuntu 22.04 hosted on a Digitalocean droplet:-

Preparation

The very first thing we will do is to create a new droplet on Digitalocean. If you already have an account on Digitalocean then just open it in a new browser window and login into your account.

If you are new to Digitalocean then I would recommend you to sign up on it as it is the best VPS provider with a nice and easy dashboard to manage and monitor your virtual servers, also called droplets.

Create new droplet

Once you are inside your account dashboard on Digitalocean then just hit the "Create" button and select "Droplet" from the dropdown as shown in the image below:-

For this step-by-step guide, to installing Odoo version 16 on Ubuntu 22.04 LTS on a Digitalicean droplet, I will create a droplet in my Digitalocean account and then later delete it once the guide is complete.

On the "Create Droplet" page you can configure your virtual server. I usually recommend using a regular droplet with 4GB RAM, however, for this guide I will use a regular droplet with 2GB RAM and a SWAP of 4GB.

First, select the region where you want Digitalocean to host your server. I usually select either Bangalore or Singapore because these 2 locations are closest to me.

Second, select Ubuntu 22.04 LTS as the operating system for your droplet. I usually pick the LTS version of Ubuntu for the server because it receives updates for a long time of 5 years.

Third, select the size of the droplet. I usually select a "Basic" and "Regular" server with 4GB of RAM, however, for this guide we will go for a 2GB RAM droplet as shown in the image below:-

Fourth, add your SSH public key to access the server using Putty if you are on Windows or by simply running ssh username@-your-server-ip-address- on your Terminal, if you are on Linux or Mac.

Finally, we will hit the "Create Droplet" button to create our 2GB virtual server with Ubuntu 22.04 LTS on Digitalocean to install Odoo 16.

You can add tags to your droplet if you have many droplets and you need to differentiate this one from the others for an easy search. And, also change the hostname provided by Digitalocean by default. I just leave it as it is.

Next move on to the next step which is installing preliminary software such as Python, etc. required to install Odoo on Ubuntu.

Login to your droplet using SSH

Once your droplet is created then login into it using ssh root@-your-droplet-ip-address- as shown in the image below:-

Before installing software from scratch on my droplets I usually prefer creating a SWAP image of twice the size of server RAM to be on the safe side just in case some software process needs more memory power to execute.

Create a SWAP image of 4GB for your droplet

Follow the guide here to add swap: https://www.digitalocean.com/community/tutorials/how-to-add-swap-space-on-ubuntu-22-04.

Verify if you already have a SWAP by running free -h on your server:-

As you can see we don't have any SWAP image as yet. Let's create one.

Create a 4GB SWAP image by running the commands as shown below along with images:-

$ sudo fallocate -l 4G /swapfile

$ ls -lh /swapfile

$ sudo chmod 600 /swapfile

$ ls -lh /swapfile

$ sudo mkswap /swapfile

$ sudo swapon /swapfile

$ sudo swapon --show

$ free -h

$ sudo cp /etc/fstab /etc/fstab.bak

$ echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

You can also tune your SWAP image by updating its values of "Swappiness" and "Cache Pressure".

Update and Upgrade your Ubuntu Server Droplet

First, let us check if your server is on Ubuntu 22.04 or not by running the following command inside your server's terminal.

$ lsb_release -a

Once we have confirmed that our server is running Ubuntu 22.04 update your server by running:-

$ sudo apt update && sudo apt upgrade

After your server update, reboot it and then log in again.

$ reboot

$ ssh root@-your-droplet-ip-address-

Add a System User to Install Odoo 16 on your Ubuntu 22.04 Server Droplet

$ sudo useradd -m -d /opt/odoo16 -U -r -s /bin/bash odoo16

Install Software Dependencies for Odoo 16

$ sudo apt install build-essential wget git python3-pip python3-dev python3-venv python3-wheel libfreetype6-dev libxml2-dev libzip-dev libsasl2-dev python3-setuptools libjpeg-dev zlib1g-dev libpq-dev libxslt1-dev libldap2-dev libtiff5-dev libopenjp2-7-dev

Install PostgreSQL Database

$ sudo apt install PostgreSQL

Add the system user odoo16 we created earlier to the PostgreSQL database to manage our Odoo 16 database:-

$ sudo su - postgres -c "createuser -s odoo16"

Install wkhtmltopdf for generating PDFs such as Invoices

$ sudo apt install wkhtmltopdf

Now, our Ubuntu 22.04 droplet is created, configured, and prepared to install Odoo 16. Let's install it next.

Install Odoo 16

The default software installer in Ubuntu 22.04 installs Odoo 14 but we need to install Odoo 16, right? As we already know Odoo is built using Python software programming language thus let us install Odoo version 16 by using a feature in Python called "Virtual Environment".

To do this you will need to login into your system by logging in using the system user odoo16 we created earlier:-

$ sudo su - odoo16

Once you are logged in using odoo16 system user, you will need to download Odoo16 software from its Github repo located at https://www.github.com/odoo/odoo.

$ git clone https://www.github.com/odoo/odoo --depth 1 --branch 16.0 odoo16

Now, create a new Python Virtual Environment inside which we will run Odoo 16:-

$ python3 -m venv odoo16-venv

Once you have your Python Virtual Environment for Odoo 16 installed you will need to activate it:-

$ source odoo16-venv/bin/activate

Finally, let us move ahead with installing Odoo 16. Run the following:-

(odoo16-venv) odoo16@ubuntu-s-1vcpu-2gb-blr1-01:~$ pip3 install wheel

(odoo16-venv) odoo16@ubuntu-s-1vcpu-2gb-blr1-01:~$ pip3 install -r odoo16/requirements.txt

If the above steps have run successfully on your Ubuntu 22.04 server to install Odoo 16 then you need to deactivate your Python Virtual Environment:-

(odoo16-venv) odoo16@ubuntu-s-1vcpu-2gb-blr1-01:~$ deactivate

Next, you can create a custom-addons folder inside the /opt directory at the exact location /opt/odoo16/odoo16/custom-addons for Odoo 16 installation to access any custom addons you will use if any.

$ mkdir /opt/odoo16/odoo16/custom-addons

Logout from the odoo16 system user:-

$ exit

Configure Odoo 16

Now, you will need to configure your Odoo 16 to make it run.

Create Odoo 16 config file

Open the Odoo 16 config file using a text editor such as nano:-

$ sudo nano /etc/odoo16.conf

Paste the following inside the file:-

[options]
admin_passwd = passW0rd
db_host = False
db_port = False
db_user = odoo16
db_password = False
addons_path = /opt/odoo16/odoo16/addons,/opt/odoo16/odoo16/custom-addons
xmlrpc_port = 8069

You can change the admin_password above as per your likeliness, however, passW0rd is easy to remember for me for this guide. This is your Odoo 16's master password which you will need to create or delete databases.

Create a systemd unit file for your Odoo 16

$ sudo nano /etc/systemd/system/odoo16.service

Paste the following inside the file:-

[Unit]
Description=Odoo16
Requires=postgresql.service
After=network.target postgresql.service

[Service]
Type=simple
SyslogIdentifier=odoo16
PermissionsStartOnly=true
User=odoo16
Group=odoo16
ExecStart=/opt/odoo16/odoo16-venv/bin/python3 /opt/odoo16/odoo16/odoo-bin -c /etc/odoo16.conf
StandardOutput=journal+console

[Install]
WantedBy=multi-user.target

Hurray! Your Odoo 16 is now ready to run. Let's run it.

Run your Odoo 16 server

Run to reload the Odoo 16 server with the above configuration:-

$ sudo systemctl daemon-reload

Now, start the Odoo 16 server:-

$ sudo systemctl start odoo16

If you want to see the status of the Odoo 16 server then you can run:-

$ sudo systemctl status odoo16

Below is the screenshot of the Odoo 16 server running on my droplet created above:-

Below are the details I filled in to create my first database on my Odoo 16 server. I hope you can fill the same, just replace my master password (the one you entered in the /etc/odoo16.conf config previously), username, email, phone, and country with yours:-

After creating the database successfully you will see a login page as below. Here, you will enter your email id and password (filled above):-

After successful login, you will see your Odoo 16 Dashboard. I am using demo data so my dashboard might look different than yours.

You can see in the image above, the very first time you will log in you will see a dashboard listing multiple applications for you to install inside your Odoo 16 database. I installed the "CRM" application on my instance as seen in the above image.

Note:- You can create and delete many databases in a single Odoo 16 instance. You can consider a database as a separate company or business.

Install NGINX for Setting up Reverse Proxy

If you are using it for internal use then accessing it through http://IP\_address:Port would also be fine, however, you won't be able to make use of HTTPS leaving your private company data accessible to hackers.

I would recommend you use a domain name (a subdomain would be fine too e.g. erp.your_domain_name.com) to use HTTPS and make your Odoo 16 server more secure.

Install NGINX Web Server

For this you will need a Web Server either Apache or NGINX and then make it run your Odoo 16 server behind a proxy. I prefer NGINX. Login to your droplet using SSH and run the following command to install NGINX.

$ sudo apt -y install nginx

Once NGINX is installed successfully, open your droplet's IP address in your browser. You will see a page with a message saying, "Welcome to nginx!".

As the droplet being used for this guide will be deleted thus I won't be configuring any domain on it, however, for the instructions below I will use the "-your-domain-name-" placeholder. You can replace it with your real domain name while setting up your production Odoo 16 server.

Setup your Odoo 16 Server with NGINX Web Server

To set up your Odoo 16 server with NGINX you will need to create an NGINX site and then enable it with some configuration.

As you can see in the image below we only have 1 NGINX site enabled default that shows the HTML page which says, "Welcome to nginx!".

Now, create an NGINX site for your Odoo 16 server:-

$ sudo nano /etc/nginx/sites-enabled/-your-domain-name-.com

And, paste the following config in it before saving:-

upstream odoo16 {
server 127.0.0.1:8069;
}

upstream odoochat {
server 127.0.0.1:8072;
}

server {
listen 80;
server_name -your-domain-name-.com;

access_log /var/log/nginx/odoo.access.log;
error_log /var/log/nginx/odoo.error.log;

proxy_buffers 16 64k;
proxy_buffer_size 128k;

location / {
     proxy_pass http://odoo16;
     proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504;
     proxy_redirect off;
     proxy_set_header Host $host;
     proxy_set_header X-Real-IP $remote_addr;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     proxy_set_header X-Forwarded-Proto https;
     }

location /longpolling {
     proxy_pass http://odoochat;
     }

location ~* /web/static/ {
     proxy_cache_valid 200 60m;
     proxy_buffering on;
     expires 864000;
     proxy_pass http://odoo16;
     }
}

Save the file and reload your NGINX server:-

$ sudo systemctl restart nginx

Access your Odoo 16 Server on -your-domain-name-.com

Voila, now you can access your Odoo 16 server on -your-domain-name-.com and start maintaining your company data.

Remember, the Open Source version (Community Edition) of Odoo doesn't have as many features as the Paid version (Enterprise Edition).

The downside is that Odoo Accounting App doesn't even allow you to maintain Journals and Ledgers in its Open Source version.

I personally prefer ERPNext.

If you want to set up HTTPS on your Odoo 16 server running on -your-domain-name-.com then you can follow this article on Digitalocean on how to configure SSL for NGINX on Ubuntu 22.04 by using Letsencrypt.

If you seem to find something not working for you then let me know in the comments below.

WebAssembly reminds me of Java Applets and Macromedia Flash

Chetan Mittal — Sat, 08 Apr 2023 11:45:36 +0000

Rust programming language is meant to write software for low-powered hardware devices, the majority of which include IOT devices, embedded devices such as industrial machines, robotic devices, etc.

WebAssembly is a virtual machine (a software program) that is inbuilt into modern browsers, such as Chrome, Firefox, Safari, Edge, etc., to download and execute a binary file(s) (a compiled software program specified in the <script> tag in your HTML file) inside the browser.

A majority of WASM software programs are written in the Rust programming language. Though these can be written in C/C++ and Ruby-Lang too.

See the diagram below:-

WASM binary files are included in the HTML files the same way Javascript files are included inside a to tell your browser that there is a web-assembly file that it needs to download and execute.</p> <script src="mymodule.wasm">

Unlike Javascript which is interpreted on the run, from the source file, without any compiling; WASM binaries are pre-compiled files meant for fast execution and safety.

Java Applets and Adobe Flash were the same, a software program pre-compiled into a binary file running within the browser.

And similar to WASM binaries needing a software program in the browser to get downloaded and executed, both the Java Applets and Adobe Flash needed a browser plugin to get downloaded and executed within the browser.

https://steveklabnik.com/writing/is-webassembly-the-return-of-java-applets-flash

During my early days in software programming, I built a few websites based on Java Applets and I seriously remember the nightmares I used to have while debugging those.

https://stackoverflow.com/questions/868111/how-do-you-debug-java-applets

In 2023, I use either Ruby or JavaScript for building software applications, using VIM and Visual Studio Code, and both programming languages are really easy to debug on the fly than C/C++ and Java, and Rust.

I wouldn't definitely want to go back to the old days of having debugging nightmares and waiting hours while my Rust or C/C++ files for WASM are getting compiled.

https://media.giphy.com/media/tXL4FHPSnVJ0A/giphy.gif

I would say, using WASM would make more sense than JavaScript only where there is a need for a CPU-intensive software program execution because of being written in Rust and compiled.

The best examples could be:-

Games inside the browser
Image, audio, and video editing inside the browser
Machine learning computations inside the browser
Etc

Do you have any other examples where WASM could be used best? Please comment.

How to Easy Install ERPNext 14 on Ubuntu 22.04 LTS on Digitalocean Droplet

Chetan Mittal — Fri, 07 Apr 2023 06:18:55 +0000

ERPnext is a 100% open source and FREE Enterprise Resource Planning software developed and maintained by a FOSS-promoting company, Frappe Technologies Pvt. Ltd., based out of India's financial capital Mumbai.

ERPNext is the best among FREE ERPs available in 2023 such as Dolibarr, Odoo, etc. In 2018, ERPNext was rated among the top 5 user-friendly ERP systems by Gartner, surpassing Microsoft, SAP, Bexio, and several other ERP systems.

ERPNext is available as a self-hosted software for your small to medium business to install on your own servers helping you to maintain your data privacy without paying a dime for the licensing fee (except the server costs).

However, it is not easy for non-technical users to get the hang of it.

My ERPNext installation guide below is an easy-to-follow set of instructions helping you to easily install ERPNext version 14 on a 4GB droplet hosting Ubuntu 22.04 LTS.

Let's get started:-

Create a new droplet on Digitalocean with Ubuntu 22.04

Signup for a new account or log in to your already existing account on Digitalocean.

Once you are on the "projects" page of your Digitalocean account, click on the green "Create" button on the top right and select "droplet" from the dropdown. This will take you to the "Create Droplets" page.

On the "Create Droplet" page you can configure your server by following the instructions on this page such as:-

Your server's data center: I usually pick Bengaluru or Singapore because those are the nearest to my location.
An operating system image for your server: I usually prefer the latest Ubuntu LTS. Currently, the LTS version of Ubuntu is 22.04.
The CPU size for your server: I usually pick Basic and Regular with 4GB RAM for a new ERPNext installation. I would recommend a minimum RAM for ERPNext of 2GB with 4GB SWAP.

After you have configured the server add your SSH key for easy access to your server from your PC.

If you are on Windows then you can use Putty to access your server else you can simply run ssh root@-your-droplet-ip-address on your Linux terminal or Mac Command.

Finally, hit the "Create Droplet" button to create a new server for your ERPNext 14 installation.

Install all the preliminary software required to install Frappe and ERPNext

To install Frappe and ERPNext we need to install a few essential software such as gcc, python, mariadb, etc.

Follow the instructions below:-

Login to your server from your PC for easy access. As I use ArchLinux thus I just have to open a Terminal window and then just ssh into my server.

Replace my server's IP address with your droplet's IP address. Note:- I will ~~delete~~ my server post-publishing this article.

$ssh root@-your-droplet-ip-address

Add SWAP to your server

Though 4GB RAM is enough for an ERPNext instance, however, just in case there might be a RAM-eating process so to keep our instance running it would be nice to have some SWAP.

I usually prefer a SWAP of 2x of your server RAM but you can add a 4GB swap too to save disk space.

Follow the guide here to add swap: https://www.digitalocean.com/community/tutorials/how-to-add-swap-space-on-ubuntu-22-04.

Verify if you already have a SWAP:-

Create an 8GB SWAP:-

Make your SWAP permanent so that when you restart your server then also you will have your SWAP.

Adjust or tune your SWAP settings swappiness and vfs_cache_pressure:-

Update your server and install the LOCALES

$ sudo apt update

$ sudo apt upgrade

After you have completely upgraded your Ubuntu 22.04 server, then you can install LOCALES which are required by ERPNext.

$ sudo localectl set-keymap us && sudo localectl set-locale LANG=en_US.utf8

Note:- If you get an error Failed to set keymap: Keymap us is not installed. then you can follow the instructions given at https://www.claudiokuenzler.com/blog/1257/how-to-fix-missing-keymaps-debian-ubuntu-localectl-failed-read-list to resolve this error and continue with installing ERPNext 14.

$ sudo nano /etc/environment (and copy-paste the following at the bottom of the file after $PATH)

##############

LC_ALL=en_US.UTF-8

LC_CTYPE=en_US.UTF-8

LANG=en_US.UTF-8

Now, reboot your server for the locales and server updates.

$ sudo reboot

Install the NGINX HTTP server

$ sudo apt install nginx (and test by opening your-droplet-ip-address in a browser window)

The below section is optional, however, if you want to access your ERPNext instance using HTTPS://DOMAIN_NAME then you must follow these optional instructions.

OPTIONAL

Install certbot (ubuntu 20.04 doesnt support certbot-auto required by erpnextfrappe-bench thus we will use snap to install certbot classic to generate SSL certificates manually using lets-encrypt).

$ sudo service nginx stop

$ sudo snap install --classic certbot

Generate a lets-encrypt SSL certificate for your domain name(s) - the certificate will be saved under -your-domain-name-folder-name- at /etc/letsencrypt/live

$ sudo certbot certonly --standalone (your domain name(s) will be asked here)

$ sudo service nginx start

OPTIONAL ENDS

Install the MySQL database server

$ sudo apt install mariadb-server

$ sudo apt install python3-mysqldb libmysqlclient-dev

$ sudo mysql_secure_installation

$ sudo systemctl stop mariadb

$ sudo nano /etc/mysql/mariadb.conf.d/mariadb.cnf (and copy-paste the following to save file)

https://gist.github.com/chetanmittaldev/28ea822b9815feac891d2c809f8d2598

Restart the MySQL server:-

$ sudo systemctl start mariadb

$ sudo systemctl enable mariadb

Install the Ubuntu packages required for Python3, etc.

$ sudo DEBIAN_FRONTEND=noninteractive apt install -y curl build-essential python3-testresources python3-setuptools python3-dev libffi-dev python3-pip libcurl4 dnsmasq fontconfig git htop libcrypto++-dev libfreetype6-dev liblcms2-dev libwebp-dev libxext6 libxrender1 libxslt1-dev libxslt1.1 libffi-dev ntpdate postfix python3-dev python-tk screen vim xfonts-75dpi xfonts-base zlib1g-dev apt-transport-https libsasl2-dev libldap2-dev libcups2-dev pv libjpeg8-dev libtiff5-dev tcl8.6-dev tk8.6-dev libdate-manip-perl logwatch

Add a system user 'frappe' to install ERPNext

Add user 'frappe' with password 'password' by running the commands below in your terminal:-

$ adduser frappe

$ usermod -aG sudo frappe

$ rsync --archive --chown=frappe:frappe ~/.ssh /home/frappe/

Create your MySQL database

Add a MySQL database 'frappe' with user 'frappe' and password 'password' by running the commands below:-

$ mysql

$ MariaDB [(none)]> CREATE DATABASE frappe;

$ MariaDB [(none)]> SHOW DATABASES;

$ MariaDB [(none)]> GRANT ALL PRIVILEGES ON . TO 'frappe'@'%' IDENTIFIED BY 'password' WITH GRANT OPTION;

$ MariaDB [(none)]> SELECT host, user, Super_priv FROM mysql.user;

$ MariaDB [(none)]> FLUSH PRIVILEGES;

$ MariaDB [(none)]> exit

SSH into your server using the 'frappe' user in a new console or terminal window

$ ssh frappe@-your-droplet-ip-address

Install some python3-based packages such as setuptools, etc

$ sudo -H python3 -m pip install --upgrade setuptools cryptography psutil

Install wkhtmltopdf

install wkhtmltopdf as erpnext12 requires 0.12.5 version (i am not sure about erpnext13 or erpnext14 but installed just in case):-

$ cd /tmp

$ wget https://github.com/wkhtmltopdf/wkhtmltopdf/releases/download/0.12.5/wkhtmltox_0.12.5-1.bionic_amd64.deb

Now, wkhtmltopdf needs libssl1.1 package which is not available on Ubuntu 22.04 LTS thus we will add the packages repo for Ubuntu 20.04 and then install libssl1.1 from there:-

$ echo "deb http://security.ubuntu.com/ubuntu focal-security main" | sudo tee /etc/apt/sources.list.d/focal-security.list

$ sudo apt-get update

$ sudo apt-get install libssl1.1

$ sudo dpkg -i wkhtmltox_0.12.5-1.bionic_amd64.deb

$ sudo cp /usr/local/bin/wkhtmlto* /usr/bin/

$ cd ~

$ sudo chmod a+x /usr/bin/wk*

$ sudo rm /etc/apt/sources.list.d/focal-security.list

Install the Redis Cache Server

$ sudo apt install git python-dev-is-python3 python3-dev redis-server

$ sudo apt-get install software-properties-common

$ sudo apt-get install xvfb libfontconfig wkhtmltopdf

$ sudo systemctl enable redis-server

Install nodejs by using NVM

$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash

$ sudo reboot (required to run nvm command)

SSH into 'frappe' user again

$ nvm install --lts (install the LTS version of NodeJS; currently, it is v18.15.0)

$ npm install -g yarn

Verify nodejs, npm, yarn installations:-

$ yarn --version

$ npm -v

$ node -v

Lets summarize what we have accomplished so far. Up to this point, you have installed all the major components required by ERPNext 14, which include:-

Nginx
Certbot
SSL Certificate Generate
Python3
MariaDB DB
Nodejs, NPM
The Yarn package manager
A Redis database cache
The wkhtmltopdf PDF documents generator

Whether you are installing the ERP system for development or for production, you are now ready for the next step, which is installing the Frappe full-stack framework and the actual ERPNext 14 web application.

Install the Frappe full-stack web framework and ERPNext web application

SSH 'frappe' system user in a new console or terminal window:-

$ ssh frappe@-your-droplet-ip-address

Install bench (Installing Frappe Bench CLI)

$ cd ~

$ sudo chown frappe -R /home/frappe

$ sudo pip3 install frappe-bench

$ bench --version

$ sudo apt install python3.10-venv

$ bench init frappe-bench

$ cd frappe-bench

$ echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p

$ ./env/bin/pip install numpy && ./env/bin/pip install pandas

Upgrade pip

$ /home/frappe/frappe-bench/env/bin/python -m pip install --upgrade pip

Install bench apps

$ bench get-app erpnext

Add a new site to the bench

$ bench new-site -your-domain-name-or-droplet-ip-address- --admin-password -your-admin-password- --mariadb-root-username frappe --mariadb-root-password 'password'

Install bench app to bench site

$ bench --site -your-domain-name-or-droplet-ip-address- install-app erpnext

Test bench on port 8000

$ bench start

Open a new browser window and open -your-domain-name-or-droplet-ip-address-:8000 to test:-

Setup production server using NGINX for your ERPNext instance

SSH your server using 'frappe' user in a new console or terminal window:-

$ ssh frappe@-your-droplet-ip-address

$ cd /home/frappe/frappe-bench

$ sudo bench setup production frappe --yes

Verify if the required services work on your server:-

$ sudo supervisorctl stop all

$ sudo supervisorctl start all

$ systemctl list-unit-files | grep 'fail2ban|nginx|supervisor'

After confirming that everything is working as expected, you can test ERPNext 14 live on your server.

Open your favorite browser and navigate to -your-domain-name-or-droplet-ip-address-, or wherever you are hosting your ERPNext 14 application.

After a few seconds, you should see the ERPNext 14 login screen.

Use Administrator for the username (email) and the erpnext_admin_password you created previously for the password.

The NGINX conf file is saved in the path below:-

$ sudo nano /etc/nginx/conf.d/frappe-bench.conf

Add HTTPS

$ sudo -H bench setup add-domain -your-cname-domain-name-

$ sudo -H bench setup nginx

$ sudo service nginx reload

Turn on multi-tenancy for HTTPS to work:-

$ sudo -H bench config dns_multitenant on

$ sudo -H bench setup nginx

$ sudo service nginx reload

Add SSL certificate (lets-encrypt) to bench site (install HTTPS on apex domain) - frappe-bench uses the same path /etc/letsencrypt/live to get SSL certificates:-

$ sudo -H bench setup lets-encrypt -your-domain-name-or-droplet-ip-address- custom-domain -your-cname-domain-name-

$ sudo -H bench setup nginx

$ sudo service nginx reload {or $ sudo service nginx start}

Start using ERPNext

Open -your-domain-name-or-droplet-ip-address- in a browser window.

Known Issues

WARN Cannot connect to redis_cache to update assets_json during bench init then you can follow the instructions at https://discuss.frappe.io/t/issue-w-redis-during-bench-init-step/87134.
Bench runs fine on port 8000, however, during production it doesn't run. This might be due to the redis-server not being run on port 11000. To fix this open file sudo nano /etc/redis/redis.conf and change the port to 11000. Do not forget to reload the redis-server again. Follow the instructions at https://linuxhint.com/change-default-port-redis/.

Any issues then comment

If you face any issues then please comment, and I will try to rectify them.