DEV Community: Aadhitya A

Walking through the OSS Path

Aadhitya A — Mon, 10 Jul 2023 07:15:16 +0000

NOTE: This blog post is all about my short experience in LFX program and FAQ about OSS. This post doesn’t guarantee 101% that you’d “crack” into the OSS programs. The OSS programs are made for a specific reason: To help the people working in OSS projects and become a long-time member of the project. I hope you understand this. Anyways :) Cheers ✌️

Some OSS Program links (for those who aren’t aware, there are many but I’m providing link of the two):

☀️ Google Summer of Code

🐧 LFX Mentorship

⚙️ Other programs

My Experience

I’d like to keep this short and quick. My journey was all started during 2020 and it’s quite useful as I got to know about some of things such as OSS during net surf. Of course, I was a newbie in OSS like you, so I had to explore a bit. I engaged in some of the projects such as Tensorflow, CNCF, Meshery and I got a hang of Meshery (a CNCF Sandbox project) a lot. Later on, I kept contributing and became an org member, finally after a year, I got a chance to become a LFX mentee during Spring 2022 for the project. It is bit late due to some commitments I had in middle due to which I was inactive, but it’s worth. Thus, the experience is so far great and I’m still doing it even today.

FAQ

Q: What skills do I need to get engaged into Open Source?

A: These tools might be enough to get you started:

GitHub account (or GitLab/BitBucket, depends on project you’re seeing on)
GitHub CLI (if working on GitHub repo, this would make things faster. It’s optional though)
Git Bash
Other than that, you might need to look into the programming languages (explained in subsequent Qs)

Q: What exactly I need to do to get engaged in OSS?

A: It’s simple TBH, though many people follow it in wrong way as they think it’s like a competitive exams. IT’S NOT! If you’re in that mindset, then Open Source is strictly not for you. It’s mainly present as a collaboration and community purpose and you’re expected to contribute your part there. (Sorry for strict point, but it’s reality though)

Choose a project to engaged on, it can be of anything ranging from small project to a very large project. If you’re confused on this, you can have look on the GSoC, LFX portals to have a look on orgs that participated previously.
Look at the codebase and try to understand. It’s ok if it’s very large to grasp on. It may take time. ✌️ You can also read the docs for this purpose
Couldn’t grasp the project codebase? There’s also another option to contribute non-code based like docs. Remember, everyone is not a coder out there! 🙂
Participate in the community and get engaged. Talk to the ones who made the project.
Try taking on smaller issues if you’re new to the code base. Remember to speed up your learning curve and ask Q if you’re struck. But make sure to gradually increase your actions in the project too.
Repeat step 3–5
That’s it 🎉

Q: Are OSS programs meant for absolute cores who are already experienced?

A: Absolutely not! GSoC program is designed for those who are very new to the Open Source, although it’s true that certain folks who are already experienced with the project get selected. It varies from org to org, you need to talk with the org members if you’re confused with this.

Q: How to get selected in the OSS programs?

A: Read the answer of 2nd Q and 3rd Q

Q: Is OSS worth it?

A: ABSOLUTELY! Why not? After all, the world runs on 85–90% OSS projects. Never believe on this? Take Linux as example. No further explanation needed! 😂 (JK, no seriousness intended)

Yes, it is worth. It’ll help you to grow your skills as well. Some find it very useful to get jobs or even work in OSS full time. So, take your shot! ;)

Q: What kind of fields are there in OSS to take on?

A: Basically 2 kinds, Code and Non-Code (UI/UX, Docs, Release Notes)

Q: I find some OSS programs not providing stipend…

A: Read answer of 2nd Q. Plus, some OSS programs don’t provide stipend generally as there are non-funded ones as well. The main objective of these programs is to make you gain experience by working on real stuff. Sometimes, that might be also worth it. Though I’m not forcing you to apply these programs, you could give a try for gaining skills.

Q: I’m a newbie to the project. Could I make it?

A: Sure you can! Remember, every action does take time. I’m counting on you! ;)

I hope these Q would provide a gist of OSS now. If you’re feeling that some Q can be asked and added as well, feel free to contact me (Discord: kryox64 or via mail)!

Cheers! ✌️

How a C/C++ code is compiled in a system?

Aadhitya A — Tue, 26 Apr 2022 16:57:47 +0000

