It’s been a while. Maybe longer than I’d like to admit. If you’ve ever stepped away from technical blogging or any creative outlet, you’ll understand the weird cocktail of excitement and hesitation that comes with coming back.

But here I am. And maybe you’re thinking of doing the same. So let’s talk about it.

Why I Stopped Blogging

Life happens. Work got intense. Priorities shifted. The "write about this later" tab kept growing dust. Somewhere along the way, I convinced myself that I needed to have something big, profound, or perfect to say before hitting “publish.”

But here's the thing: the best blog posts aren't necessarily revolutionary. They’re real. They share what you’ve learned, what you’re struggling with, and what excites you. And over time, that builds something valuable for readers and for yourself.

Why I’m Starting Again

Because technical blogging is powerful.
Not in the influencer, “build a massive audience” kind of way (though that can happen too), but in the personal growth, clarity of thought, and community building kind of way.

Writing forces you to slow down, organize your ideas, and explain them clearly. That process alone sharpens your understanding like nothing else. It’s like pair programming with your past self and future readers.

And honestly? I miss that.

Getting Back Into the Flow

If you're like me and thinking of jumping back in, here’s what’s helping me ease into it without overthinking.

1. Start Small.

You don’t need a 3,000-word deep dive on distributed systems. Write about that cool CLI trick you used this week. Or that weird bug you fixed. Or a “How I thought X worked, but it actually works like Y” post.

2. Be Honest.

It’s okay to say, “I’m relearning this myself.” People love authenticity. You're not writing a textbook. You're writing a story. Your story.

3. Focus on Consistency, Not Perfection.

One post is better than none. A short post is better than a draft that never sees the light of day. Set a low bar. You can always raise it later.

4. Write for Yourself First.

Even if no one reads it (spoiler: someone will), you’re creating your own reference material. And your future self will thank you.

5. Reconnect With the Community.

Comment on other blogs. Share your post with friends or on dev communities. Blogging doesn’t have to be a solo act.

So, What’s Next?

I’m committing to writing again. Maybe weekly, maybe biweekly. I’ll write about things I’m learning, projects I’m working on, and the occasional rant about why some error messages still suck in 2025.

If you're thinking of coming back to blogging too, consider this your nudge. Dust off that draft folder. Hit publish. Doesn’t matter if it's perfect.

Just start.

TL;DR: It’s never too late to return to technical blogging. You don’t need to be perfect, just honest and curious. Let’s build and learn out loud. Again.

In the fast-evolving world of AI, "agents" have become a buzzword, promising autonomous systems that go beyond simple chatbots. Drawing from Andrew Ng's seminal talk at Sequoia Capital's AI Ascent in March 2024, this post explores what AI agents really are, how they work, and why they're set to transform industries. Andrew Ng, a pioneer in deep learning, argues that agentic workflows’ iterative processes mimicking human thinking could deliver GPT-5-level performance using today's models like GPT-4. Let's dive in.

What Makes an AI Agent?

Traditional AI interactions are "non-agentic": You prompt a model like ChatGPT, and it generates a response in one go. It's impressive but limited like asking someone to write an essay without revisions.

Enter agentic workflows. These are looped processes where the AI plans, acts, observes, and refines. For example, to write an essay, an agent might outline, research via web tools, draft, self-critique, and revise. The result? Dramatically better outputs.

Ng illustrates this with benchmarks:

• HumanEval (Coding): Zero-shot GPT-4 solves 67% of problems. But wrap GPT-3.5 in an agentic loop, and it hits ~85%—surpassing the more advanced model (Evaluating Large Language Models Trained on Code, Chen et al., 2021).

• GSM8K (Math Problems): Similar gains, showing agents amplify existing models.

True agents aren't fully autonomous yet, but these workflows are a crucial step toward AGI.

The Four Pillars of Agentic Design

Andrew Ng outlines four patterns:

1. Reflection: The AI reviews its own work. Prompt it to "check your code for bugs and efficiency," and it iterates. Papers like Self-Refine show GPT-4 improving itself without extra data.

2. Tool Use: Agents call external resources. Gorilla fine-tunes models for API calls, outperforming GPT-4; MM-REACT integrates vision tools for multimodal tasks.

3. Planning: Break tasks into steps with Chain-of-Thought prompting. It turns flat performance curves into steep gains on reasoning benchmarks.

4. Multi-Agent Collaboration: Teams of agents specialize and debate. ChatDev simulates a company (CEO, coder, tester) to build software; multi-agent debates (e.g., GPT vs. Gemini) boost accuracy.

These patterns are messy but potent. Reflection is reliable, while multi-agent can be "mind-blowing" but inconsistent.

Building and Applying Agents Today

You don't need code. Tools like n8n, CrewAI, Autogen, LangChain let you prototype workflows. Ng advises focusing on fast models for more iterations. Speed enables 100x loops, potentially outpacing slower, smarter models.

