DEV Community: Aditya Giri

Building my own Interpreter: Part 1

Aditya Giri — Sat, 05 Feb 2022 16:32:31 +0000

Note: This is not supposed to be a tutorial on building the interpreter. This is just my anecdote about how I built my interpreter. If you're looking for extensive tutorials, I'd recommend going to Crafting Interpreters or purchasing Interpreter Book (on which this article is based on if you want to get a deeper dive).

I've been programming for several years now and have tackled working with many languages. But one thing that always bugged me was how do these programming languages really work? I know there are compilers and interpreters that do most of the work of converting a simple text file into a working program that the computer can understand, but how exactly do they work?

This had become increasingly important that I understand the inner workings of a language for what we are doing at Hyperlog. We are building a scoring system that analyzes the skillsets of a programmer by going through multiple metrics. A couple of these metrics are tightly coupled with how you write and structure a program. So in order to get deeper insight, I decided to implement one of my own interpreters.

That is when I embarked on my journey. I know what you're thinking, why interpreter rather than compiler? I like to take the top-down approach to learning new stuff. The major inspiration behind this was a book by Kulrose, Ross Computer Networking - Top Down Approach. I learned a lot about computer networking in a neat manner while reading that book. And ever since, I've been doing a similar form of learning as often as possible.

What tech to use?

I guess this is the most common dilemma of a programmer. While writing this interpreter, I wanted to focus on the inner workings rather than learning a whole new language like assembly.

For this adventure, I settled on using Golang. Golang gives you the most basic barebones of talking with the computer, and you can write the programs that won't require any imports and installs from external libraries just to make the basic code usable. (Looking at you, JavaScript).

What would the interpreter be interpreting?

In order to properly implement my interpreter, I need some basic syntax for the language. I decided to settle on this syntax for my interpreter which is inspired by a bit of C++, and a bit of Golang.

let five = 5;
let ten = 10;
let add = fn(x, y) {
    x + y;
};

let result = add(five, ten);

if (5 < 10) {
    return true;
} else {
    return false;
}

let fibonacci = fn(x) {
    if (x == 0) {
        0
    } else {
        if (x == 1) {
            1
        } else {
            fibonacci(x - 1) + fibonacci(x - 2);
        }
    }
};

let twice = fn(f, x) {
    return f(f(x));
};

let addTwo = fn(x) {
    return x + 2;
};

twice(addTwo, 2);

The above program should run successfully using my interpreter. If you notice, there are some pretty basic things there. Let's go through them one by one.

Keywords - A few keywords including let, return, if, else, and fn.
Recursive function - The Fibonacci function written above is a recursive function.
Implicit returns - When you closely notice add and Fibonacci functions, they do not have a return statement. This part was inspired by my favorite language, ruby.
Function as a parameter to other functions - The last part of this program gets a function as a parameter.

What really goes in an interpreter?

If you've been in the programming sphere for a couple of years now, you may have heard of the words "Lexer", "Parser", and "Evaluator". These are the most important parts of an interpreter. So what exactly are they?

Lexer

Lexer converts our source code into a series of tokens. This is particularly helpful to define the basic structure of words that can be used in your program, and classifying those words. All the keywords, variable names, variable types, operators are put in their own token in this step.

Parser

Once your program passes through lexer, the interpreter needs to make sure that you have written the tokens in the correct syntax. A parser basically declares the grammar of the language. The parser is also responsible for building the abstract syntax tree (AST) of your program. Note that the parser does not actually evaluate and run the code, it basically just checks for the grammar. Evaluation happens in the next steps after the parser makes sure that the code is in the correct syntax.

Evaluator

This is the part that actually looks at how to execute the program. After the program goes through the lexer and parser, evaluator steps in.

Let's build the interpreter.

Starting out, I built a token system that defined what each character would mean in the language. In order to get there, firstly, I needed a token system that defined the type of the token and the actual token itself. This is particularly useful for throwing error messages like "Expected token to be an int, found string".

type Token struct {
    Type    TokenType
    Literal string
}

Then, there are actual token types:

const (
    ILLEGAL = "ILLEGAL"
    EOF     = "EOF"

    IDENT = "IDENT"
    INT   = "INT"

    ASSIGN    = "="
    PLUS      = "+"
    GT        = ">"
    LT        = "<"
    BANG      = "!"
    MINUS     = "-"
    SLASH     = "/"
    ASTERICKS = "*"

    COMMA     = ","
    SEMICOLON = ";"

    LPAREN = "("
    RPAREN = ")"
    LBRACE = "{"
    RBRACE = "}"

    EQ     = "=="
    NOT_EQ = "!="

    FUNCTION = "FUNCTION"
    LET      = "LET"
    RETURN   = "return"
    TRUE     = "true"
    FALSE    = "false"
    IF       = "if"
    ELSE     = "else"
)