We may all used C or C++ language in our life, either as a product (eg: Games created using Unreal Engine) or even created/developed projects. Well, its most popular and it even exists today as its a foundation for many languages too like Python, Golang. But have you ever wondered how a C or C++ code is compiled in a system? Well, actually I also didn't know at first glance and later found a nice tip from my seniors about it. So let's get into it 😁

Tools needed?

Before knowing about how the stuff works, I recommend you to use GNU's GCC Compiler as it's widely used. You could also use LLVM Clang (which is better than GCC) to try it out too!

In Action!

Alright, to get things started, let's type a normal C++ Hello World code. You'd understand at end, why I started with simple one.

// Hello.cpp
#include <iostream>

using namespace std;

int main()
{
    cout << "Hello World! \n";
    return 0;
}

Right, now let's compile the code using g++ Hello.cpp or clang++ Hello.cpp

If you run the output file called a.out (a.exein Windows), you'd get pretty straight output. No doubt.

Hello World!

Now, to make things interesting, compile the code again but this time using -S flag

// For GCC
gcc -S Hello.c (for C)
g++ -S Hello.cpp (for C++)

// For Clang
clang++ -S Hello.cpp

You'd get a file called Hello.s and if you read the contents, it's bit different than usual syntax and if you slightly read a bit more... It's all encoded in assembly format!

Here's an example (do note that it differs across compilers, computation speed, processor used and much more)

// From GCC (arrows are presented for better view)
    .file   "Hello.cpp"
    .text
    .section    .rodata
    .type   _ZStL19piecewise_construct, @object
    .size   _ZStL19piecewise_construct, 1
_ZStL19piecewise_construct:   <--- Initialize step
    .zero   1
    .local  _ZStL8__ioinit
    .comm   _ZStL8__ioinit,1,1
.LC0:                          <--- Which function to execute?
    .string "Hello World!"
    .text
    .globl  main
    .type   main, @function
main:                          <--- Main operation
.LFB1522:
    .cfi_startproc
    endbr64
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    leaq    .LC0(%rip), %rsi
    leaq    _ZSt4cout(%rip), %rdi
    call    _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@PLT
    movl    $0, %eax
    popq    %rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE1522:
    .size   main, .-main
    .type   _Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
.LFB2006:
    .cfi_startproc
    endbr64
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    subq    $16, %rsp
    movl    %edi, -4(%rbp)
    movl    %esi, -8(%rbp)
    cmpl    $1, -4(%rbp)
    jne .L5
    cmpl    $65535, -8(%rbp)
    jne .L5
    leaq    _ZStL8__ioinit(%rip), %rdi
    call    _ZNSt8ios_base4InitC1Ev@PLT
    leaq    __dso_handle(%rip), %rdx
    leaq    _ZStL8__ioinit(%rip), %rsi
    movq    _ZNSt8ios_base4InitD1Ev@GOTPCREL(%rip), %rax
    movq    %rax, %rdi
    call    __cxa_atexit@PLT
.L5:
    nop
    leave
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE2006:
    .size   _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii
    .type   _GLOBAL__sub_I_main, @function
_GLOBAL__sub_I_main:
.LFB2007:
    .cfi_startproc
    endbr64
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    movl    $65535, %esi
    movl    $1, %edi
    call    _Z41__static_initialization_and_destruction_0ii
    popq    %rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE2007:
    .size   _GLOBAL__sub_I_main, .-_GLOBAL__sub_I_main
    .section    .init_array,"aw"
    .align 8
    .quad   _GLOBAL__sub_I_main
    .hidden __dso_handle
    .ident  "GCC: (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0"
    .section    .note.GNU-stack,"",@progbits
    .section    .note.gnu.property,"a"
    .align 8
    .long    1f - 0f
    .long    4f - 1f
    .long    5
0:
    .string  "GNU"
1:
    .align 8
    .long    0xc0000002
    .long    3f - 2f
2:
    .long    0x3
3:
    .align 8
4:

You'd see a lot of code just for a Hello World program! (Sounds bit shocking right?! Yeah, I got it too) so let me just explain a bit of it to get it clear...

    .file   "Hello.cpp"
    .text
    .section    .rodata
    .type   _ZStL19piecewise_construct, @object
    .size   _ZStL19piecewise_construct, 1