Applications? Automate coding, research, or even game development. For businesses, this means productivity leaps; for developers, it's a new paradigm.

Recommended Reading

1. Reflection

   • Self-Refine: Iterate Refinement with Self-Feedback, Madaan et al. (2023)

   • Reflexion: Language Agents with Verbal Reinforcement Learning, Shinn et al. (2023)

2. Tool Use

   • Gorilla: Large Language Model Connected with Massive APIs, Patil et al. (2023)

   • MM-REACT: Prompting ChatGPT for Multimodal Reasoning and Action, Yang et al. (2023)

3. Planning

   • Chain-of-Thought Prompting Elicit Reasoning in Large Language Models, Wei et al. (2022)

   • HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face, Shen et al. (2023)

4. Multi-Agent Collaboration

   • Communicative Agents for Software Development, Qian et al. (2023)

   • AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation, Wu et al. (2023)

AI agents aren't hype, they're here. By embracing agentic workflows, we can unlock unprecedented potential. The set of tasks that AI can do will expand dramatically because of agentic workflows. We have to get used to delegating tasks to AI agents and patiently wait for a response.

My Journey to Neovim

After using VSCode for more than 5 years, I found myself increasingly frustrated with its performance and the distractions that came with its extensive plugin ecosystem. While VSCode is known for its user-friendly interface and rich feature set, I felt that it was becoming more of a hindrance than a help. 5 years ago I wrote this blog post about trying out Vim. But in practice I never picked up vim as my text editor until a year ago. I was using Vim keybindings in VSCode. Later i started looking into Neovim setups and workflows. The desire for a more streamlined and efficient coding experience led me to explore Neovim. Though I am not yet efficient in Neovim but really enjoying the learning process and using lazy.nvim made it easier for me to use.

Pros of Using Neovim

1. Speed: One of the most significant advantages of Neovim is its speed. With a startup time of around 94 milliseconds (even with multiple plugins), it is far quicker than VSCode, which can take several seconds to launch, even without extensions. This performance boost allows me to jump into coding almost instantly.

2. Customizability: Neovim offers unparalleled customizability. Users have complete control over their editor's appearance and functionality through configuration files. This flexibility allows me to create an environment tailored specifically to my workflow, enhancing my overall productivity.

3. Keyboard-Centric Workflow: The modal nature of Neovim encourages a keyboard-driven approach to coding. Once familiar with the keybindings, I found that I could navigate and edit text much more efficiently than in VSCode, where reliance on the mouse can slow down productivity.

4. Minimalism: Switching to Neovim has helped me embrace a more minimalist approach to coding. I realized that many features I thought were essential in VSCode were actually unnecessary distractions. This shift in mindset has allowed me to focus on what truly matters—writing code.

5. Community and Resources: The Neovim community is vibrant and supportive, providing numerous resources for learning and troubleshooting. The availability of plugin managers like lazy.nvim makes it easier to manage configurations and enhance functionality without overwhelming complexity.

Cons of Using Neovim

1. Steep Learning Curve: Transitioning from VSCode to Neovim requires a significant investment in time and effort. Learning Vim keybindings and configuring the editor can be daunting at first, especially for those accustomed to the simplicity of point-and-click interfaces.

2. Initial Setup Complexity: Setting up Neovim with all the desired plugins and configurations can be time-consuming. Unlike VSCode, which offers a more straightforward installation process for extensions, Neovim requires users to manually configure their environment.

3. Missing Features: While many features available in VSCode have equivalents in Neovim, there are some functionalities that may not translate directly or require additional configuration (e.g., advanced search capabilities or integrated debugging tools).

4. Potential Frustration: For those who are not willing to invest the time needed to learn and customize Neovim, it can lead to frustration. Some users may find themselves longing for the convenience of VSCode’s built-in features and extensions.

Why I Chose Neovim Despite Controversies

Despite the mixed opinions surrounding Neovim—ranging from advocates praising its efficiency to critics highlighting its steep learning curve—I ultimately chose it for several reasons:

• Increased Productivity: After dedicating time to learn Neovim, I found that my productivity skyrocketed compared to my time spent in VSCode. Many users report being two to five times more productive after fully embracing Neovim's capabilities.

• Satisfaction from Mastery: There is immense satisfaction in mastering an editor you have configured yourself. The process of customizing my environment has not only improved my workflow but also rekindled my love for programming.

• Performance Over Features: While VSCode offers many features out-of-the-box, I found that performance was often compromised for convenience. In contrast, Neovim’s speed and responsiveness allow me to focus on coding without lag or interruptions.

• Community Support: The active community around Neovim provides ample resources for learning and troubleshooting, making it easier for newcomers to get up to speed despite initial challenges.