In this block, I think the not so apparent ones are ILLEGAL, EOF, and IDENT. Illegal token type is assigned whenever we encounter some character that does not fit our accepted string type. Since the interpreter will be using ASCII character set rather than Unicode(for the sake of simplicity), this is important. EOF is do determine the end of file, so that we can hand over the code to our parser in the next step. And IDENT is used for getting the identifier. These are variable and function names that can be declared by the user.

Setting up tests for lexer

TDD approach never fails. So I first wrote the tests for what exactly do I want as output from the lexer. Below is a snippet from the lexer_test.go.

    input := `let five = 5;
        let ten = 10;
        let add = fn(x, y) {
            x + y;
        };

        let result = add(five, ten);
        !-/*5;
        5 < 10 > 5;

        if (5 < 10) {
            return true;
        } else {
            return false;
        }

        10 == 10;
        10 != 9;
        `

    tests := []struct {
        expectedType    token.TokenType
        expectedLiteral string
    }{
        {token.LET, "let"},
        {token.IDENT, "five"},
        {token.ASSIGN, "="},
        {token.INT, "5"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "ten"},
        {token.ASSIGN, "="},
        {token.INT, "10"},
        {token.SEMICOLON, ";"},
        {token.LET, "let"},
        {token.IDENT, "add"},
        {token.ASSIGN, "="},
        {token.FUNCTION, "fn"},
        {token.LPAREN, "("},
        {token.IDENT, "x"},
        {token.COMMA, ","},
        {token.IDENT, "y"},
        {token.RPAREN, ")"},
        // ........
    }

    l := New(input)

    for i, tt := range tests {
        tok := l.NextToken()

        if tok.Type != tt.expectedType {
            t.Fatalf("tests[%d] - tokenType wrong. expected=%q, got=%q", i, tt.expectedType, tok.Type)
        }

        if tok.Literal != tt.expectedLiteral {
            t.Fatalf("tests[%d] - Literal wrong. expected=%q, got=%q", i, tt.expectedLiteral, tok.Literal)
        }
    }

Here, we're invoking the function New for the given input which is of type string. We are invoking the NextToken function that helps us get the next token available in the given program.

Let's write our lexer.

Alright, so first things first, we are invoking the New function, which returns a lexer. But what does a lexer contain?

type Lexer struct {
    input        string
    position     int
    readPosition int
    ch           byte
}

Here input is the given input. position is the current position our lexer is tokenizing, and readPosition is just position + 1. And lastly, ch is the character at the current position. Why are all these declared in such a way? Because we'll keep updating our lexer itself, while keeping track of the position we are analyzing at any moment, and adding tokens to a separate array.

Let's declare the New function:

func New(input string) *Lexer {
    l := &Lexer{input: input}

    return l
}

Pretty easy. Should be self-explanatory. Now, what about the NextToken function? Behold, as there's a ton of code ahead. All of it is explained in the comments. So do read them.

// Reads the next character and sets the lexer to that position.
func (l *Lexer) readChar() {
    // If the character is last in the file, set the current character
    // to 0. This is helpful for determining the end of file.
    if l.readPosition >= len(l.input) {
        l.ch = 0
    } else {
        l.ch = l.input[l.readPosition]
    }
    l.position = l.readPosition
    l.readPosition += 1
}