This section contains metadata for the C++ file and has some information about the file.

_ZStL19piecewise_construct:
    .zero   1
    .local  _ZStL8__ioinit
    .comm   _ZStL8__ioinit,1,1
.LC0:
    .string "Hello World!"
    .text
    .globl  main
    .type   main, @function
main:
.LFB1522:
    .cfi_startproc
    endbr64
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    leaq    .LC0(%rip), %rsi
    leaq    _ZSt4cout(%rip), %rdi
    call

In above code, the section _ZSt... denotes initialization of pointers and the main part of code is done on the .LC0 and main sections. LC0 has the information about the function and where to execute it (in this case, it's main function). In main section, you'd see a bit on handling the data and the pointers. Interesting fact is that, it's all encoded in assembly.

Now, let's see a bit complex one (don't panic xD). Addition of 2 numbers!

#include <iostream>

using namespace std;

int main()
{
    int a=5, b=10;
    cout << a+b << "\n";
    return 0;
}

Compiling the program with -S flag, you'd get the assembly file. Let's just see the important details about it.

main:
.LFB1522:
    .cfi_startproc
    endbr64
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    subq    $16, %rsp
    movl    $5, -8(%rbp)  <-- NOTE HERE
    movl    $10, -4(%rbp) <-- NOTE HERE
    movl    -8(%rbp), %edx
    movl    -4(%rbp), %eax
    addl    %edx, %eax
    movl    %eax, %esi
    leaq    _ZSt4cout(%rip), %rdi
    call    _ZNSolsEi@PLT
    leaq    .LC0(%rip), %rsi
    movq    %rax, %rdi
    call    _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@PLT
    movl    $0, %eax
    leave
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc

In the above main section, you can see that the registers are being used to store the values 5 and 10... Let's have a close look...

movl    $5, -8(%rbp)
movl    $10, -4(%rbp)

So, the values are made to move towards the destination registers and eventually carry out the operation in further parts of assembly code

This is how generally C or C++ is compiled to assembly mode and I've just shown only the upper layer of the glacier (yes, it's bit deep!). I'll also share a blog post soon on how pointers are used in such case to access while running in assembly mode and much more. Until then, see ya! ;)

How to approach an OSS project

Aadhitya A — Wed, 20 Apr 2022 13:57:01 +0000

The title of this blog post may understand for some people and eventually some won't :') at first glance. So let me get this straight. Consider a scenario where you're a developer; be it aspiring or a pro, and want to enhance your skills in a great way such that public will benefit on your work. On your quest, you found that the open-source is one such method to look and try your hands on, so you took a project and had a look. But sadly you didn't understand the project well! Sad right :( So, you tried all ways possible to understand the project even better but still you didn't know what you made mistake on. This is seen in most of the developers and if you're one of them, well don't worry! Here's some of the fields where you can try to look on any project and thereby start doing your work.

What the heck is Open Source?! 🙄

I'd make it short though. Open Source is a kind of project where you use the project for free or sometimes paid (if in case of pro/business user). These projects are made with help of passionate team or community and code is open. Yes, open! This means you can have a look at the source code and understand what is happening BTS.

How to understand OSS project? 😵

So you know what is Open Source and you found a project to contribute as well! But you didn't know how the project works and you got tired of learning it 😫! Well, it happens at first, don't panic. There's a way to approach an OSS project. So, here's the way on how to it.

Find the community before code 🏢

You might think "hey, why I'd need to find a community? All I need is just to code...🤔" Well, in that case, you should drop that thought. There would be a team/community behind that project and there are the ones who created as well. So if you found a project, make sure you join the team and get a hang of it. You could also ask doubts related to the project. They'd be happy to help you. Trust me :) Get along with the team together and you'd achieve something more!

Find your field 🔍

Did you join the community and understood the purpose of the project? That's great news! 🥳 So what's next? You need to find your suitable field in order to contribute better.

Now, you can ask why you'd do such, remember that before starting a big work you need to rely on small modules. That's where you could look on the fields in which a project would have. Some of them are...

UI/UX
Docs
Frontend
Backend
CI/CD
Security
and much more...

If you're newbie and want to get hang on a project, then I'd suggest you to try on docs first. Because, after all, docs are the first source of truth for any project! Then you can explore other fields.

SHARP NOTE: Contributions can also be non-code! Eg: Docs, UI/UX. It doesn't mean it has to be code all time! Even non coders can also contribute to the project (sounds amazing right?!)

Know the rules and hack the code 👨‍💻

Alright! So you know what field to tackle and contribute. Next step is to know the rules of the project ecosystem. This step might be slightly important such that your PR (Pull Request) may get rejected if you don't follow them. Do note that some rules may differ according to the project. So, first step, read the contribution rules, typically you will find it in the project in the name of "CONTRIBUTING" file. Read it first. You can also find the rules by asking in the community as well.

Then, you should find a suitable issue to work on the project. You can find several issues and filter them to suit your field. Select an issue which is comfortable for you at first, because if you start a hard issue you may feel bit sad at later times. It's ok if you seek help, the project maintainers and committers will help you if you're struck. Finally, it's time to open a PR!

During PR review 😬

You've contributed code and raised a PR. Congrats! It'd be on the reviewers and maintainers work to review and merge your PR to the source code! This step is crucial as your code will be reviewed and suggestions would be posted if it needs a change. You need to be calm and accept criticism during this stage. Accept or ask doubts if reviewers suggest a change. Do changes on your code and push them. Iterate this process until it's successful.

Final result 🎉

After your PR is accepted, the maintainers will merge your PR which eventually would show up on the project. And that's it! You've made your first contribution to the project! Give yourself an applause or have a small treat ;)