Conclusion

Switching from VSCode to Neovim is a journey filled with challenges and triumphs. By embracing the speed, customizability, and keyboard-driven efficiency that Neovim offers, I have transformed my coding experience into one that is both productive and satisfying. While there are valid concerns about the learning curve and initial setup complexity, the long-term benefits far outweigh these drawbacks for those willing to invest the time.

For anyone considering making the switch, I encourage you to dive into the world of Neovim—embrace the challenge, customize your environment, and discover how this powerful editor can enhance your programming workflow.

Next.js is a React framework that offers Server-Side Rendering (SSR) and Static Site Generation (SSG) along with some other handy features like:

• Incremental Static Generation
• TypeScript Support
• Fast Refresh
• Filesystem-based Routing
• API Routes
• Built-in CSS Support
• Code Splitting and Bundling

I will give a brief overview of my Next.js setup with TypeScript, ESLint, Jest, and TailwindCSS from scratch. This will give you a good starting point for your Next.js projects. So, If you are starting a new project in Next but you are not sure how to set it up then this post is for you. This might save you some time on the initial setup and get you up and running quickly. Let's get started.

Installing NextJS

We will use create-next-app to generate your Next.js application. You need to have NodeJS 10.13 or later installed. We will use npm as a package manager.

npx create-next-app my_next_app

This will create a fresh Next.js application in the my_next_app directory. The folder-structure of your app should look like this:

my_next_app
├── node_modules
├── package.json
├── package-lock.json
├── pages
│   ├── api
│   │   └── hello.js
│   ├── _app.js
│   └── index.js
├── public
│   ├── favicon.ico
│   └── vercel.svg
├── README.md
└── styles
    ├── globals.css
    └── Home.module.css

Now, we will change this structure a little bit. We will create a directory called src in the root of our project and move pages, public and styles directories in the src directory. We can also make directories like components, helpers, 'lib' etc in the src directory to organize everything properly. Now start our dev server.

npm run dev

This will run the Next.js development server on 127.0.0.1:3000. If everything is fine then you should see the Next.js project starter page on your localhost:3000.

Setting Up TypeScript

It is very easy to set up TypeScript in your Next.js project. First, install TypeScript along with React and Node types.

npm install --save-dev typescript @types/react @types/node

Now, we can change the .js files to .ts(x) files.

src/pages/api/hello.js -> hello.ts
src/pages/_app.js -> _app.tsx
src/pages/index.js -> index.tsx

Hope you get the idea. Now replace the content of your src/pages/_app.tsx with the following code:

/* 
 * _app.tsx file
 */
import { AppProps } from 'next/app'

function App({ Component, pageProps }: AppProps ){
  return <Component {...pageProps} />
}

export default App