// Major function ahead!
func (l *Lexer) NextToken() token.Token {
    // This will be the token for our current character.
    var tok token.Token

    // We don't want those stinky whitespaces to be counted in our program.
    // This might not be very useful if we were writing ruby or python-like language.
    l.skipWhitespace()

    // Let's determine the token for each character
    // I think most of it is self explanatory, but I'll just go over once.
    switch l.ch {
    case '=':
        // Here, we are peeking at the next character because we also want to check for `==` operator.
        // If the next immediate character is not `=`, we just classify this as ASSIGN operator.
        if l.peekChar() == '=' {
            ch := l.ch
            l.readChar()
            tok = token.Token{Type: token.EQ, Literal: string(ch) + string(l.ch)}
        } else {
            tok = newToken(token.ASSIGN, l.ch)
        }
    case '+':
        tok = newToken(token.PLUS, l.ch)
    case '(':
        tok = newToken(token.LPAREN, l.ch)
    case ')':
        tok = newToken(token.RPAREN, l.ch)
    case '{':
        tok = newToken(token.LBRACE, l.ch)
    case '}':
        tok = newToken(token.RBRACE, l.ch)
    case ',':
        tok = newToken(token.COMMA, l.ch)
    case ';':
        tok = newToken(token.SEMICOLON, l.ch)
    case '/':
        tok = newToken(token.SLASH, l.ch)
    case '*':
        tok = newToken(token.ASTERICKS, l.ch)
    case '-':
        tok = newToken(token.MINUS, l.ch)
    case '<':
        tok = newToken(token.LT, l.ch)
    case '>':
        tok = newToken(token.GT, l.ch)
    case '!':
        // Again, we are peeking at the next character because we also want to check for `!=` operator.
        if l.peekChar() == '=' {
            ch := l.ch
            l.readChar()
            tok = token.Token{Type: token.NOT_EQ, Literal: string(ch) + string(l.ch)}
        } else {
            tok = newToken(token.BANG, l.ch)
        }
    case 0:
        // This is important. Remember how we set our character code to 0 if there were no more tokens to be seen?
        // This is where we declare that the end of file has reached.
        tok.Literal = ""
        tok.Type = token.EOF
    default:
        // Now, why this default case? If you notice above, we have never really declared how do we determine
        // keywords, identifiers and int. So we go on a little adventure of checking if the identifier or number
        // has any next words that match up in our token file.
        // If yes, we give the type exactly equals to the token.
        // If not, we give it a simple identifier.
        if isLetter(l.ch) {
            tok.Literal = l.readIdentifier()
            tok.Type = token.LookupIdent(tok.Literal)
            // Notice how we are returning in this function right here.
            // This is because we don't want to read the next character without returning
            // this particular token. If this behavior wasn't implemented, there would be a lot
            // of bugs.
            return tok
        } else if isDigit(l.ch) {
            tok.Type = token.INT
            tok.Literal = l.readNumber()
            return tok
        } else {
            // If nothing else matches up, we declare that character as illegal.
            tok = newToken(token.ILLEGAL, l.ch)
        }
    }

    // We keep reading the next characters.
    l.readChar()
    return tok
}

// Look above for how exactly this is used.
// It simply reads the complete identifier and
// passes it token's LookupIdent function.
func (l *Lexer) readIdentifier() string {
    position := l.position
    for isLetter(l.ch) {
        l.readChar()
    }
    return l.input[position:l.position]
}

// We take a peek at the next char.
// Helpful for determining the operators.
func (l *Lexer) peekChar() byte {
    if l.readPosition >= len(l.input) {
        return 0
    } else {
        return l.input[l.readPosition]
    }
}

func (l *Lexer) readNumber() string {
    position := l.position
    for isDigit(l.ch) {
        l.readChar()
    }
    return l.input[position:l.position]
}

func isLetter(ch byte) bool {
    return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
}

func isDigit(ch byte) bool {
    return '0' <= ch && ch <= '9'
}

func newToken(tokenType token.TokenType, ch byte) token.Token {
    return token.Token{Type: tokenType, Literal: string(ch)}
}

// Note how we check not just for whitespace, but also for tabs, newlines and
// windows based end of lines.
func (l *Lexer) skipWhitespace() {
    for l.ch == ' ' || l.ch == '\t' || l.ch == '\n' || l.ch == '\r' {
        l.readChar()
    }
}

Okay, cool, but what about that LookupIdent function? Well, here's the code for that.

var keywords = map[string]TokenType{
    "fn":     FUNCTION,
    "let":    LET,
    "return": RETURN,
    "true":   TRUE,
    "false":  FALSE,
    "if":     IF,
    "else":   ELSE,
}

func LookupIdent(ident string) TokenType {
    if tok, ok := keywords[ident]; ok {
        return tok
    }
    return IDENT
}

Get it? We are just mapping it the proper TokenType, and returning the type accordingly.

And voila! That is the lexer to our basic interpreter. I know it seems like I skipped over a large portion of explaining, but if you want to learn more, I highly recommend picking up the Interpreter Book.

Stay tuned for part 2 where I'll be implementing the parser for this program.

Building perfect portfolio

Aditya Giri — Mon, 19 Apr 2021 05:00:12 +0000

Building a developer portfolio is one of the most daunting tasks. Where do you start? What do you need in your portfolio?

A portfolio just like one for designers is a website that showcases all the work you have done.

Why do you need a portfolio?

Well, you already have a resume, and a LinkedIn profile, isn't that enough? While both of them are important, a portfolio has much more to it.

If your projects are a monument, A resume and a LinkedIn profile are like the broachers you get at the gates of the monument when you visit them, a bunch of screenshots, external links, and that's it. A portfolio, on the other hand, is more like a guided tour of your projects. Where you show (rather than just state) your skills. A portfolio lets you highlight the most impressive and important parts of your projects, stuff that isn't visible at the first glance, or things that you are really proud of.

So how do you build a decent portfolio?

Curating the projects.

Go deep not wide.

A portfolio is meant to be a showcase, a showcase of your best work and not an exhaustive list of all your work. Nobody will spend time looking at more than 3-4 projects. If you make it an exhaustive list, chances are a potential employer would end up looking at one of the least impressive ones.

Pick 4 projects that best represent your skills, and if you really want to include more than that consider putting up an archive link to all the other projects.