But that's not the end, it's the small step for your journey to pursue! This process is iterative one which would eventually turn into a journey you would want to take on. If you do this correctly, you may get recognized for your work and have bigger accomplishments on your profile! So keep going!

But why Open Source though? 🤨

You can ask this question, no wrong in it. With open source, you could indeed learn few valuable skills which some usually won't teach. For example, documenting your code for people to understand better, collaboration on a project, learning new tech and a lot more. So, why don't you give yourself a try to experience it? ;) After all, actions speak louder than voice!

P.S: Never try this if you do for 💵, there's a reason why open source exists. Understand it before you do (just a personal opinion 🙂)

Conclusion

And that's it! You've successfully contributed towards an open source project. Do remember to be consistent and be engaging with the project and the team such that both you and the project will be successful. So what are you waiting for? ;)

My experience at Layer5

Aadhitya A — Sat, 15 May 2021 05:17:09 +0000

Joining Layer5

It was Dec 2020, I was looking at some programs at LFX Programs (previously CommunityBridge) where some orgs like Linux Kernel, CNCF post openings on mentorships to work on. At that time, I came across a mentorship program called "Meshery". I applied out of interest and found a link to join their slack. I joined in and realized that the program needs community member for that program such that he/she has done impactful contributions previously in the project. Then I quickly withdrawn the application and started becoming active in the community. That's how I joined Layer5

My initial works

At the beginning, I wanted to test the project as a user but felt a bit hard because I wasn't ready for cloud native at that moment. Tweaked some settings in my system but no results. So, I thought is there any way to contribute the project and that's how I started looking on Documentation. I gradually looked at some issues, commented and took up the work. The project's documentation is mainly made of Jekyll so I had to install Ruby, and since Makefile is dominant in order to install dependencies, I used Linux as my main development environment. It felt a bit hard at first because I never used Jekyll before. Then gradually, I learned about Jekyll and YAML, fixed some bugs and done even bigger works!

My greatest work so far

The greatest work so far I've done is to redesign mesheryctl command reference page. The page was outdated for a while so I was given a task to redesign and update the doc. It felt tedious at first, then some ideas came in, took my peer's help and finally completed. The doc was so impressive such that it's updated with the latest spec and understandable!

My surprise!

After taking a lot works, I got recognized such that I've been added to their community and their GitHub organization! It all happened at one day, a team was created including me and I got a message that "your works have been recognized a lot... So, we decided to add you on our community profile in our website" I WAS SURPRISED AND EXCITED AT THE SAME TIME! O_O 🎉🎉🥳😂😂
It really got a pride feeling within me. So I accepted! :)
Link: https://layer5.io/community/members/ (First profile)

At present

