DEV Community: Ashish Bailkeri

Calculate Your Code Performance

Ashish Bailkeri — Sat, 23 Oct 2021 15:40:36 +0000

Benchmarking your code is a very important step to maintaining good code. It does not particularly matter whether the language is "fast" or "slow" as each language has its target platform where it needs to do well.

JavaScript Benchmarking Code

In JavaScript there is a really simple way to measure the performance of your code and can be rally useful to test easily on the client side of your web browser.

Let's look at an example:



function reallyExpensiveFunction() {
  for (let i = 0; i < 10000; ++i) {
    console.log("Hi\n");
  }
}

console.time('reallyExpensiveFunction');
console.timeEnd('reallyExpensiveFunction');

We can bench our functions by using the function console.time to start and console.timeEnd to end our bench.

Here is an output you might get

You can try this example on repl-it.

C Benchmarking Code

Believe it or not, the same code in C is very similar to the JavaScript example.

Let's look at this example:



#include <stdio.h>
#include <time.h>

void really_expensive_function() {
  for (int i = 0; i < 10000; ++i) {
    printf("Hi\n");
  }
}

int main() {
  clock_t start = clock();
  really_expensive_function();
  clock_t end   = clock();
  printf("Took %f seconds\n", (((float)(end-start) / CLOCKS_PER_SEC)));
  return 0;
}

clock_t is a typedef for long on my machine and is likely the same for yours. Despite that, you should still use clock_t as it may be different on different machines. We get the system time before and after the really expensive function and are able to get the amount of time in seconds.

You can try this example on repl-it.

Here is an output you might get

Understanding the Reality

The examples are great for testing out small pieces of code but are not feasible for large code bases where complex benchmarking is necessary.

Complex Benchmarking

Profiling
- What does a profiler actually do? A program profile gives the developer the ability to be able to measure both space and time complexity of their functions in their program. This is particularly important if your program has a major bottleneck causing slowdowns, which is especially disastrous if it is a system where many requests are made. An example of such a tool is orbit which can visualize the performance points in your program.
Benchmarking IO Operations
- IO operations are ones that take in user input or read or write to system files, mainly requiring operations from the operating system kernel. These operations are usually the most expensive operations in your program. However, since time spent in system calls is not manageable by the programmer, it is best to reduce the amount of system calls that are made to improve performance.
Distributed Systems
- These systems are complicated and so it is necessary to make sure that the performance of the system is in check. In general this is because each computer is not entirely the same, and so it becomes difficult in order to assess performance accurately. Different computers have different CPUs, network sockets, and configurations and these computers interact with routers and other network systems that communicate with each other that impact the way performance is calculated. It is best to determine the performance of such systems in a way that gives relative benchmark, or a benchmark that is good enough for a team working on it to be able to assess the program.

Resources

JavaScript:
For JavaScript, there are already some good tools for benchmarking, most notable being Benchmark.js and Bench-Rest. Using these tools will allow you to be able to properly test the performance of your code. It is generally given that you want to use software already tested for acceptable benchmarking as the demos shown today are often trivial and may not give all the results you want.

C++:
C++ has quite a number of benchmarking libraries some of the recent ones involving C++ 20's flexibility. The most notable being Google Bench and UT. C does not have many specific benchmarking libraries, but you can easily integrate C code with C++ benchmarking libraries in order to test the performance of your C code.

Conclusion

In the end it's up to you how you choose to benchmark your code. Generally, you want to code your project before you benchmark it and if performance is really a concern then you can opt to use these benchmarking libraries or use a performance profile to find bottlenecks. I hope you learned something today :).

C++ Programming: Operator Overloading

Ashish Bailkeri — Sat, 23 Oct 2021 15:32:39 +0000

Operator overloading is one of the special features in C++ programming. The advantages of this feature is that it allows us to apply operators that logically make sense on our custom data structures. Let's how they can be used in real world applications.

Looking at the first use of operator overloading, we can see it in std::cout using the operator << that is overloaded to print values to our terminal. It is used as the following:

int main() {
  std::cout << "Hello, World!\n";
  //        ^^ <-- This is the overloaded operator
}

This is trivial, right? Most of us use it without giving it much thought, but it is important enough that overloading this operator for your own class allows std::cout to print user-defined classes.

A real world example

class CustomVector {
  float x;
  float y;
public:
  explicit CustomVector(float x, float y) : x(x), y(y) {}

  bool operator==(const CustomVector &vec) const {
    return this->x == vec.x && this->y == vec.y;
  }