Make it Personal

The portfolio should reflect your personality. Avoid generic terms and language, you are making your personal portfolio, not a template for mass use. So make sure it reflects you!

Tell your story, include information that shows the human whose work they are looking at.

Be a tour guide

When it comes to the project description pages, guide the reader through the most important aspects of your projects, show them the challenges you went through, how the project came into being, highlight the sections that you are really proud of. Tell the story of your journey while working on the projects, the difficulties, the way you resolved them, what new things you came across, everything. Your project description pages should convey to employers that you're competent and enthusiastic.

Good UX/UI

Obviously, every website needs a decent UX/UI. Even if you are not a designer, it still matters that your portfolio site has a good design and aesthetic.

Domain and Hosting.

A portfolio site should probably be a static site and if possible prefer buying a domain for your portfolio site, eg yourname.com.

Make sure your portfolio follows accessibility standards.

General Layout

Obviously, the layout of your portfolio depends on your own designs and templates that you use, but let's talk basics, what are the most basic elements that every portfolio has.

An About me section
- A small about me section that highlights your personality and your background.
A list of projects
- a curated list of the projects you have worked on, with each project having a link to a project page that talks more about the project.
Contact Information.

About the Project description pages, while it is a tricky and time-consuming thing to build decent project description pages. Nevertheless, these pages are important.

Here's a template drawn by Josh Comeau in his book "Building an effective dev portfolio" for the project description pages to give you a better idea.

Introduction

High-level summary of what the project is
List of core functionalities / interesting features
Your role in the project.
Technologies used
Links to live demo + source code (if applicable)

Purpose and Goal

Why did you build this project? Why is it important to you?
What was the expected outcome of the project?
What were the initial designs?
Any other preliminary planning that you did which helps build a narrative

Spotlight

What is the “killer feature” of your project?
What were the technical hurdles that got in your way? Any major problems you hit during development?
How did you solve those problems? What was the solution? Go deep here, and write with a developer in mind.

Current status

This section is optional. If the project is actively being used by real people, talk a little bit about the current status, who uses it, why they use it, what they say to you about it, stuff like that.
If the project was contrived specifically for the portfolio, omit this section.

Lessons Learned

What did you learn doing this project? Feel free to list multiple things. Also, feel free to cover non-technical lessons. It’s great to talk about how you learned to use an advanced feature of a framework or library, but it’s just as valuable to talk about the project-management experience or things you learned about shipping projects.
If you used a framework or other libraries/tools, was it a good choice? How did it help? In which ways was it insufficient?
Is your project accessible? What did you learn about accessibility, while building this project? Describing how you tested your project using keyboard navigation or a screen reader can make for a really compelling story!
How has this affected the work you’ve done since then? Real examples of how this project built your knowledge for future projects are fantastic.

In summary,

Your Portfolio site should have a decent enough UI/UX
Make sure it reflects your personality and the content isn't generic.
It should have a minimum general layout with an About me section and a Project details list.
Make sure your portfolio follows accessibility standards.
Use a domain custom domain.
Connect your social media profiles and blogs.

Are you looking to create a portfolio but don't know where to start? Hyperlog was made with just that use-case in mind. It allows you to build a portfolio according to your style while giving you the ability to add cool pluggable and themes to your project. Connect your repositories and get your code analyzed. The best part, you can get your portfolio on the WWW in under 5 minutes. Get custom domains, website analytics, and much more.

You focus on the code, we do the rest.

DEV Community is amazing!

Aditya Giri — Fri, 06 Mar 2020 10:34:37 +0000

So I had started blogging a few months back about some of the programming related topics. I did not know that dev.to had this feature of followers, but I recently saw the number of followers that I have. In such a short span of time, I have managed to amass 800+ followers. So all I want to say is thank you to all of you. And I promise there will be a lot more posts coming soon. I won't be stopping blogging anytime soon now😁.

A Quick Survey? Please?

Aditya Giri — Tue, 11 Feb 2020 15:58:13 +0000

I feel like dev.to community would really love this particular survey.

Can you please help me fill this out? Here is a link: https://adityagiri.typeform.com/to/cEOFhg

🗓️HyperLog, Weekly update - 1

Aditya Giri — Fri, 29 Nov 2019 03:09:55 +0000

Hello everyone 👋. Many of you know that I've been working on HyperLog, a site and a community that makes programming fun to learn with the gamified process.

So I thought it would be a good way to start by posting the weekly updates about HyperLog here on dev.to

Tasks accomplished:

Built a GitHub and discord user authentication system
Allow users to submit the tutorials that they love

To-Do for next week:

Build roadmaps system which aggregated the best article and puts them in proper order
Add discord interoperability to allow setting the roles and joining the server
Create a proper XP system that will facilitate level up
Build a house system