Like the above, we need to replace all the js code to its equivalent ts code. After that stop the dev server (if it's running) and start it again. Next.js will automatically detect TypeScript and generate a tsconfig.json file and a next-env.d.ts file for you. Your basic TypeScript setup is done.

Setting up ESLint

For large TypeScript of JavaScript projects code consistency and following the best practices are very important. That's where ESLint comes in. To setup ESLint in your Next.js application install ESLint as a devDependency

npm i -D eslint eslint-plugin-react @typescript-eslint/eslint-plugin @typescript-eslint/parser

Then we have to create a eslintrc.json file and put the following content in it.

// eslintrc.json file
{
  "env": {
    "browser": true,
    "es6": true
  },
  "extends": [
    "eslint:recommended",
    "plugin:react/recommended",
    "plugin:@typescript-eslint/eslint-recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "globals": {
    "Atomics": "readonly",
    "SharedArrayBuffer": "readonly",
    "React": "writable"
  },
  "parser": "@typescript-eslint/parser",
  "parserOptions": {
    "ecmaFeatures": {
      "jsx": true
    },
    "ecmaVersion": 2018,
    "sourceType": "module"
  },
  "plugins": ["react", "@typescript-eslint"],
  "rules": {
    "react/react-in-jsx-scope": "off"
  }
}

Setting up Jest for Testing

Now it's time to set up the testing framework Jest. Jest works pretty well with React and Next. First, install Jest as a devDependency.

npm i -D jest ts-jest babel-jest react-test-renderer @types/jest @testing-library/react @testing-library/jest-dom

Now, we create a .babelrc file with the following:

# .babelrc file
{
    "presets": ["next/babel"]
}

Then we shall create a jest.config.js file with the following content:

// jest.config.js file
module.exports = {
    collectCoverageFrom: [
      "**/*.{js,jsx,ts,tsx}",
      "!**/*.d.ts",
      "!**/node_modules/**",
    ],
    setupFilesAfterEnv: ["<rootDir>/setupTests.js"],
    testPathIgnorePatterns: ["/node_modules/", "/.next/"],
    transform: {
      "^.+\\.(js|jsx|ts|tsx)$": "<rootDir>/node_modules/babel-jest",
      "^.+\\.css$": "<rootDir>/config/jest/cssTransform.js",
    },
    transformIgnorePatterns: [
      "/node_modules/",
      "^.+\\.module\\.(css|sass|scss)$",
    ],
    moduleNameMapper: {
      "^.+\\.module\\.(css|sass|scss)$": "identity-obj-proxy",
    },
    //additional prop from a github issue: https://github.com/zeit/next.js/issues/8663
    preset: "ts-jest",
    testEnvironment: "jsdom",
    globals: {
      // we must specify a custom tsconfig for tests because we need the typescript transform
      // to transform jsx into js rather than leaving it jsx such as the next build requires.  you
      // can see this setting in tsconfig.jest.json -> "jsx": "react"
      "ts-jest": {
        tsConfig: "tsconfig.jest.json",
      },
    },
  }

After that, we have to create a tsconfig.jest.json file like the following:

// tsconfig.jest.json
{
    "extends": "./tsconfig.json",
    "compilerOptions": {
      "jsx": "react"
    }
}

Now, we have to create a setupTests.js file like the following:

/*
 * setupTests.js file
 */
// optional: configure or set up a testing framework before each test
// if you delete this file, remove `setupFilesAfterEnv` from `jest.config.js`

// used for __tests__/testing-library.js
// learn more: https://github.com/testing-library/jest-dom
import '@testing-library/jest-dom/extend-expect'

The last file we need to create for Jest is a cssTransform.js in the config/jest directory.

/*
 * cssTransform.js file
 */
module.exports = {
    process() {
      return 'module.exports = {};'
    },
    getCacheKey() {
      return 'cssTransform'
    },
}

Then finally in our package.json file, we have to add the following two scripts.

// package.json file
{
  ...,
  "scripts": {
    ...,
    "test": "jest --watch",
    "test:ci": "jest --ci"
  },
  ...
}

The Jest framework is set up now. We will add a simple test now. For this, we will create a small component and test if that component renders without any error. Here I used the Avatar component which simply shows an avatar image. My src/components/avatar.tsx file looks like the following:

// src/components/avatar.tsx file
function Avatar() {
    return (
        <div className="avatar">
            <img src="/avatar.png" alt=""/>
        </div>
    )
}

export default Avatar

We will render this component in our Index page which is the src/pages/index.tsx file. To test this component let us create a src/components/__tests__/avatar.test.tsx file.

// src/components/__tests__/avatar.test.tsx file
import React from "react"
import Avatar from "../avatar"
import TestRenderer from "react-test-renderer"
import { cleanup } from "@testing-library/react"

afterEach(cleanup);

describe('Avatar', () => {
    it('should render without throwing an error', () => {
        const testRenderer = TestRenderer.create(<Avatar />);
        expect(testRenderer.toJSON()).toMatchSnapshot();
    });
})

To run the test use

npm run test

Setting up TailwindCSS

TailwindCSS is a utility-first CSS framework and it works well with React and Next. We will add Tailwind as a PostCSS plugin to our project. To install TailwindCSS and PostCSS:

npm i -D tailwindcss postcss-preset-env postcss-flexbugs-fixes

Now, we have to create a tailwind.config.js file and a postcss.config.js file in our project root.

// tailwind.config.js file
module.exports = {
  future: {
    removeDeprecatedGapUtilities: true,
  },
  purge: ['./src/components/**/*.{js,ts,jsx,tsx}', './src/pages/**/*.{js,ts,jsx,tsx}'],
  theme: {
    extend: {
      colors: {
        'accent-1': '#333',
      },
    },
  },
  variants: {},
  plugins: [],
}

// postcss.config.js file
module.exports = {
  plugins: [
    'tailwindcss',
    'postcss-flexbugs-fixes',
    [
      'postcss-preset-env',
      {
        autoprefixer: {
          flexbox: 'no-2009',
        },
        stage: 3,
        features: {
          'custom-properties': false,
        },
      },
    ],
  ],
}

Now replace everything from your src/styles/globals.css with the following:

@tailwind base;

/* Write your own custom base styles here */

/* Start purging... */
@tailwind components;
/* Stop purging. */

/* Write you own custom component styles here */

/* Start purging... */
@tailwind utilities;
/* Stop purging. */

Now, import this globals.css file in your src/pages/_app.tsx file like:

// src/pages/app.tsx file
import '../styles/globals.css'

We are all set up now and ready to start building our Next.js application. One final thing I want to do is to add some Tailwind utility classes to our page. Here is our src/pages/index.tsx

// src/pages/index.tsx

import Head from 'next/head'
import Avatar from '../components/avatar'

export default function Home() {
  return (
    <div className="flex h-screen items-center justify-center">
      <Head>
        <title>My Next App</title>
      </Head>
      <Avatar />
    </div>
  )
}

Finally, we are done setting up everything and testing that they are all working properly. Now, you can start building your awesome Next.js app on top of this boilerplate. You can also find the project boilerplate on Github. Hope this will help you get started with Next.js quickly. Happy coding.

Elixir & OTP

Elixir is a functional programming language. Functional languages are built with functions as first-class citizens and tend to involve a declarative style of programming, where we specify what is to be done rather than focusing on how to do it. Functions are meant to be small and simple, and bigger functions are made by composing the smaller functions together.

Elixir was built on top of a mighty language called Erlang which was originally designed and developed by Erricson in the mid-'80s with the aim of building their telephony software. Elixir is a dynamically-typed language, which means data types are determined in runtime rather than compile time. Elixir code is compiled into bytecode that runs on a virtual machine. The virtual machine is called the BEAM (Bogdan's Erlang Abstract Machine) which is at the core of Erlang Open Telecom Platform (OTP). OTP is a set of Erlang libraries and design principles providing middleware to develop massively scalable soft real-time systems with requirements on high availability. Elixir can interact with Erlang code and can call Erlang libraries if the equivalent functionality doesn't exist in an Elixir library.