After doing some doc work, I realized why not try new field and work on it. That's where I again used the project but this time with Minikube cluster enabled. (If you guys wonder what is Minikube, it's a simple one-node local Kubernetes cluster which can be run on Virtualization enabled machines like WSL2, HyperV, VMware etc). It WORKED! I was in state of awe! I can't believe I really ran a cloud-native project locally. Then I started installing Golang, learning about Kubernetes and Golang and started working on mesheryctl as tester and now a contributor (will catch up soon, coz I started recently) xD

Conclusion

In a nutshell, I thought only skills matter in such a DEV ecosystem. But, I was wrong. If it's open-source, community also matters in order to co-operate and work in harmony. I learned that when I joined Layer5. It's an interesting experience and I hope this continues long further! 😍❤❤

The Linux side

Aadhitya A — Sat, 23 May 2020 05:32:44 +0000

NOTE: This blog post is republished from my inactive Medium account

Windows is for anyone. But you need resources.

MacOS is for creators, business. But you need money.

Linux is for developers & you just need skills.

I didn’t believe it until I got hands into the Linux at 2019. It was so fascinating! Plus it’s an advantage specially for developers ;)

Speaking of this, if you didn’t know what is Linux, it’s an OS similar to Windows but with some additional features. To know about Linux, let’s take a walk in the memory lane…

In 1991, Linus Torvalds created a UNIX based OS, which he made it open-source and required just 14MB to install on any PC (that was back then). He made it as a collaborate-friendly, which made programmers to add features to it. This OS is Linux. :)

So, now Linux is not just one or two, but many versions! Deployed by many countries, with some features of their own, Linux became famous in the names of Ubuntu, Debian, mintOS, parrotOS, and much more. But to be frank, it’s not an OS! It’s a kernel .

Ubuntu and Debian are the most stable and famous OS today. I had Ubuntu installed and it was a new experience! I didn’t have that before, and these are the new changes

It supports even older hardware
There’s no virus created to attack Linux (but don’t take for granted as vulnerabilities exist T_T)
Best for script file writers
Good for programming
Has better ecosystem and it’s resource friendly
Don’t like an OS? No problem! Switch to other provider’s OS xD

I like those features and it’s fascinating. But it does have problems just like the quote,

“If there’s light, there’s darkness”

For OS other than Ubuntu, you need to use terminal to install any application (but you'd get used to it).
Most famous apps sometimes don’t provide support to port onto Linux
You need patience to understand Linux ecosystem
Linux is sometimes unstable (due to frequent breaches in mirror servers)
You must get used to the terminal to operate it clearly
Installation may be a bit tough because of disk partition
Installing software is bit tough (especially if you don’t have Debian or Ubuntu )

So, that’s what Linux is about.

If you need a guidance on choosing a OS, then here are some, which you can give a try!

Ubuntu:

My first list on the series. It has a nice UI, with a bunch of apps and games. If you’re new to Linux, then you must try Ubuntu. Most of the apps support this OS. Ubuntu is popular Linux based OS managed by Canonical. But updates for LTS come only after a long time, that’s the down side! Oh, and if you want to use the shell alone, you can install within Windows via WSL2!

mintOS:

If you’re low on hardware and still need a clean OS, welcome to Mint! It’s based on Ubuntu but with faster performance. Nice and clean to operate.

elementaryOS:

If you want to try a mac based OS (or just want to see how it looks like), try this. It has a clean, Mac based UI and has even have it’s own app store! But customizing it, would be a difficult task as it doesn’t allow much of it. T_T

Debian:

If you’re a Linux fan, you may know this one. It’s similar to Windows and yeah, better than Ubuntu. (I haven’t tried it yet. But still, it’s popular) It’s one of the most stable versions of Linux

Kali Linux :

This is strictly not recommended for beginners; this is only suitable for pentesters and ethical hackers. Kali is based on Debian and it’s maintained by offensive security. Kali has a wide range of hacking tools pre-installed, so you need to download the OS, that’s it!

ParrotOS:

Similar to Kali, but a fast and light version. Better for beginners as it’s user friendly!

These are some of Linux versions which I know, but there are other OS like, Fedora, Red Hat Enterprise Linux, openSUSE, centOS (deprecated) etc. So, you just need to go to the provider to get the details….

And that's it! So, what are you waiting for? ;) Try getting your feet wet on Linux now! xD

Originally posted on Medium by @alphax86 at May 2020 (Just thought I could republish some blogs -_-)
Link: https://alphax86.medium.com/the-linux-side-18de67abbc33