  CustomVector operator+(const CustomVector &vec) const {
    return CustomVector(this->x + vec.x, this->y + vec.y);
  }
// ...
};

So let's breakdown what is actually going on here. We have a class called CustomVector and we give it the values of x and y, now what do we do with this? We don't want to continuously compare the their x values all the time, so what we do instead is create on operator overload for the == operator to do this for us.

Writing operator functions is as simple as writing a normal function with the difference in the function name being operator followed by a valid operator to overload. In fact, C++ will allow you to overload the new and delete keywords too, although this is not generally recommended.

Applying operators and using `std::cout`

After our implementation of the + operator, we can add this line:

friend std::ostream& operator<<(std::ostream& s, const CustomVector &vec);

If you don't know what friend functions or classes are, they allow functions and classes to access private variables of a given class.

Finally, we can add our implementation:

std::ostream& operator<<(std::ostream& s, const CustomVector &vec) {
  s << "{ x: " << vec.x << ", " << "y: " << vec.y << " }";
  return s;
}

Brief overview of the parameters shows that we take in an instant of the output stream and an instance of our custom class. Not so bad, right?

Checking our results

Now let's test our code to see it work in action:

int main() {
  CustomVector vec = CustomVector(1.0f, 1.0f);
  CustomVector vec2 = CustomVector(2.0f, 2.0f);

  if (vec == vec2) {
    std::cout << "They are equal\n";
  } else {
    std::cout << "They are not equal\n";
  }

  std::cout << "Vec 1: " << vec << "\n";
  std::cout << "Vec 2: " << vec2 << "\n";
  std::cout << "Vec 3: " << vec + vec2 << "\n";

  return 0;
}

This is what you should see when you run your code:

You can play around with this to get a better fell of it here.

Conclusion

Operator overloading can be confusing at times so it is best to take it slow when using this concept. Be sure to use this appropriately as to not write confusing code, and make sure that you allow flexibility in the classes you write. As with many things in C++, it is easy to shoot yourself in the foot when programming, so be careful. I hope you learned something today from this overview :)

C++ Programming: Implicit and Explicit Constructors

Ashish Bailkeri — Mon, 18 Oct 2021 15:48:34 +0000

Note: Any code snippets posted here are licensed under the MIT License.

Did you know that there are both implicit and explicit constructors?
Let's look into the difference between both, and what each can do for code readability and convivence when programming.

Explicit Constructors

You may see warnings in certain C++ compilers about making certain constructors explicit. But what does it mean? Let's look at an example of an explicit constructor:

class MyClass {
  int i;
  explicit MyClass(int i) : i(i) {}
}

// ...

int main() {
  MyClass clz = MyClass(2);
}

Looks pretty normal, right? So you might wonder what this actually does. You must initialize the value with the name of the type before it's initialization aka: MyClass then with the constructor parameters. You can see the difference in usability in the implicit constructor code.

Implicit Constructors

These constructors allow you to initialize a class value without specifying the name of the class. Let's look at an example:

class MyClass {
  int i;
  /*implicit*/ MyClass(int i) : i(i) {}
}

// ...

int main() {
  MyClass clz = 2;
}

Wait, is the class MyClass now the integer type? No. What actually happened was that the C++ compiler was able to tell that you were calling the MyClass constructor implicitly and allowed that conversion.

Every wondered why this code was legal?

std::string my_string = "Wow, this is cool!";

It's because there is an implicit constructor with std::string that takes in a const char * and thus allows this initialization to be valid.

Bringing It Together

In accordance with certain code writing standards, compilers or code analyzers may warn using implicit constructors, why? They do this because in general it is harder for another programmer to analyze code that uses implicit constructors because it is hard to pin point the type of the object being initialized.

Conclusion

Understanding implicit and explicit constructors will allow you to take in full control of how your code is read and how you use it. This is especially important to take note of if you are reviewing code, or reading code from a library. I hope you learned something today, and have good day!

Why Good Syntax Highlighting is Important

Ashish Bailkeri — Sun, 17 Oct 2021 18:30:11 +0000

All code snippets posted are under the MIT License

So does it really matter?

Yes. There good programming practices in certain programming languages but there is also good developing practices and this is one of them.

So what are the advantages?

Higher Productivity
- When programming with better syntax highlighting it becomes easier to identify where parts of your program is based on the color. With color schemes with limiting syntax highlighting on certain semantics, it can be really difficult to differentiate between what may be a parameter variable or a local variable, or in the case of C++, macros, enum values, global variables, etc.
Encourages you to code
- What do I mean by this? I mean that you actually feel more engaged looking at a theme bested suited to your programming style, for me, I prefer a diverse array of colors on my screen.

