DEV Community: Irfan

Working with Rust as a C++ Programmer

Irfan — Fri, 12 May 2023 04:02:05 +0000

Rust is a modern programming language that is quickly gaining popularity. It is known for its safety, speed, and expressiveness. Many C++ programmers are finding that Rust is a great language to learn, as it offers many advantages over C++.

In this post, we will discuss the similarities and differences between Rust and C++, and we will provide some tips for C++ programmers learning Rust.

Introduction
Rust is a multi-paradigm, general-purpose programming language designed for performance and safety, especially safe concurrency. Rust is syntactically similar to C++, but can guarantee memory safety by using a borrow checker to validate references.

Similarities between Rust and C++
There are many similarities between Rust and C++. Both languages are statically typed, compiled languages that support object-oriented programming. Rust also supports many of the same features as C++, such as pointers, arrays, and functions.

Here are some of the similarities between Rust and C++:

Syntax: Rust's syntax is very similar to C++. Both languages use curly braces to group statements, and both languages have similar keywords.

Ownership and borrowing: Rust's ownership and borrowing system is similar to C++'s memory management system. In both languages, it is important to manage the lifetime of objects carefully to avoid memory leaks.

Memory management: Rust uses a borrow checker to manage memory safety. The borrow checker ensures that references to objects are always valid, and that objects are never destroyed while they are still in use.

Generics: Rust supports generics, which allow you to write code that can be used with different types of data.
Traits: Rust supports traits, which are similar to C++'s interfaces. Traits allow you to define a set of methods that a type must implement.

Function pointers: Rust supports function pointers, which are similar to C++'s function pointers. Function pointers allow you to pass functions as arguments to other functions.

Lambdas: Rust supports lambdas, which are similar to C++'s lambdas. Lambdas allow you to create anonymous functions that can be passed as arguments to other functions.

Differences between Rust and C++
There are also some important differences between Rust and C++. These differences include:

Safety: Rust is a much safer language than C++. Rust's borrow checker ensures that references to objects are always valid, and that objects are never destroyed while they are still in use. This helps to prevent many common programming errors, such as dangling pointers and memory leaks.

Concurrency: Rust has a very powerful concurrency model that is designed to be safe and easy to use. Rust's concurrency model is based on the concept of ownership and borrowing. This allows you to write concurrent code that is safe and easy to understand.

Modules: Rust's modules system is much more powerful than C++'s namespace system. Rust's modules system allows you to organize your code into logical units, and it makes it easy to import and export symbols from different modules.

Cargo: Rust has a build system called Cargo that makes it easy to manage Rust projects. Cargo can automatically download and build dependencies, and it can also publish your projects to crates.io, which is a central repository for Rust crates.

C++ programmers learning Rust
If you are a C++ programmer who is interested in learning Rust, here are some tips:

Focus on the similarities first. Rust and C++ have many similarities, so it is helpful to focus on these similarities when you are first learning Rust.
Don't try to learn everything at once. Rust is a complex language, so it is important to take your time and learn one thing at a time.
Use the Rustonomicon as a reference. The Rustonomicon is a comprehensive reference for Rust. It is a great resource for learning about Rust's features and syntax.
Ask for help in the Rust community. The Rust community is very welcoming and helpful. If you have any questions, don't hesitate to ask for help on the Rust subreddit or the Rust forum.

I hope this post has been helpful. If you are a C++ programmer who is interested in learning Rust, I encourage you to give it a try. Rust is a powerful and expressive language that can be used for a wide variety of tasks.

What is new in C++20?

Irfan — Thu, 12 Jan 2023 17:45:19 +0000

C++20 is the latest version of the C++ programming language, which was officially standardized in December 2019. It includes a number of new features and improvements over previous versions of the language. Some of the most notable changes include:

Concepts: C++20 introduces a new feature called "concepts", which are a way to express constraints on template arguments. Concepts allow for more expressive type checking and improved error messages when using templates. Here's an example of how you might use a concept in C++20:

template<typename T>
concept Addable = requires(T a, T b) {
  { a + b } -> T;
};

template<Addable T>
T add(T a, T b) {
  return a + b;
}

In this example, the Addable concept is defined to require that the type T can be added to another value of the same type (i.e., it has a + operator). The add function is then defined to take two arguments of type T, where T is constrained by the Addable concept.

Coroutines: C++20 introduces support for "coroutines", which are a way to write asynchronous code in a more synchronous style. Coroutines allow you to write code that can be paused and resumed, similar to how a generator works in Python. Here's an example of how you might use coroutines to asynchronously read from a file:

std::fstream file("example.txt");
std::string buffer;

co_await file.async_read_some(std::addressof(buffer), buffer.size());

Modules: C++20 introduces "modules", which are a way to organize code in a more modular fashion. Modules allow you to group related declarations (e.g., functions, classes, variables) together and make them available to other parts of your code. They are similar to headers but faster to compile and more powerful.

export module my_module;

export int x = 1;

export void func() {
  std::cout << "Hello, World!" << std::endl;
}

Ranges: C++20 introduces a new library for working with ranges of values, called the "ranges library". The ranges library provides a set of algorithms and views for working with ranges of values in a more functional style. Here's an example of how you might use the ranges library to filter and transform a range of integers:

std::vector<int> v {1,2,3,4,5};
auto rng = v | std::views::filter([] (int i) { return i % 2 == 0; })
            | std::views::transform([] (int i) { return i * 2; });
std::cout<<*rng.begin(); // Outputs 8

This is just a small sampling of the new features in C++20, and there are many more improvements and changes in the language. C++20 provide more expressive and powerful tools for C++ Developers and make the language a more modern and powerful one.

Fundaments of a payment gateway

Irfan — Tue, 10 Jan 2023 05:36:20 +0000

Introduction:

A payment gateway is a system that enables merchants to accept payments from customers through various channels, such as credit and debit cards, bank transfers, and digital wallets. It serves as the intermediary between the merchant and the customer's bank, facilitating the authorization, capture, and settlement of transactions. In this post, we will discuss the key considerations and components of a payment gateway system, as well as some best practices for designing an efficient and scalable solution.

Key Components of a Payment Gateway System:

Payment Gateway API: This is the interface through which merchants can integrate their websites or mobile applications with the payment gateway. It allows them to initiate transactions, check the status of transactions, and receive notification of transaction events. The API should be secure, well-documented, and easy to use.

Payment Processor: This component is responsible for communicating with the customer's bank and obtaining authorization for the transaction. It also handles the capture and settlement of the transaction, transferring the funds from the customer's bank to the merchant's account.

Fraud Detection: A payment gateway system should have robust fraud detection capabilities to protect merchants and customers from fraudulent transactions. This can include techniques such as machine learning algorithms, IP address and device fingerprinting, and velocity checks.

Reporting and Analytics: A payment gateway system should provide merchants with valuable insights into their payment activity, such as transaction volumes, conversion rates, and revenue trends. This can be achieved through a dashboard or through APIs that allow merchants to extract data for analysis.

Scalability and Availability: A payment gateway system should be able to handle large volumes of traffic and transactions without experiencing downtime or performance issues. This requires a robust architecture that can scale up or down as needed, as well as robust failover and disaster recovery mechanisms.

Design Considerations:

Security: Ensuring the security of transactions and sensitive customer data is a top priority for any payment gateway system. This involves implementing strong encryption and authentication protocols, as well as complying with industry security standards such as PCI DSS.

Integration: The payment gateway system should be easy to integrate with a variety of platforms and frameworks, such as e-commerce platforms, mobile apps, and point-of-sale systems. This can be achieved through APIs and SDKs that provide a seamless integration experience.

User Experience: A smooth and intuitive user experience is essential for improving conversion rates and customer satisfaction. This includes designing a simple and intuitive checkout flow, as well as providing a range of payment options to suit different customer preferences.