If you'd like to ask me any questions, feel free to shoot them in the comments below.

The Advantages of Peer Learning

Aditya Giri — Thu, 14 Nov 2019 16:03:51 +0000

What is Peer Learning?

Peer learning is not a single, undifferentiated educational strategy. It encompasses a broad sweep of activities and an amalgamation of different learning strategies that we come across all the time.

From a formal context: Peer learning is an educational practice in which students interact with other students to attain educational goals. To an informal context relaxing the constraints, and positioning "peer-to-peer learning" as a mode of "learning for everyone, by everyone, about almost anything."

Peer learning has a long history. It is possibly as old as any form of collaborative or
community action, and probably has always taken place, sometimes as a natural
process, sometimes by a deliberate effort to teach/learn in that manner.

And yet somehow through our traditional mass-manufactured education system, we have managed to undo all that and make "problem solving" a mundane task, that one is forced to perform.

On the other hand, computers have the opportunity to restructure the learning environment, but too often they are simply used to provide a digital version of a normal lesson or exam.

Although in the recent past, there has been a world-wide informal/formal push to "add-on" the strategies of "peer learning" with the mainstream traditional approach of learning. In an attempt to "enhance" the process of "learning".

Why?

There are countless research papers indicating the effects of Peer Learning, to name them all here would take far more time than you or I have to spare.

Peer learning gives the learners considerably more practice than traditional teaching and learning methods in taking responsibility for their own learning and, more generally, learning how to learn.

These methods improve problem- solving strategies because the students are confronted with different interpretations of the given situation. The peer support system makes it possible for the learner to internalize both external knowledge and critical thinking skills and to convert them into tools for intellectual functioning.

Some forms of Peer learning are even said to be closely approximating Habermas' notion of an 'ideal speech act' in which issues of power and domination are less prominent than when one party has a designated 'teaching' role and thus takes on a particular kind of authority for the duration of the activity.

When reciprocal peer learning was applied in an anatomy course at the Mayo Clinic College of Medicine. All of the students alternated between being the teacher and the learner. The students taught course content and explained procedures to their peers. After doing various reciprocal peer learning activities, they gave a debriefing questionnaire and the results were that 100% of the students increased their understanding of course content because they taught it and 97% agreed that it increased their retention of knowledge they taught to their peers. Also, 92% agreed that it improved their communication skills, which could then be used anywhere.

And that's not just it, the list goes on.

Peers gain a deeper understanding of what they teach to other peers, which benefits them as well as the peer they are helping, also incubating the habit of exchanging ideas.
Peers feel more comfortable and would open up and interact more with other peers rather than teachers or staff.
It creates greater confidence and independence in learning, deeper understanding and improved grades for both peer leaders and their students.
Peers acquire certain organizational and planning skills because they work collaboratively with others, give and receive feedback, and evaluate their own learning.
The benefits/effects of peer learning are not just limited to educational areas, but also sociological.
Peer Learning boosts social skills, and the ability to collaborate, and exchange ideas, not just academically, but also emotionally.
Peer tutoring is cost-effective, has a sound theoretical basis and has demonstrated a positive impact on student learning

Peer learning can be practiced at every level, in schools, universities, work places, or independently.

Peer Learning in Corporate World.

Most of the corporations see Peer Learning as a cost-efficient and effective alternative to hiring alien resource-experts, and instead invest in facilitating Peer Learning, creating an interesting work experience. British Telecom, having adopted Peer Learning systems, saved $12,000,000 of benefits per annum from its peer-to-peer learning system in terms of cost savings and performance improvements.

On the other hand, employees benefit more with these strategies than the usual external experts or training days, A learner’s development is dependent on a willingness to make mistakes, challenge ideas, and speak up about concerns. Unlike some learning methods, like tests or exams, or high-pressure demonstrations of skills, peer-to-peer learning creates a space where the learner can feel safe taking these risks without a sense that their boss is evaluating their performance while they are learning. You’re more likely to have candid conversations about areas you need to develop with a peer than with someone who has power over your career and income. In peer-to-peer learning, the dynamics of hierarchy disappear.

A secondary benefit of peer-to-peer learning is that the format itself helps employees develop management and leadership skills. Group reflection conversations help employees master the difficult skills of giving and accepting honest, constructive feedback. Because feedback flows in both directions, participants in peer-to-peer learning tend to put more time and energy into making sure the feedback they provide is meaningful.

Some research even goes on to say, that Peer Learning is not just an "add-on" to enhance the learning process, but is "necessary for optimal active learning" and is "essential to growing critical thinking and problem-solving skills."

About us

hyperlog.club is a community of programmers who help each other in learning new technologies. We are currently working on a product that sets a clear path with aggregation of multiple free tutorials available around the web to learn a specific technology while cultivating the practice of Peer Learning. And the best part is we are completely open-source and free. So everyone is welcome to join in with our initiative and contribute to the library of tutorials. You can join the discord server here.