Let me show you what I mean:

Colorful Example:

Snippet from Jet.

What does this do well? It has a vast amount of colors that is easy to differentiate parts of the program immediately, it is not just about I have highlighting, but it really tries and brings out different parts of the program. I can easily point out macros, class variables, parameters, and functions almost instantly through this highlighting.
But for some, this might be overkill in colors, and you may prefer a softer tone.

Note: This is my opinion of course, but in general you should choose a theme that suits your programming style the best

Of course, this also depends on your editor's capability but other popular editors like Visual Studio Code, still provide support for semantic highlighting. But we can see clearly how this highlighting can improve the coder's experience and provides clarity.

Another Interesting Example:

This theme is known as Darcula, JetBrains's default dark theme syntax highlighting, and while it does the job, is less colorful. Important type values such as size_t don't have clear highlighting in this example and can easily be overlooked as they have a very similar color to the delimiter tokens. This is not say it isn't a good theme, it is, and is far better than editors with only keyword highlights. What does it do well? It has a far softer theme than the previous example, and still manages to highlight important parts of the program.

In general, good syntax highlighting themes needs to be able to have ways of identifying important parts of the program, and JetBrains's IDE's usually give the programmer enough flexibility to adjust their highlighting.

Disadvantages of Good Syntax Highlighting

Get lost in the sea of colors that is your code
- No? That's just me? Well let's move on then.

Conclusion

My opinion is this: the making of a good programmer is one that knows how to use the tools available today to further increase their skills, and this includes something as subtle as syntax highlighting and font choice. You don't have to stick with something like my syntax highlighting, rather you should find the one best suitable for you.

C++ Programming: Arena Allocation

Ashish Bailkeri — Sat, 16 Oct 2021 22:33:56 +0000

Hi Everyone, I'm going to starting a mini series of articles about C++ Programming concepts that you may be using in your projects. Today's topic is: Arena Allocation.

Code snippets and images posted in this article are under the MIT License

Edit: Some ambiguous information has been cleared up

Memory management is a pain, isn't it?

When working in garbage collected languages such as Java or Go, you may be mostly free from dealing closely with memory but in languages like C and C++, memory usually causes a lot of problems, especially since you have a lot of power to manipulate it.

So what's the best allocator?

There is no number 1 best allocator in every scenario, rather, if you wanted the best allocator, the programmer is the best allocator because they know exactly what the program will do and thus know the best way to allocate memory.

Arena Allocation

Instead of allocating pointers using malloc or new, we can create our own allocator known as the arena allocator.

This kind of allocation involves allocating a large chunk of memory before the logic of your program executes, for example, 20 GiB of memory. Wait, hold up, this sound completely unreasonable right? Yes, it is, but the operating system knows this too, so it allows overcommitting memory.

Linux Overcommit

Mac Overcommit

Windows Overcommit

NOTE: Windows doesn't have the same ability to overcommit memory, rather large amounts of memory can be reserved and then requested

When you have your large amount memory allocated, what do you do with it?

Generally the block of memory can be separated into chunks, known as a memory pool, and parts of the program may be assigned dedicated amounts of memory. This is the approach of a pool allocator.

For simplicity sake, a arena allocator is usually implemented with allocations done linearly.

Why would you use arena allocation?

Faster allocation
- A large block of memory is allocated as a huge chunk meaning that allocation is as simple as incrementing the amount of bytes that have been written
Cache efficiency
- With a large chunk of memory being allocated it is likely that values will be allocated in continuous memory
Almost no cost freeing
- In general, with a large chunk of memory that is allocated, you can free the memory all at once with almost no cost.

Disadvantages:

Arena allocation may not be the right for your use case. In most cases, if you do not see the user or your program using past a certain amount of memory, it is preferable to use alternative methods of allocation, and usually general purpose allocators are good enough.
Large amounts of memory allocated at the beginning of a program may go to waste if you choose this allocator to just get rid of memory handling issues. Arena allocation has its own specific use cases or areas where it is reasonable to use it like in Compiler Construction.

Create an allocator

Here is an extremely basic arena allocation setup:

The way this is setup is pretty generic, it allows me to create multiple allocators for different parts of my program.

If you wanted to distribute your memory instead of allocating it linearly, you could do as follows:

Part A of Program 5 GiB
Part B of Program 10 GiB
Part C of Program 5 GiB

This is how the large pool of memory can be distributed and is useful if you know which part allocates more memory.

Conclusion

