It is an exciting moment when we get to know that there is a new programming language which is being used.
It is even more exciting when we get to know that we will be working on the new language very soon.
Although this excitement stays throughout, there are some situations when we feel that there are a lot of things to know about a new language, and it might feel overwhelming to think where to start with.
What I am sharing here is one of the techniques that I have used to get myself used to some of the programming languages, and start contributing. Keep in mind, this is not a guide on how to master a particular language, but to get comfortable with the language, and have some output.
Start writing a simple application
Download a suitable IDE for the language, and start designing a simple application.
I know this might sound absurd, as you don’t even know anything about the language yet. But that is the point. Start with a simple hello world problem, and build on top of it, to get an idea of the basic syntax of the language.
From this step, you will
Problem example: Simple Calculator
Once you start with any of the above problems, you will realize that you are reaching out to google out some basic questions like “how to write a loop”. Keep going. That is what is expected out of this step. Make sure that the program runs, and provides the expected output. You can System input and output to be able to interact with the application.
Get some test coverage around the above code
Build on top of the above program, to make the code more robust. That would mean, adding some tests to the existing code.
You can either take a TDD approach, or add tests which would cover (almost) all the scenarios of the code that you have written.
While doing this step, you might realize that the initial way of writing code was not easy to test, and hence there might be a need to do some refactoring. Go ahead.
You might also require introducing some testing suite or library. This will prepare your codebase for further enhancements. Do not worry about the structure of the code just yet. If you are keeping it in mind, well and good, but if in doubt, choose what structure you are most comfortable with.
Understand the file structures of some popular github repositories
Now comes the time to restructure the code into some best practice followed across the industry. Visit github’s trending repositories page, filter them by the language of your choice, and go into some repository which has a good number of stars to it’s name.
Over here, search for the source and test files, and see if the locations make sense to you. If it does, refactor your codebase accordingly.
Trending repo link: https://github.com/trending
Do note, there might be a bit too many files in the repo that you have chosen. Spend some time to get a repo which might be easier to walk through for you, or spend the same amount of time to understand the repo that you have at hand, and how the files are structured.
Add new features on top of the existing code, with test coverage
Now that you have got a working code with test coverage, and some structure to it, go ahead and do some TDD to add a couple more features on the codebase. For example, in case of calculator, add a feature of transforming from one unit to another, like from centimeter to inches and vice versa.
Make sure to add some test coverage for the new feature, and make the tests fail, before adding the actual fix for the tests. This will ensure that your code actually works, even if the structure changes.
Add some new packages and libraries
Just to get a better understanding of how the language is used, try adding some packages into your code, and some libraries. For example, in calculator, you can add a new feature around currency conversion via some third party API.
This stage will help you in getting more flexible and confident around how to move around your code.
Expose your application as a simple HTTP service
By now, you must have got some methods which encapsulates the features that you had in mind. It’s time to take this application one level further.
The goal of this step is to be able to use all the above features via an HTTP client. You can google for the best library out there for the language of your choice, and start implementing that itself. There might be better ways to implement a certain use case, but that will be up for another topic.
Once an API is ready, make sure to try out that the API is working from your local machine.
Revise the code that is implemented, and refactor based on the learning gathered till now
Once the complete end to end application is working, it is time to look back at the code that is written, but now with better understanding around how the language expects to be implemented in the best way.
It would also be a good point to go back to look at the trending repositories again, and go through some more repositories, and try to understand what is happening in the code.
Clone a popular git repo and go through the code flows
This would be the second last step of this guide. Cloning the code into local machine allows you to navigate faster around the codebase, which in turn makes the whole code understanding journey faster. Although speed is not a concern here, it will definitely make it a better experience.
Start from the main file of the codebase, and walk your way through the various packages and files that are present. Understand what each component is responsible for, and how are communications happening. This will create a reliable base for you to understand some of the best practices and best structures for the language.
Please keep in mind that this is in no way a request to memorize the structure, as that would be complete waste of time very soon, when some of the practices change. Instead, the suggestion is to understand the concepts being followed, and implement them.
Final step: Design a more complicated application
Once the above steps are gone through, it is time to do a refresher, and I believe that the best way is to implement, rather than reading through. So, now it is time to design a bit more complicated application, keeping in mind the amount of time that you have at hand.
If you feel that going for a complicated application would be too much of a jump, and you would like to go over the steps again, the recommendation would be to still choose the more complicated application, and follow the steps starting from step 1.
The above steps are in no way exhaustive, or the only way to start with any language.
Also, keep googling for the specific questions which you encounter while going through the below steps.
That would be all as of now. I hope this helps you in getting onboarded to an new language in an exciting way, and you are able to start contributing to the new project as soon as possible!