External Links

Which programming language should you learn in 2020?

Aditya Giri — Fri, 08 Nov 2019 17:34:54 +0000

The programming world moves fast. There are a ton of different programming languages spawning every year. Enterprises use these languages as per how they cater to their needs. A couple of years ago, the de-facto language of any enterprise used to Java. But in the current day, the scenario has changed completely. (We still have java as a candidate here 😉)

In this article, we have compiled the top trending languages that enterprises are using. For each language, we have divided the section into the main feature of the language, job market, usability, career paths, and average global salary of that particular language.

**NOTE: The data in this article is compiled from various sources such as Hired, and StackOverflow Survey.

1. Go

Go Language has been one of the top trending languages of 2019. It was introduced in November 2009, which now completes a decade of Go. It was developed by Google and is currently actively used by large corporations such as SoundCloud, Netflix, and Dropbox.

The reason behind such a drastic growth of Go language is the advantage for multithreaded tasks such as efficient processing of parallel processes, using memory only when it is necessary, and fast start-up time.

There are a lot of career opportunities for Go. The demand for Go developers is quite high. Since it is one of the most in-demand programming languages, it is always a good choice to start learning Go.

The average global salary for a Go developer is around $109k.

2. Rust

Rust language is developed by Mozilla Research back in 2010. It is the most loved language in StackOverflow annual survey since 2016, every year. Rust is being used in a wide variety of tasks. There are web browsers, operating systems, as well as GPUs being programmed using rust language. It has picked up its pace in systems programming. Some developers believe it can replace C/C++ for low-level programming. Rust is being used in some of the largest corporations which include Google, Microsoft, Cloudflare, and Dropbox.

Rust is a multi-paradigm system programming language that mainly focused on safety. It specializes in safe concurrency, and memory safety while maintaining high performance. It is intended for highly concurrent, highly safe systems and programming in the large.

Job opportunities are plentily available for rust developers. Since the language is relatively new and is being adopted by such a wide community, this is the least of the problems.

The average global salary for a rust developer is around $90k.

3. Elixir

Elixir language is developed by José Valim in 2011. It was developed with the primary goals of enabling higher extensibility and productivity in the Erlang VM while keeping the compatibility with the Erlang's ecosystem. Elixir is built on top of Erlang and BEAM VM. It is primarily used for web development, but there are a lot of other cases in which it is being used. Elixir is being adopted in large companies such as Apple, Discord, and Pinterest.

Elixir is a functional, concurrent, general programming language. Since it is built on top of Erlang, it shares similar abstractions for building distributed, fault-tolerant applications. Elixir also has support for metaprogramming with macros and polymorphism via protocols.

The market is still evolving and providing an average number of job opportunities for Elixir developers at the moment. But considering its adoption at large companies such as Apple, Elixir will definitely be one of the most in-demand programming languages in the near future.

The average global salary for Elixir developer is $102k.

4. JavaScript

JavaScript is a widely known programming language. It is used to write web apps on both the front and back end. This language is used by almost every company in the world as it is an essential component for building interactive web pages. Some of the various career paths that you can take using JavaScript are Front end developer, back-end developer, and Full Stack Developer.

JavaScript is a multi-paradigm language. It supports event-driven, functional and imperative programming styles. Initially, it was only used as a client-side language, but recently, it is being used in almost every other task except system-level programming. The language has support for dynamic typing, prototype-based object-orientation, and first-class functions. It has been rebranded to ECMAScript but continues to be called JavaScript as usual.

The job market for JavaScript is always active. There are a ton of different jobs on multiple different job boards.

The average global salary for JavaScript developer is $100k.

5. Python

Python language was released 29 years ago in 1991. Since then, the language has taken the industry by a storm. It is used for a variety of tasks including, but not limited to Machine Learning, web development, artificial intelligence, and data science. It is used by a variety of large enterprises such as Google, Microsoft, and Facebook.

Python is dynamically typed and garbage collected language. It supports procedural, object-oriented, and functional programming paradigms. It is also known as "batteries included" language due to its comprehensive standard library.

Python remains always active in the job market.

The average global salary for Python developer is $96k.

6. Java

The Java programming language is one of the most highly-demanded among employers and popular among developers according to the GitHub team. Java is used to develop products in the banking sector and in automated testing. It is especially appreciated for its cross-platform thanks to JVM. It is used by almost all major banking institutions.

I don't really need to give the major Java features, but still for the sake of writing, here they are. It is class-based, object-oriented and s designed to have as few implementation dependencies as possible. With JVM, it aims to achieve write once, run anywhere concept. Java is compiled to bytecode which can run on any JVM regardless of computer architecture.

The job market for java remains stable. Although, the market is quite saturated. I wouldn't personally recommend going after this language just to land a job post.