Arena allocation is just another tool in the box that will help you advance your knowledge of low-level programming in C++. Be sure to understand how your specific program works before choosing this allocation method. Understanding allocators behind the scenes will help you in general for any kind of endeavor and I hope you learned something from this.

Jet: Programming Language that puts developers first.

Ashish Bailkeri — Wed, 06 Oct 2021 21:28:05 +0000

Hi Everyone!

I'm Ashish and this is my first post on the platform and I'm very excited to share my project Jet. This post is for updates and recent developments for the programming language I am developing.

About

If you have ever tried to develop an application, you know hard it is to get your app up and running on your desired platform, but even more exhausting to develop one for multiple platforms, especially when scrolling through piles of error messages. This is where Jet comes in to help. Jet seeks to provide the highest performance applications in both the Web and in Native environments while keeping the developer informed of what actually caused the error.

Understanding The Language

There is no need to discuss the entire language specifics here, but you can totally read about it on our Github.

What's new, and what's planned?

The language has had a variety of features planned and fine-tuned to create simple and flexible language.

Error Messages

One of Jet's main strengths are its error messages. When I first learned programming, they had a whole lesson teaching on how to interpret stack traces and error messages, this should not be how it works!

Error messages should be clear and explain to the programmer what they did wrong. Let's look at an example:

Here we get a clear reason as to the error, and we get the location to fix the problem. And yes, this is output on a Windows machine, your eyes do not deceive you. This is the output we get on all platforms Mac, Linux, and Windows.

If we look at the same error in C++, however, we get a nasty error message:

Along with some compiler gibberish, it doesn't even tell us where to fix the problem! This is not how programming languages should be designed. This is especially tricky if you are missing braces in a sequence of braces.

Let's have a look at another example:

Here we get a list of possible values that are acceptable and tell the programmer why the compiler errored out. In C++, we don't even get an error, worse, its designated as a warning which commonly overlooked and can lead to undefined behavior.

We take inspiration in our error messages from Rust and Elm to increase the productivity of the developer.

Updates

Jet has removed some extra features that do not sit well for the core language and has now made explicit grammar definitions for enums and a structures.

Compile-time code execution

Inspired by the Jai Programming Language by Johnathon Blow, we have based a lot of different principles in the language after that, including compile-time code execution.

does_something => () {
  return "Hi";
}
// ...
another_function => () {
  // Variable `some_value` evaluated at compile-time
  some_value := static {
    return does_something();
  }
}

Code Generation

Jet's current state is in the midst of type-checking and C Programming Language code generation. However, we don't intend to solely rely on C, there is x64 Backend in its testing phase too.

JavaScript code generation is also on high priority after the C backend, as we want Jet code to get up and running on the web as soon as possible. In order to keep up with those who dislike manual memory management, smart pointers are already planned to be implemented in the near future which will translate well into JavaScript code generation.

Web Development

In order to live up to expectations, web development is in the works, too. A complete web project consists not just of JavaScript files and other programming language build files may be necessary, so Jet is keen on generating complete projects that interact with every aspect to launching existing code on the web.

Conclusion

Jet is planned to have close to 90% of features to be implemented and tested with code generation within the next year, and hopefully begins its user-base testing in the Spring of 2022.

I would love any feedback that is to be given on the language, and contributions are always made welcome, and are really helpful too!
Make sure to star the repo and watch it for updates as they present themselves on Github, and I hope to give you another update in the future.

Thank you for your time!

DEV Community: Ashish Bailkeri

Calculate Your Code Performance

JavaScript Benchmarking Code

Here is an output you might get

C Benchmarking Code

Here is an output you might get

Understanding the Reality

Complex Benchmarking

Resources

Conclusion

C++ Programming: Operator Overloading

A real world example

Applying operators and using std::cout

Checking our results

Conclusion

C++ Programming: Implicit and Explicit Constructors

Explicit Constructors

Implicit Constructors

Bringing It Together

Conclusion

Why Good Syntax Highlighting is Important

So does it really matter?

So what are the advantages?

Disadvantages of Good Syntax Highlighting

Conclusion

C++ Programming: Arena Allocation

Memory management is a pain, isn't it?

So what's the best allocator?

Arena Allocation

Linux Overcommit

Mac Overcommit

Windows Overcommit

When you have your large amount memory allocated, what do you do with it?

Why would you use arena allocation?

Create an allocator

Conclusion

Jet: Programming Language that puts developers first.

About

Understanding The Language

What's new, and what's planned?

Error Messages

Updates

Compile-time code execution

Code Generation

Web Development

Conclusion

Applying operators and using `std::cout`