Internationalization: If the payment gateway system is intended to serve a global market, it should support multiple currencies, languages, and payment methods. This requires integration with a variety of local and international payment processors and banks.

Compliance: Payment gateway systems must adhere to a range of legal and regulatory requirements, such as anti-money laundering laws and data protection regulations. This requires careful planning and compliance monitoring to ensure that the system operates within the bounds of the law.

Conclusion:

A payment gateway system plays a critical role in facilitating online and mobile payments for merchants. By considering key components and design considerations, it is possible to build a system that is efficient, scalable, and secure.

How to set Python3 as a default python version on MacOS?

Irfan — Wed, 04 Dec 2019 06:28:36 +0000

By default MacOS ships with Python-2.-. But, I guess most of us have long back started to work with Python-3 and it is very irritating to run python3 every time instead of python in terminal. Here is how to do this.

Open the terminal (bash or zsh) whatever shell you are using.

Install python-3 using Homebrew (https://brew.sh).

brew install python

Look where it is installed.

ls -l /usr/local/bin/python*

The output is something like this:

lrwxr-xr-x  1 irfan  admin  34 Nov 11 16:32 /usr/local/bin/python3 -> ../Cellar/python/3.7.5/bin/python3
lrwxr-xr-x  1 irfan  admin  41 Nov 11 16:32 /usr/local/bin/python3-config -> ../Cellar/python/3.7.5/bin/python3-config
lrwxr-xr-x  1 irfan  admin  36 Nov 11 16:32 /usr/local/bin/python3.7 -> ../Cellar/python/3.7.5/bin/python3.7
lrwxr-xr-x  1 irfan  admin  43 Nov 11 16:32 /usr/local/bin/python3.7-config -> ../Cellar/python/3.7.5/bin/python3.7-config
lrwxr-xr-x  1 irfan  admin  37 Nov 11 16:32 /usr/local/bin/python3.7m -> ../Cellar/python/3.7.5/bin/python3.7m
lrwxr-xr-x  1 irfan  admin  44 Nov 11 16:32 /usr/local/bin/python3.7m-config -> ../Cellar/python/3.7.5/bin/python3.7m-config

Change the default python symlink to the version you want to use from above.
Note that, we only need to choose the one that end with python3.*. Please avoid using the ones' that end with config or python3.*m or python3.*m-config.

Below command shows how it should be done:

ln -s -f /usr/local/bin/python3.7 /usr/local/bin/python

Close the current terminal session or keep it that way and instead open a new terminal window (not tab). Run this:

python --version

You will get this:

Python 3.7.5

Hah! That's it. Happy coding!!

AWS integration with VS Code

Irfan — Thu, 28 Nov 2019 06:25:04 +0000

VS Code is the first choice of most of the developers today. From writing and debugging code to pushing it to GitHub, we can also deploy to cloud.

For example,

AWS has on official extension for VS Code (AWS Toolkit). It can be installed from the VS Code extension marketplace.

(Considering you have an AWS account)

First things first:

Install the extension.
Connect to AWS using your own ACCESS KEY.

(To get the access key, just login to the AWS console. Goto username on top, select 'My Security Credentials', then goto 'Access keys for CLI, SDK, & API access' section. Create a new access key if you don't have one.)

Go back to AWS click connect to aws, enter any unique name, then access key id and then secret access key.

You are done setting up the extension!

It offers following services:

Develop serverless applications locally and then deploy them to an AWS account.
Listing and deleting AWS CloudFormation stacks.
Listing and invoking AWS Lambda functions.
Select any region from the region explorer.

To use the toolkit for developing serverless applications on AWS, you need to have following things installed locally:

AWS CLI
AWS SAM CLI
Docker

That is it!

C++ Template Meta Programming - The Basics

Irfan — Fri, 12 Jul 2019 04:07:52 +0000

Template Meta-programming is a generic programming technique that uses extremely early binding to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled.
In order to completely understand why we need Template Programming, let's go back to Function Overloading.

Function overloading is somewhat tedious, because we have to essentially repeat the same code for each function but with different variable and parameter types. However, there is a way of avoiding this. There's a possibility of creating a recipe that will enable the compiler to automatically generate functions with various parameter types. The code defining the recipe for generating a particular group of functions is called a function template.

A function template has one or more type parameters , and we generate a particular function by passing a concrete type argument for each of the template's parameters. Thus, the functions generated by a function template all have the same basic code, but customized by the type arguments that we pass.

We will write an example using both function overloading and function template, that finds the largest element from an array.

int max(int max[], const int& len){
    int maximum(x[0]);
    for(int i = 0; i < len; ++i){
       if(maximum < x[i]) maximum = x[i];
    }
    return maximum;
}  

long max(long max[], const int& len){
    long maximum(x[0]);
    for(int i = 0; i < len; ++i){
       if(maximum < x[i]) maximum = x[i];
    }
    return maximum;
} 

double max(int max[], const int& len){
    double maximum(x[0]);
    for(int i = 0; i < len; ++i){
       if(maximum < x[i]) maximum = x[i];
    }
    return maximum;
}

The above example shows the three versions of one function using function overloading. We see that we have to repeat the same code for each version of the function.

Now let's define a function template for the same function max().

template<class T> T max(T x[], const int& len){
    T maximum(x[0]);
    for(int i = 0; i < len; ++i){
       if(maximum < x[i]) maximum = x[i];
    }
    return maximum;   
}

The template keyword identifies this as a template definition. The angled brackets following the template keyword enclose the type parameters that are used to create a particular instance of the function separated by commas. In this instance we have one type parameter, T. The class keyword before the T indicates that the T is the type parameter for this template, class being the generic term for the type. Consequently, we have fundamental types in C++, such as type int and type char, and we also have types that we define. We can use the keyword typename instead of class to identify the parameters in a function template, in which case, the template definition would look like this:

template<typename T> T max(T x[], const int& len){
    T maximum(x[0]);
    for(int i = 0; i < len; ++i){
       if(maximum < x[i]) maximum = x[i];
    }
    return maximum;   
}

The creation of a particular function instance is referred to as instantiation . Each time we use max() in our program, the compiler checks to see if a function corresponding to the type of arguments that we have used in the function call already exists. If the function required does not exist, the compiler creates one by substituting the argument type that we have used in our function call in place of the parameter T throughout the template definition.

Here's a full working example of function template.

#include <iostream>
#include <cstdlib>

template<typename T> T max(T x[], const int& len){
    T maximum(x[0]);
    for(int i = 0; i < len; ++i){
       if(maximum < x[i]) maximum = x[i];
    }
    return maximum;   
}

int main(){

int small[] = {1, 24, 34, 22};
long medium[] = {23, 245, 123, 1, 234, 2345};
double large[] = {23.0, 1.4, 2.456, 345.5, 12.0, 21.0};

int lenSmall(_countof(small)); //_countof() works only on MSVC.
int lenMedium(_countof(medium));
int lenLarge(_countof(large));

std::cout << max(small, lenSmall) << "\n";
std::cout << max(medium, lenMedium) << "\n";
std::cout << max(large, lenLarge) << "\n";

return 0;
}

Examples:

Output :

34

2345

345.5

For each of the statements that output the maximum value in an array, a new version of max() is instantiated using the template. Of course, if you add another statement calling the function max() with one of the types used previously, no new version of the template code is generated.

Using the template doesn't reduce the size of your compiled program in any way. The compiler generates a version of the source code for each unique function that is required. In fact, using templates can generally increase the size of our programs, as functions may be created even though an existing version might satisfactorily be used by casting the argument. We can force the creation of particular instances of a template by explicitly including a declaration for it.

Template meta-programming allows the programmer to focus on architecture and delegate to the compiler the generation of any implementation required by client code. Thus, template meta-programming can accomplish truly generic code, facilitating code minimization and better maintainability.