The average global salary for Java developer is $100k.

7. Ruby

Ruby gained the utmost popularity as a tool for developing Web apps, and it was used for developing the server part of many popular worldwide services. The language was built by keeping in mind short development time, clarity and simplicity. It is used by multiple large corporations such as Github, and Basecamp.

Ruby is dynamically typed and uses garbage collection. It supports multiple programming paradigms such as procedural, object-oriented, and functional programming.

The job market for ruby is quite active. Recruiters love the veterans of Ruby language with experience of 10+ years according to Hired.

The average global salary of Ruby developer is $94k.

8. Scala

Scala is a language developed 15 years ago based on the top of Java. It provides language interoperability with Java. Scala is used for web and desktop app development, distributed applications, data analysis, and data streaming. It is used by tech behemoths such as LinkedIn, Twitter, and Netflix.

Scala is a general-purpose programming language providing support for functional programming and a strong static type system. It includes many major features you can expect from programming languages with the functional paradigm.

The job market for Scala is quite stable. I'd recommend you learn Scala over Java in the current day.

The average global salary for Scala developer is $104k.

9. Clojure

Clojure is another programming language developed at supported strongly by Google. It was released 12 years ago in 2007. Clojure is a modern, functional, and dynamic dialect of the List programming language on Java platform. It is used by the likes of CircleCI, Braintree, and Groupon.com.

Clojure language advocates immutability and immutable data structures. This focus on immutability and explicit progression-of-time constructs facilitate more robust, and concurrent programs. These programs are simple and fast.

Clojure has an active demand in the market. Since a lot of enterprises have started a slow switch to Clojure, expect this trend to grow over the years.

The average global salary of Clojure developer is $96k.

10. Kotlin

The programming language Kotlin developed by the IT-company JetBrains has become the official development language for Android. This was officially announced at the Google I/O conference in 2017. It is quite possible that soon the apps for Android devices will be written exclusively using Kotlin, so those wishing to progress in the mobile development direction are advised to take a closer look at it. Since Android apps will soon be completely switched to Kotlin, multiple companies have started using it.

Kotlin language has easy to understand and laconic syntax, full compatibility with Java, and a growing community. Most of all, it has strong support from Google.

The job market has steadily been demanding more and more kotlin developers.

The average global salary of Kotlin developers is $75k.

Conclusion

So the main conclusion that can be drawn from these recent trends in languages, is that functional programming is on the rise. There is an upward trend for raw power and performance optimization. And most importantly, there is a need for developers to keep updated with these languages.

It can be really intimidating when you start out in one of these languages and don't which clear pathway you should take. That's why we have been working on a free and open-source community hyperlog.club where you can go through aggregated resources from the internet to master any given technology. We are currently slowly expanding our library. Since we are completely open-source, you can even contribute to our growing list of resources. You can join the community discord server right now.

Do you think these programming languages will dominate the market in the coming years? Let me know your thoughts on it in the discussion on dev.to

How to learn Programming?

Aditya Giri — Thu, 07 Nov 2019 07:52:26 +0000

Computers were invented back in the 20th century and they have become a basic necessity of almost every human being at the current point. With the rise of the Internet, people are getting more closer digitally. And what this has done, is it has created this new stream of jobs with it. And in the current date, it is one of the highest-paid jobs in the world.

So you are interested to become a programmer. You want a job as a software developer. There are a bunch of ways you can go about it. Let's divide the two major forms through which you can learn programming.

Traditional Ways
Modern Ways

Traditional Ways

As the computers started becoming mainstream, colleges and universities started to embed computing and programming related activities into their syllabus. In the current day, every university provides a degree in computer science. You can easily achieve programming skills with tutoring from top-notch professors (If you manage to get in hi-fi university) and like-minded individuals.

The benefit of going through the traditional way of learning is that the path that you should be taking to attain a certain level of skills where you become hirable is already set. You will just have to follow what your teacher asks you to do. If there are any doubts you have, you can clear them up with your teachers. And biggest of all, you can call yourself "Computer Scientist". A degree is worth more than skills. And also the placements are provided through your college/university itself.

But with this all, there comes a huge downside. These downsides can be divided by country. Universities cost a lot of money if you are in the USA. It is not feasible at all to attend university. In India/Pakistan, the current state of engineering is really bad. Outdated technologies are being taught in colleges. In Europe, it is okay to get a university education but still a lot more costly than the modern ways of learning.

You can choose the traditional way of learning at your risk.

Modern ways

With the rise of computers, the internet became completely mainstream. What this has allowed is a free exchange of information and knowledge on the largest scale. There was a time when to get into the field of computers, you'd need a computer science degree. But thankfully, we don't live in such a time anymore.