Elixir is the perfect blend of the power and robustness of Erlang and developer happiness and productivity of Ruby.

Thinking Functionally

In functional programming, data and function are strictly separated. We should divide our problem domain into smaller modules. Each module will group related functions and they are passed data as parameters and return data to the caller. One of the key concepts of functional programming is Immutable Data, we take the data, and pass it through a series of functions and return the result without mutating the actual data. Functions are simply data transformers. Our entire system should be made of modules that are comprised of such functions. Each module has data representation (optionally), they are called structs.

Let's say we have to return the number of lines, words, and characters of a file, then our approach would be, first to get the raw data of the file, then separate the lines, then for each line, compute the result. The data needs to be passed through all those stages and transformation, in other words:

format_results(calculate_stats(split_lines(read(file)))

This looks cumbersome, but Elixir has a culture of having data as the first argument of functions, that way, we can have the pipe function, which would make it:

file |> read() |> split_lines() |> calculate_stats() |> format_results()

So, it is advisable to set up our functions in such a way that data is on the first argument, the same goes with module functions that take advantage of that module's struct.

We should learn to understand map, filter, and reduce really really well. They can often save us from recursions. And let us work in a beautiful flow.

Patterns are amazing, think of it more like the matching games we used to play as kids, key to enjoying Elixir is understanding and embracing pattern matching

Modular design where data is transformed through functions, and pipes, and patterns emerge are the key to Thinking in Elixir. To be able to think in Elixir we first need to learn to think like functional programmers. For this, we have to grasp the concept of functional programming. Below is a good article on this.

Functional Paradigm

Functional programming is not only about following some rules. It is a different way of thinking about a problem or approaching a problem. It is a declarative approach where we define what needs to be done rather than how to do it. The declarative functional mindset is something we have to master before we can write meaningful functional programs. Without the proper understanding of the functional paradigm, it is very easy to abuse any functional language. That can result in inefficient code. That's why learning to write idiomatic Elixir code is the key to developing robust and performant programs which is the actual purpose of Elixir.

Here is a talk by Dave Thomas on Thinking in Elixir.

Some key concepts of functional programming are:

• Data and functions are separated
• Functions are first-class citizens
• Functions are simply data transformers
• Functions are small and composable
• Data is immutable
• Higher-order functions

Watch this other talk by Dave Thomas for a better understanding.

Conclusion

We have come to the conclusion of this post. After getting the very basics of the Elixir language it is imperative that we spend some time with functional programming and try to conceptualize as much as we can before moving forward with intermediate Elixir. In this post, I have tried to give a brief idea about it. But there are a lot of things to learn. Try to explore by yourself and learn about each topic mentioned in this post. Follow the official documentation , Elixir School and Programming Elixir book if possible. After you are comfortable with the basic concepts of functional programming and Elixir you are ready to dig deeper into the Elixir ecosystem.

Pre-requisites

1. First of all, you will need a running EC2 instance with Ubuntu 18.04 or later. This will also work for VPS servers like DigitalOcean or Linode.
2. If you are using EC2 instance, make sure you configured the VPC and security groups properly and your port 80 is open for inbound and outbound traffic.
3. You have to have Nginx installed and running.
4. You will need Python 3.7 or above installed and any Python virtual environment tool like virtualenv, pipenv, conda, etc. installed.
5. You need to have your FastAPI application on Github/Bitbucket/Gitlab for easy deployment.

After you have ensured that all of the above requirements are met you can move on to the next step. The actual deployment.

Prepare the Application

Now, SSH into the server, create and navigate to the directory that you want your application to be stored into. Say it's /var/www/myapp.

$ mkdir /var/www/myapp 
$ cd /var/www/myapp

We have to make sure that our user has proper read-write access to this directory. In this post, I will use virtualenv to manage a Python virtual environment. You can use whichever you like or prefer. Inside /var/www/myapp we have to do the following one by one:

$ virtualenv -p python3.8 venv
$ mkdir src
$ . venv/bin/activate
(venv) $ cd src

Once inside the src directory, we have to pull our application source code there. Our application source code should contain a requirements.txt file with all the dependencies unless we are using a PIPFILE.

(venv) $ git init
(venv) $ git remote add origin <your-repo-url>
(venv) $ git pull origin <your-branch-name>
(venv) $ pip install -r requirements.txt
(venv) $ pip install gunicorn uvicorn

Configure Nginx

Now our application is ready to be run and tested. To be able to serve the application over HTTP we have to make an Nginx config for our application.

(venv) $ sudo vim /etc/nginx/sites-available/myapp

Put the followings on that file:

server{
       server_name <your-site-name>;
       location / {
           include proxy_params;
           proxy_pass http://127.0.0.1:8000;
       }
}

Now we save the file and exit. Then we make a symbolic link to this config file in the /etc/nginx/sites-enabled directory.

(venv) $ sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/

Then we restart the Nginx service.

(venv) $ sudo systemctl restart nginx.service

Now we can start our uvicorn server to check if our application is working or not.

(venv) $ gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app

In the place of main:app we can use whatever is correct for our application. Now that our application is running and the proxy server is configured properly we should be able to visit the URL and see our application from a browser.

Configure ASGI Server

Now that our application is deployed and configured properly one last thing to do is to create a service for the Gunicorn server so that it is always running and it automatically starts when the server is rebooted. We will user systemd to create the service.

(venv) $ deactivate
$ sudo vim /etc/systemd/system/myapp.service

In this new file we have to put the following:

[Unit]
Description=Gunicorn instance to serve MyApp
After=network.target

[Service]
User=<username>
Group=www-data
WorkingDirectory=/var/www/myapp/src
Environment="PATH=/var/www/myapp/venv/bin"
ExecStart=/var/www/myapp/venv/bin/gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app

[Install]
WantedBy=multi-user.target

Modify the locations as of your own setup and then save and exit the file.

$ sudo systemctl start myapp.service

This will start our new service and our ASGI server will be running in the background.

Back to School

Elixir School is a good starting point for learning Elixir. It has very good official documentation also. We will find it on hexdocs. HexDocs contains the documentation of all the Elixir packages published on Hex, the package manager for the Erlang ecosystem. But we should start with Elixir School for now. For the fundamentals of the language like basic syntax, data types, control structure, functions, modules finish up to chapter 8. We should take our time and do not rush or skip anything. Here we will learn two of the most amazing features of Elixir - Pattern Matching and Pipe Operator. To help with our understanding so far the following video tutorial is recommended.

Functional Paradigm

Besides learning the basics of the language it is imperative that we start learning about functional programming as well. It will definitely take time to get our heads around all of these. But with consistency and perseverance, we will get there. Just do not get overwhelmed and take in a little every day. Here's a must-watch video on functional programming.

We will get some basic ideas about functional programming from this video. It's only scratching the surface. There's much to know and internalize before being able to think functionally. For us who are coming from the object-oriented programming paradigm, it can be quite a hassle to reorient our perspective towards programming. But knowing some other programming language will surely help us understand Elixir better.

Why Elixir Matters?

To know that we should watch the following video. It's perfectly okay to skip this but it may motivate us for the upcoming journey.

Along with all the free resources, The Programming Elixir book by Dave Thomas is highly recommended.

That's it for the first step. That was a lot to take in. But it will be easier for you all to determine if we would like to advance further with Elixir after completing all the resources mentioned here. Feel free to explore the wonderful realm of functional programming. Hope to see you in the next post.

So, What is Elixir?

Elixir is a dynamic, functional language designed for building scalable and maintainable applications. Elixir leverages the Erlang VM, known for running low-latency, distributed and fault-tolerant systems, while also being successfully used in web development, embedded software, data ingestion, and multimedia processing domains. It is built on top of Erlang, which is a battle-tested programming language developed by Ericsson to build massively scalable soft real-time systems with requirements on high availability. Erlang is the reason why Elixir is so mature despite its young age. It is powerful as Erlang and developer-friendly and productive as Ruby. Ruby was built for Developers' Happiness and Productivity. And Elixir syntax is heavily influenced by Ruby. So you will get productivity, performance and happiness.

There are a lot of cool features in Elixir. My goal is to learn as much as possible about this language and share my learnings with others. We will find out about all the cool stuff about Elixir and its ecosystem.

First, A Big Disclaimer

I am a beginner in Elixir and my goal is not to teach anybody anything. I only intend to share my understandings and some learning resources with you all. All sorts of constructive criticism and positive feedbacks are appreciated. And also this will be my own journey and may not cover all the concepts. This is not a tutorial series or crash course. If you really want to dig deeper you must do your own study and research.

Now, What Will We Attempt?

We will try to learn the following topics in the upcoming posts:

• Environment
• Syntax
• Data Structure
• Program Design
• Process and Concurrency Techniques
• Generic Server Process
• Fault-Tolerance
• Some Advanced Topics

Finally, Conclusion of the Intro

This is not a tutorial series or course. In every post, I will share some motivation and learning materials with all of you. Perhaps this will give you some basic idea about Elixir and its ecosystem and encourage you to learn more about it. I will definitely be learning a lot from this as well. So, see you in the first post.

Paradigm

Julia is a multi-paradigm programming language with Multiple Dispatch as its core. It is also Homo iconic, meaning a program written in it can be manipulated as data using the language, and thus the program's internal representation can be inferred just by reading the program itself. Thus it has powerful Metaprogramming capabilities. It combines features of imperative, functional, and object-oriented programming. Julia provides ease and expressiveness for high-level numerical computing, in the same way as languages such as R, MATLAB, and Python, but also supports general programming. To achieve this, Julia builds upon the lineage of mathematical programming languages, but also borrows much from popular dynamic languages, including Lisp, Perl, Python, Lua, and Ruby. Julia is garbage-collected, uses eager evaluation, and includes efficient libraries for floating point calculation, linear algebra, random number generation, and regular expression matching. It supports concurrent, (composable) parallel and distributed computing. A just-in-time compiler that is referred to as "just-ahead-of-time" in the Julia community is used.

Language Features

According to the official website[2], the main features of the language are:

• Multiple dispatch: providing ability to define function behavior across many combinations of argument types

• Dynamic type system: types for documentation, optimization, and dispatch

• Good performance, approaching that of statically-typed languages like C

• A built-in package manager

• Lisp-like macros and other metaprogramming facilities

• Call Python functions: use the PyCall package

• Call C functions directly: no wrappers or special APIs

• Powerful shell-like abilities to manage other processes

• Designed for parallel and distributed computing

• Co-routines: lightweight green threading

• User-defined types are as fast and compact as built-ins

• Automatic generation of efficient, specialized code for different argument types

• Elegant and extensible conversions and promotions for numeric and other types

• Efficient support for Unicode, including but not limited to UTF-8

Type System

Describing Julia in the lingo of type systems, it is: dynamic, nominative and parametric. Generic types can be parameterized, and the hierarchical relationships between types are explicitly declared, rather than implied by compatible structure. One particularly distinctive feature of Julia's type system is that concrete types may not subtype each other: all concrete types are final and may only have abstract types as their supertypes. While this might at first seem unduly restrictive, it has many beneficial consequences with surprisingly few drawbacks. It turns out that being able to inherit behavior is much more important than being able to inherit structure, and inheriting both causes significant difficulties in traditional object-oriented languages.

It has an automatic generation of efficient, specialized code for different argument types. In Julia, the types are run-time objects, and can also be used to convey information to the compiler. Due to the run-time type inference and a strong focus on performance from the inception of the project, Julia’s computational efficiency exceeds that of other dynamic languages. This language solves the two language problem by combining the ease of use of Python and R with the speed of C++.

Julia's type system is designed to be powerful and expressive, yet clear, intuitive and unobtrusive. Many Julia programmers may never feel the need to write code that explicitly uses types. Some kinds of programming, however, become clearer, simpler, faster and more robust with declared types.

Syntax and Package System

Among the languages that inspired Julia is Ruby, so it should come as no surprise that Julia adopted one of Ruby's more iconic features: the do...end block. As is the case with many other features that Julia has adopted, its implementation of do...end is simpler and more flexible than Ruby's. Julia is as easy to learn and use as Python.

Julia has a built-in package manager and includes a default registry system. Packages are most often distributed as source code hosted on GitHub, though alternatives can also be used just as well. Packages can also be installed as binaries, using artifacts. Julia's package manager is used to query and compile packages, as well as managing environments. Federated package registries are supported, allowing registries other than the official to be added locally.

Parallel Computing

Julia has a high-level syntax which makes it easy and accessible language for the programmers from any background. The Julia programs are able to compile efficient native code for multiple platforms via LLVM. It can be said that this language is built for parallelism due to its primitives for parallel computing. The parallelism is divided into three main categories — Julia Co-routines (green threading), multi-threading and multi-core or distributed processing. With scientific computing in mind, this language natively implements interfaces to distribute a process across multiple cores or machines.

Efficiency

This language can be said as the fastest high-performance open source computing language for data, analytics, algorithmic trading, machine learning, artificial intelligence, and other scientific and numeric computing applications. While popular languages like Python can be slower being an interpreted language, Julia has been designed for high-performance functions by the developers. The applications in Julia can be easily compiled to efficient native code. If you call a function in Julia it consumes a little time in the first run but when the same function has been called repeatedly, it shows a much faster outcome than other languages.

My Thoughts on Julia

I have only scratched the surface of the programming language. Surely one weekend is not enough to get a total feel of the capabilities of any language. But with the small amount of study and research I have found some very good features and reviews of Julia. It is a modern programming language designed with performance and ease of use in mind. The Ruby-like syntax is really helpful for developers to quickly pick up the language but the type system can be hard to grasp at first. If you are familiar with Lisp or even Golang you will find it relatively easy to understand and reason about. Functional programming knowledge is another good thing to have while learning Julia. The official documentation page is very descriptive and will provide you with an in-depth idea about the syntax and language features and uses. The package manager is pretty good and Julia already has more than 3000 packages available and the number is growing everyday.

Though the main power of Julia lies in Scientific Computation it is also a great choice for data analytics, machine learning, artificial intelligence, deep learning, computer vision etc. And one can also use it as a general purpose language.

I really like to learn about new and emerging technologies and try to adopt them early if I can. Many big organizations are already using Julia for building their ML or AI solutions and many universities are using it for their research work worldwide. A data scientist can highly benefit in the near future by adopting Julia now. It may not be as popular as any main stream languages today but in a few years it may become a main stream language itself.

Finally I would like to add this. If you want to bet on some tech for the future of data analytics and machine learning then Julia might be the right one.

Reference

1. https://en.wikipedia.org/wiki/Julia_(programming_language)

2. https://docs.julialang.org/en/v1/

Vim has two basic modes:

1. One is INSERT mode, in which you write text as if in a normal text editor.
2. Another is NORMAL mode which provides you efficient ways to navigate and manipulate text. This is also called Command mode cause we can do various vim commands on this mode.

To change between modes, use ESC for normal mode and i for insert mode.

VIM Commands

Cursor Movements

• h to move cursor left (←)
• l to move cursor right (→)
• k to move cursor up (↑)
• j to move cursor down (↓)
• b moves to the beginning of the word
• e moves to the end of the word
• w moves to the beginning of the next word

Number Based Movements

Using a number before each command can execute that command that many times. e.g 3w will move to the 3rd next word.

Insert Text Repeatedly

To insert the same text multiple times use <number>i<text>esc. e.g 3<i>go<esc> will write gogogo.

Find a Character

To find and move to the next (or previous) occurrence of a character, use f and F, e.g. fo finds next 'o'. You can combine f with a number. e.g. you can find 3rd occurrence of 'q' with 3fq.

Go to Matching Parenthesis

In text that is structured with parentheses or brackets, ( or { or [, use % to jump to the matching parenthesis or bracket.

Start/End of Line

To reach the beginning of a line, use 0. For the end of line use $.

Find Word Under Cursor

Find the next occurrence of the word under the cursor with *, and the previous with #.

Go to Line

gg takes you to the beginning of the file; G to the end. To jump directly to a specific line, give its line number along with G. e.g 5G will take you to the fifth line of the file.

Search for Text

Searching text is a vital part of any text editor. In Vim, press /, and give the text to search for. The search can be repeated for next and previous occurrences with n and N respectively. For advanced use cases, it's possible to use regexps that help to find the text of a particular form.

Insert New Line

To insert text into a new line after the current line use o and to insert a new line before the current line use O.

After a new line is created, the editor is set to insert mode.

Removing a Character

x and X delete the character under the cursor and to the left of the cursor, respectively.

Also adding a number before x of X can perform the action that many times. e.g 5x will remove the next five characters including the character under the cursor and 5X will remove the previous five characters excluding the character under the cursor.

Replace a Character

User r to replace only one character under the cursor.

Deleting

d is the delete command. It can be combined it with movements, e.g. dw deletes the characters on the right side of the cursor up to the beginning of the next word. de deletes all the characters of the word on the right side of the cursor including the character under cursor. db will delete the previous word if the cursor is under the first letter of a word or else it will delete the characters left to the cursor upto the beginning of the word.

It also copies the content, so that you can paste it with p to another location.

dd will delete the whole line.

Repeat Command

To repeat the previous command, just use . (period).

Replace Mode

Use R to enter REPLACE mode. In this mode characters under the cursor can be replaced.

Visual Mode

Use v to enter the VISUAL mode and V to enter VISUAL LINE mode. In this mode the text can be selected by the movement keys before deciding what to do with it.

Selected text can be deleted/cut using d or copied using y. It can be pasted after the cursor using p or before the cursor using P.