You can find many awe-inspiring stories at No CS Degree. In the industry, there is a new trend of self-taught programmers. These programmers have not gone through the traditional forms of learning institutes. They have taught themselves programming through various resources available on the internet.

Perhaps the most interesting and inspiring read that you can have for the day is this: Programming with a feature phone

If he can do programming on a Nokia feature phone, and get a job in MIT startup, you can too. So let's see how exactly should you be learning to program in modern ways.

1. Online Bootcamps

There are a ton of different bootcamps available nowadays. They range from front-end development, back-end development, app development to even data science. All these bootcamps are awesome if you want to start learning from home while doing your degree with it. These bootcamps provide you a clear pathway. Usually, they cost anywhere from 1,000$ to 20,000$. But there are some free coding bootcamps available too, like FreeCodeCamp.

There is a trend of ISAs (Income Share Agreement) nowadays. So you can learn from these coding bootcamps without paying any upfront fees. Lambda School is one of the most prominent Bootcamp that does this.

2. MOOCs

A ton of different universities recently started to think about how to make this computer education reach the masses. And with this, there is the rise of online courses. Universities have started putting out Massive Online Open Courses. These courses are available for free of cost. Some universities that put out such courses are MIT, whose content is accessible through the MIT OCW. There are Stanford courses accessible through YouTube. Other universities put out the similar kind of courses on the platforms such as Coursera, and edX. If you would like to simulate the entire course structure like a computer science degree, OSSU is a great resource.

3. Online Tutorials

You can learn almost any technology available with the help of the internet. And there are a ton of tutorials associated with each one available. Most of the tutorials are available for free. And this is the most common way most of the self-taught programmers use. They sniff through almost every tutorial available and put it all together like puzzle pieces. The most important thing that is required if you ever end up following this path is your dedication.

The most important caveat in learning from online tutorials is that no clear pathway is set up in front of you. And that is exactly what we are here for. hyperlog.club is a community of programmers who help each other in learning new technologies. We are currently working on a product that sets a clear path with the aggregation of multiple free tutorials available around the web to learn a specific technology. And the best part is we are completely open-source and free. So anyone can join in with our initiative and contribute to the library of tutorials. So enough with the shameless plug now.

These are the most common ways you can learn programming from. There might be something that I missed in this article. Please feel free to share your thoughts with me. If you are reading on dev.to, please comment below, if not, just click here to go to dev.to article.

Which JavaScript framework should you learn in 2019?

Aditya Giri — Wed, 30 Oct 2019 09:19:27 +0000

There was a time when there was only one JavaScript library that everyone used, and that was jQuery. But recent years have seen the rise of various front-end frameworks.
In this article, I will tell my top picks for which framework you should learn in 2019.

1. Vue

Vue was created back in 2014 by Evan You. It has risen to become the most popular framework in JavaScript world very quickly. Currently, it has over 150k+ stars on Github. The learning curve with this framework is really low. If you are completely new to the concept of JavaScript frameworks, you should start with Vue.

2. React

React is a front-end framework created by Facebook in 2013. It is used extensively in the Facebook ecosystem of apps and is also trusted by most enterprises. This framework is loved by people for a unique way of building web apps with JSX. The learning curve for this framework is a little steep, but once you get hang of using HTML inside JavaScript files, you can do wonders with this framework.

React also has a big developer community around it which has built some great tools like Gatsby and Next. A lot of learning resources are available for React around the web at the moment.

3. Angular

Angular is one of the oldest framework there is. It is a TypeScript-based open-source web application framework led by the Angular Team at Google and by a community of individuals and corporations. This framework has been written in TypeScript recently. TypeScript is Strictly Typed JavaScript. Most of the enterprises prefer to use Angular for building their web apps because of the legacy support they provide. The community around Angular is also one of the most helpful communities out there. Angular is a really easy framework to learn.

4. Svelte

Svelte is a new framework that has been taking over other frameworks. According to their website:

Svelte is a radical new approach to building user interfaces. Whereas traditional frameworks like React and Vue do the bulk of their work in the browser, Svelte shifts that work into a compile step that happens when you build your app.

When I had tried out svelte, it didn't take me more than a couple of hours to learn the basics of the framework. The best part about svelte is the performance that it brings to the table.

Since this is a fairly new framework, the number of resources that you can find to learn Svelte are low. But it is a good framework that will soon be on the must-know list.

5. Ember

Ember is among the oldest frameworks in this list. Ember has been around for over 7 years. The reason why I love Ember is because of the elegant way that code can be written in it. It allows developers to create scalable single-page web applications by incorporating common idioms and best practices into the framework. Ember is used on many popular websites, including Apple Music, Square, Inc. You can learn Ember easily since it has awesome resources for newcomers.

One of the caveats while learning these above frameworks can be where should I start? Just with that question, we have built a new community of developers who help you learn anything related to web development. You can join the community at hyperlog.club now.