Laxman Vijay

twitter

facebook

instagram

linkedin

Technology

Your privacy is important to us. We promise not to send you spam!

Get inspired from our coverage of the latest trends and breakthroughs in the world of gaming and AI.

Learn the newest gaming tech updates with our weekly newsletter


Physicists from South Korea have developed a new algorithm that can design a structure that follows along any given path. The idea is based on the simple realization that a spherical clay could be subtly deformed to follow along a random path.

The research team started by envisioning a sphere rolling down a ramp. If the sphere is imagined to be made of clay, it can be manipulated (deformed) as it rolls to make it conform to a given path. If the sphere is then rolled down the ramp again, it will follow the previous path due to the new deformities in its shape. The researchers noted that the paths that could be taken by the sphere could be nearly limitless due to the nearly limitless possible deformations.

That realization led them to wonder if the deformations that form in such a sphere could be corelated mathematically with its path. And if so, if such math could be used to create an algorithm that could be used to 3D print a sphere with deformations that would force it to follow a predetermined path.

Turns out it is possible. The team deviced an algorithm that computes a shape by analyzing a given path. The computed shape is then 3D printed. They named the objects trajectoids. Each had a solid metal ball-bearing inside to give it weight. They also found that they could create trajectoids that traveled over a given path twice, and named them "two-period trajectoids".

## What are the applications?

Turns out this new method could be used in robotics applications and also in physics research associated with the angular moment of an electron—or in quantum research centered around the study of evolution of a quantum bit.

<iframe width="560" height="315" src="https://www.youtube.com/embed/2lW9HznqsVY?si=NdaLqN4Sn4WdNIDK" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

## Code source:

The team also published a Google Colab for reference: https://colab.research.google.com/drive/1XZ7Lf6pZu6nzEuqt_dUCHormeSbCCMlP. The original paper can be accessed in [Nature](https://www.nature.com/articles/s41586-023-06306-y.epdf?sharing_token=MfjPA0Uduzd60wRcg6kvYtRgN0jAjWel9jnR3ZoTv0PI2oLqSz3ENBVadr6bTqqLXcnyfhIenA1AWB-lO_690iJFCALE1LSm57zc7zJ_0tgwc8etNM2RCelBtq8HIqT9EUbdWrgJv4WS2TN3vUg7dNO-otq2THip68dw4Mli0a8%3D) where they describe the process and the applications.

Solid body trajectoids roll along desired pathways

Trajectoids could introduce a new math field


If you are developer, you would have that natural instinct to automate everything that comes along the way. Create a folder? automate. Open browser and Spotify when opening vs code? automate. But. Its not that easy and you know it. We have a couple of options in Mac like Shortcuts and Automator. However, these are UI driven. I know your programmer mind is screaming, “who wants an UI automation tool?”.

But I don’t like going all in on a Python script and running it every time either. Fair enough.

Enter [ScriptKit](https://www.scriptkit.com/)… The very first time I saw ScriptKit and its capabilities, I was completely blown away. Its in this sweet spot between a complete scripting language and a full blown UI automator.  It has endless possibilities on what you could automate with it. The cherry on top? Its in Typescript. Its amazing. 

ScriptKit itself is based on Google’s [zx](https://github.com/google/zx) which is a cli executable for javascript files.

![https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/84ed56b6-98e6-d1cd-a5fe-0bb739554c6a.jpeg](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/84ed56b6-98e6-d1cd-a5fe-0bb739554c6a.jpeg)

In this article, I will be showing 2 examples which are both cool and helpful to get started in ScriptKit.

## Before that,

Here is a very simple hello world script:

```
// Name: Display HTML

import "@johnlindquist/kit"

await div(`<h1>Hello World</h1>`)
```

## Example 1

### Open favourite sites in a click

Opening your favourite sites should be a single one click process and must not involve several steps. Here is a way to achieve it:

```tsx
// Name: Open Favorite Sites

import "@johnlindquist/kit"

try {
    let path = await arg("Type a site to open", [
        {
          name: "Youtube Music",
          description: "Opens YT music in a browser window",
          value: "https://music.youtube.com",
        },
        {
          name: "Pocket",
          description: "Opens Pocket in a browser window",
          value: "https://getpocket.com/saves",
        },
        {
          name: "Archivorous",
          description: "Opens Archivorous in a browser window",
          value: "https://archivorous.com",
        },
      ])

    $`open ${path}`
} catch (e) {
    log(e)
}
```

The script is simple, I define a bunch of sites and open the one I selected using the `zx $` command.

If you don’t believe me about ScriptKit, install and give this script a try with your own favourite sites. You will fall in love ❤️

## Example 2

Are you a fan of smart home devices? You will love this one. Let’s use ScriptKit to automatically turn on/off the smart lights.

One of the best things about ScriptKit is its ability to make HTTP request. Although controlling smart devices is not natively possible in ScriptKit, we can utilise the ever amazing [IFTTT](https://ifttt.com/) to achieve this.

But first, there are a couple of prerequisites: 

- You must have IFTTT setup without your smart device provider ( for example: Philips). The webhook provides complete control over the device. Careful with it.
- You must have a webhook IFTTT action created like this:

![https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/a1cca452-426d-0db6-3eab-3446a3452aa9.jpeg](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/a1cca452-426d-0db6-3eab-3446a3452aa9.jpeg)

Now you can use the script below:

I am using IFTTT free version and so I cannot parse the incoming json in the webhook for dynamically controlling the lights. (But if you do have a pro version, you can use it to write javascript in IFTTT console and dynamically control which light is triggered in a single webook).

But for my purposes, I have created 6 webhooks and integrated them with ScriptKit:

```tsx
// Name: turn on or off smart lights

import "@johnlindquist/kit"

try {
    let selectedLight = await arg("Type a site to open", [
        {
          name: "Playroom on",
          description: "Turn on the playroom light",
          value: "playroom_lights_on",
        },
        {
          name: "Playroom off",
          description: "Turn off the playroom light",
          value: "playroom_lights_off",
        },
        {
          name: "Bedroom on",
          description: "Turn on the bedroom light",
          value: "bedroom_lights_on",
        },
        {
          name: "Bedroom off",
          description: "Turn off the bedroom light",
          value: "bedroom_lights_off",
        },
        {
          name: "Living room on",
          description: "Turn on the living light",
          value: "livingroom_lights_on",
        },
        {
          name: "Living room off",
          description: "Turn off the living light",
          value: "livingroom_lights_off",
        },
      ])

    await post(`https://maker.ifttt.com/trigger/${selectedLight}/json/with/key/<your key>`)
} catch (e) {
    log(e)
}
```

Now if you invoke the script, voila! 

The light turns on like magic. No voice commands, no mobile app, just from your computer without even taking your hands off the keyboard.

Hopefully, these examples are inspiring enough to explore ScriptKit. There is also a silent hero: IFTTT which performed all the heavy lifting for us.

Integrate ScriptKit with other automation services and create an unforgetable experience

Automate your life with Typescript and ScriptKit


Last month Meta [announced they are releasing a new LLM model](https://www.archivorous.com/posts/meta-announces-llama-llm-model) for research purposes. The model named LLaMA(Large Language Model Meta AI) is a state of the art LLM to help researchers run large models in a local environment (possibly in a single machine) to impact various research areas in the LLM domain.

This week Bulgaria based ****[Georgi Gerganov](https://github.com/ggerganov)** has released a [repo](https://github.com/ggerganov/llama.cpp) to execute the model in a M1 Mac. The port called as LLaMA.cpp uses 4 bit quantization to reduce the memory requirements of the model and run in a single Mac device. 

Running the actual LLaMA requires the following steps mentioned in the official repo: https://github.com/facebookresearch/llama. A request must be made to Meta to download the weights for the model. [Here is the official Google form from Meta](https://docs.google.com/forms/d/e/1FAIpQLSfqNECQnMkycAp2jP4Z9TFX0cGR4uf7b_fBxjY_OjhJILlKGA/viewform?usp=send_form) to request to download the weights.

Although the weights have leaked online. It is not legal to download and use this for commercial purpose. Use this magnet to download the weights:

```tsx
magnet:?xt=urn:btih:b8287ebfa04f879b048d4d4404108cf3e8014352&dn=LLaMA&tr=udp%3a%2f%2ftracker.opentrackr.org%3a1337%2fannounce
```

> Note: The magnet above is posted by one of the original requesters to which Meta has sent a download link. Technically, it is still not legal to download files that is intended for use by someone else but it should be fine for experiments and never for commercial use.
> 

> Refer LLaMA model card for info: [llama/MODEL_CARD.md at main · facebookresearch/llama · GitHub](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md)
> 

Here are the steps to run the model after you obtained the weights:

- Clone the repo:

```
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make
```

- Place the weights in a model folder: (obtained from above methods)

```tsx
ls ./models
65B 30B 13B 7B tokenizer_checklist.chk tokenizer.model
```

- Install dependencies:

```tsx
python3 -m pip install torch numpy sentencepiece
```

- Convert to ggml format: (which is a tensor format developed by the same author)

```tsx
python3 convert-pth-to-ggml.py models/7B/ 1
```

- Quantize:

```tsx
./quantize.sh 7B
```

- Run inference:

```tsx
./main -m ./models/7B/ggml-model-q4_0.bin -t 8 -n 128
```

- Profit!

## The above steps are just too much!

If you feel you don’t want to hustle with the above steps, there is a simple alternative in this repo: [cocktailpeanut/dalai: The simplest way to run LLaMA on your local machine (github.com)](https://github.com/cocktailpeanut/dalai)

Simple run:

```tsx
npx dalai llama
npx dalai serve
```

- Visit [http://localhost:3000](http://localhost:3000/)

Above two commands do the following:

1. First installs the 7B module (default)
2. Then starts a web/API server at port 3000

Interesting to watch what people come up with using LLaMA!

It is now possible to run Meta's LLaMA LLM model locally in a M1 Mac!

Run Meta’s LLaMA locally in a Macbook


[Vercel](https://vercel.com) has been continuously updating and innovating their product lineups. From introducing a [scheduler last month](https://vercel.com/guides/how-to-setup-cron-jobs-on-vercel) to introducing [Next 13.2](https://nextjs.org/blog/next-13-2) - the latest stable version of Next.js, they are on a roll. And now they have announced the latest interesting update on one of their products.

Turborepo, the build system from Vercel is migrating from [Go](https://go.dev/) to [Rust](https://www.rust-lang.org/) incrementally. Although Go is still a integral part of the tool, it is slowly migrating away from it. One of the most important aspects of Turborepo is the support for [monorepos](https://monorepo.tools/).

Turborepo improves development speeds by offering multiple features like incremental builds, parallel execution and remote caching.

Turborepo is inspired from [esbuild](https://esbuild.github.io/), the awesome build tool for javascript written in Go. Naturally Vercel chose Go as their language for Turborepo.

Language migration is a demanding task. There's *a lot* to consider and the decision shouldn't be taken lightly. But instead of simply comparing the pros, cons and other aspects of a language (those doesn’t matter in a large scale most of the time), it is important to consider certain design choices and the scenarios the language is envisioned to be used for.

Go's strength is network computing in data centers and it **excels** at this task, powering these workloads at the world's largest scales. The goroutine-per-request model, Context API, and the standard library inclusion of server infrastructure is testament to this community focus. Go is also particularly simple in its syntax. Although, sometimes the syntax can be quite limiting and weird, it works most of the time.

The Turborepo team points out the same as their reason for the switch: “Additionally, Go favors simplicity over expressiveness. A side effect of that decision means more errors are caught at runtime where other languages might catch them at compilation. With a service running in a data center, you can roll back, fix, and roll forward at your convenience. But, when building software that users install, the cost of each mistake is higher. For us, it's worth using tools that prioritize up-front correctness. We fully recognize the mismatch of **Go's priorities** and **what we are prioritizing** as a problem that we created for ourselves to solve.”

That’s quite an interesting case to know. But does rust emphasize on compile time errors. **You bet!**

Unlike Go, which is focussed on networks, servers and large scale systems, Rust focusses on correctness over abstraction which provides a lot more control in aspects like process management, file systems, os, etc. 

Since being a software that is shipped to client devices, it makes sense.

“Rust's type system and safety features allow us to put guardrails in place in our codebase where we need them. The language's expressiveness allows our developers to encode constraints that catch errors at compile time rather than in GitHub issues.”

One more reason is the ability to interop with C/C++. A majority of low level libraries are still developed and maintained in C and C++. But newer developers want a safe language and also some ability to interface with those languages. Rust provides exactly that.

Rust has an unsafe alter ego is that the underlying computer hardware is inherently unsafe. If Rust didn’t let you do unsafe operations, you couldn’t do certain tasks.Rust has a FFI interface. It provides a keyword “extern” to allow rust code to invoke C code. Here is an example from the [rust book](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code):

```
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}
```

## Rust makes us happy

Another important aspect the team provides is since Rust allows them to be flexible and does not get in their way, it makes the team happy. It is not unique to Turborepo team. In fact, Rust is the most desired language for the past 4 years in [Stack Overflow surveys](https://insights.stackoverflow.com/survey).  

Rust finds its way into a majority of web and other software tooling these days partly because of the correctness and dev satisfaction.

Let’s see how this turns out for the Turborepo team.

Here is the announcement blog: [https://vercel.com/blog/turborepo-migration-go-rust](https://vercel.com/blog/turborepo-migration-go-rust)

The build system is starting to incrementally adopt Rust in their project

Turborepo migrates from Go to Rust


Large language models like ChatGPT and BARD are trained from a huge corpus of real world data. These are mainly extracted from the internet, books, wikipedia and by generally crawling websites. And so, naturally these models reflect what they have been trained on.

They excel in everything their source data excelled at. Including bias and stereotypes. Even the AI bots think they are biased. 

From ChatGPT, “As an artificial intelligence language model, I am designed to provide unbiased responses to questions and queries. My responses are generated based on the information I have been trained on, which includes a vast range of text from various sources. However, it's possible that my responses may reflect any biases present in the training data or the way questions are phrased. In any case, I strive to provide objective and informative answers to the best of my ability.”

So its clear that even the LLMs are aware they may be biased. But is there a fix for this?

## Is it that important?

Absolutely.

- There have been several examples in the past that AI models have exhibited racial discrimination towards black people and some sorts of gender discrimination towards woman.
- Models trained on data from news articles and other journals may include gender biases.
- Criminal justice AI models, oversampling particular areas may result in more data for crime in that area, which could lead to more enforcement.
- It was found that more searches containing the term “arrest” came up when African-American-identifying names were searched than for white-identifying names.
- With professions, a language model (which is biased) thinks that “flight attendant,” “secretary,” and “physician’s assistant” are feminine jobs, while “fisherman,” “lawyer,” and “judge” are masculine. Concerning emotions, a language model thinks that “anxious,” “depressed,” and “devastated” are feminine.

For an indepth talk on the seriousness of bias, here is a lecture from ML scientist Jeremy Howard: https://www.youtube.com/watch?v=5_xFdhfUnvQ&list=PLfYUBJiXbdtSyktd8A_x0JNd6lxDcZE96&index=12

## How could we fix bias?

Bias in an AI model is not easy to fix. There are several active researches going on to reduce bias. 

- One of the most important methods to fix bias in an AI model is increase diversity in the training data: This can be done by collecting data from a wide range of sources and ensuring that the data is balanced across different demographics.
- Penalising the models by introducing a human in the loop: This can be done by comparing the predictions of the model with real-world outcomes and checking if any particular groups are being unfairly impacted by the model. If found, then the model could be retrained again.
- The algorithm should also be fair: This is the idea of ensuring that AI models are fair and just to all individuals regardless of their race, gender, or any other demographic factor. One way to do this is by adjusting the algorithms used to train the model so that they do not unfairly favor one group over another. This can also be made possible by increasing the AI industry’s diversity. By making more diverse people work in the industry, we increase the perception of views and increase the chances of detecting biases and potentially reducing them.

## What are the recent advancements in this field?

Recently, [MIT has published a paper](https://news.mit.edu/2023/large-language-models-are-biased-can-logic-help-save-them-0303) for reducing model bias by introducing a logical layer to the model. 

“Current language models suffer from issues with fairness, computational resources, and privacy,” says MIT CSAIL postdoc Hongyin Luo, the lead author of a new paper about the work.

The team lead by Hongyin Luo has come up with the thought of introducing logical awareness in AI models. They trained a language model to predict the relationship between two sentences, based on context and semantic meaning, using a dataset with labels for text snippets detailing if a second phrase “entails,” “contradicts,” or is neutral with respect to the first one. Using this dataset — natural language inference — they found that the newly trained models were significantly less biased than other baselines, without any extra data, data editing, or additional training algorithms.

This model, which has 350 million parameters, outperformed [some](https://blog.google/technology/ai/lamda/) very large-scale language models with 100 billion parameters on logic-language understanding tasks. The team evaluated, for example, popular BERT pretrained language models with their “textual entailment” ones on stereotype, profession, and emotion bias tests. The latter outperformed other models with significantly lower bias, while preserving the language modeling ability.

The “fairness” was evaluated with something called ideal context association (iCAT) tests, where higher iCAT scores mean fewer stereotypes. The model had higher than 90 percent iCAT scores, while other strong language understanding models ranged between 40 to 80.

“Although stereotypical reasoning is a natural part of human recognition, fairness-aware people conduct reasoning with logic rather than stereotypes when necessary," says Luo.

"We show that language models have similar properties. A language model without explicit logic learning makes plenty of biased reasoning, but adding logic learning can significantly mitigate such behavior. Furthermore, with demonstrated robust zero-shot adaptation ability, the model can be directly deployed to different tasks with more fairness, privacy, and better speed.”

We are still far away from eliminating bias completely in the AI models. Although research like these are a positive step in the right direction.

With bias being a serious issue in several AI models, what is the new research to fix it?

How can we fix bias in Large Language models?


If you have worked with React or scaffolded a React application from you would have come across this statement most likely in the App.jsx file:

```tsx
root.render(
  <StrictMode>
    <App />
  </StrictMode>
)
```

This is the configuration required to enable StrictMode in react. But what is it? And why do we need it?

## What does StrictMode do?

StrictMode is a very simple and efficient idea in React to discover potential bugs during development. It does 3 major functions:

- renders every component twice in development mode.
- run effects twice in development mode.
- checks deprecated APIs

But why?

## Component behaviour in strict mode

To understand how rendering a component twice will help us discover bugs, we must first understand the philosophy behind react components.

React emphasizes every component in the tree to be pure functions. There are some inherent assumptions in the reconciliation (committing to DOM) logic that every function components are pure.

### But what are pure functions?

The idea is simple. A function is pure if,

- it is deterministic (it returns the same output for the same input every time.)
- has no side effects (it does not modify or depend on values outside its scope.)

Let’s take an example:

```tsx
function areaOfCircle(radius) {
  return Math.PI * Math.pow(radius, 2)
}
```

The above function takes the radius of a circle and calculates and returns its area. This function is a simple example of a pure function.

If you apply the above rule “Same input should return same output” to the above function, it applies to it.

Let’s take another example:

```tsx
let powerFactor = 2

function areaOfCircle(radius) {
  return Math.PI * Math.pow(radius, powerFactor)
}
```

```tsx
let powerFactor = 2

function areaOfCircle(radius) {
  const area = Math.PI * Math.pow(radius, powerFactor)
  powerFactor = 3

  return area
}
```

The above two are impure functions (Although they are not the best examples 🥲). It modifies/depends on a variable outside its scope and the function itself is indeterministic now. It depends on powerFactor variable and if the variable’s value changes, the result of areaOfCircle also changes.

This approach is bad because it can introduce unexpected bugs because of dependant values changing.

But if you think about it, by creating only pure functions, we cannot do so much in programming. After all if you are developing something, you want it to modify some state, somehow, somewhere at some point in time.

A side effect could be anything like:

- Modifying data
- fetch requests
- DOM manipulation
- etc.

### Back to strict mode

Now that we understand pure functions, let’s come back to React and StrictMode configuration. As I said earlier, React assumes each functional component is pure. Thus StrictMode renders the same component twice to check if we modify any outside variables and generate a different state for the component the 2nd time.

Consider the example below:

```tsx
function TodoItems({ todos }) {
  todos.push({ id: 4, value: 'buy food' })
  return (
    <ul>
      {todos.map((x) => (
        <li key={x.id}>{x.value}</li>
      ))}
    </ul>
  )
}
```

The above function takes a todo list and renders it. But it also pushes a entry to the todo prop during render.

The above code may look correct but it is not. Without strict mode, the 4th entry will be pushed every time the component re-renders. Let’s add a state variable for example,

```tsx
function TodoItems({ todos }) {
  const [isHover, setIsHover] = useState(false)
  todos.push({ id: 4, value: 'buy food' })
  return (
    <ul onPointerEnter={() => setIsHover(true)} onPointerLeave={() => setIsHover(false)}>
      {todos.map((x) => (
        <li key={x.id}>{x.value}</li>
      ))}
    </ul>
  )
}
```

If you intended that one todo will be pushed when the list is hovered, its not the case. Every time you push, multiple todo will be pushed. This is because the function modified a prop which is an external variable. This also could potentially affect other components as well.

This bug is not obvious the first time, but only with multiple presses. That is where StrictMode helps us. By rendering twice, it brings out hidden bugs like this.

Moreover, modifying prop directly is never a good idea in itself.

## useEffect behaviour in strict mode:

StrictMode also modifies the useEffect hook to run an extra time to identify unexpected side effects like the above example.

The problem is evident when you modify an external datasource. It might be triggered multiple times. Here is a simple example:

```tsx
function BookReader({ book }) {
  useEffect(() => {
    service.setStartReadingTime()
  }, [])

  return (
    <div>
      <h1>{book.title}</h1>
      <p>{book.content}</p>
    </div>
  )
}
```

Let’s say we track the time a user starts to read a book. This example might look good but it is missing the cleanup. As a result, every time we change the book prop from the parent, the component re-renders causing to restart the tracker in the reading time service.

This can be detected by strict mode without changing the prop itself, because the component will be rendered twice and it makes the bug obvious.

```tsx
function BookReader({ book }) {
  useEffect(() => {
    service.setStartReadingTime()

    return () => {
      service.setEndReadingTime()
    }
  }, [])

  return (
    <div>
      <h1>{book.title}</h1>
      <p>{book.content}</p>
    </div>
  )
}
```

The fix is to add the cleanup logic of setting the endTime.

## deprecated APIs

StrictMode also helps in detecting usage of deprecated APIs like:

- `[findDOMNode](https://beta.reactjs.org/reference/react-dom/findDOMNode)`
- `UNSAFE_` class lifecycle methods like `[UNSAFE_componentWillMount](https://beta.reactjs.org/reference/react/Component#unsafe_componentwillmount)`
- Legacy context (`[childContextTypes](https://beta.reactjs.org/reference/react/Component#static-childcontexttypes)`, `[contextTypes](https://beta.reactjs.org/reference/react/Component#static-contexttypes)`, and `[getChildContext](https://beta.reactjs.org/reference/react/Component#getchildcontext)`)
- Legacy string refs (`[this.refs](https://beta.reactjs.org/reference/react/Component#refs)`)

The usage of these APIs are rare, but StrictMode still detects them.

## Conclusion:

To summarize, StrictMode does the following:

- renders every component twice in development mode.
- run effects twice in development mode.
- checks deprecated APIs

It does so to detect any unwanted behaviour in the code during development phase itself.

References:

- [https://beta.reactjs.org/reference/react/StrictMode#fixing-bugs-found-by-double-rendering-in-development](https://beta.reactjs.org/reference/react/StrictMode#fixing-bugs-found-by-double-rendering-in-development)
- [https://beta.reactjs.org/learn/keeping-components-pure](https://beta.reactjs.org/learn/keeping-components-pure)
- [https://www.geeksforgeeks.org/pure-functions-in-javascript/](https://www.geeksforgeeks.org/pure-functions-in-javascript/)


Explains what does StrictMode do in React

Understanding React Strict Mode


[Bun.js](https://bun.sh/) is a new javascript runtime which is released as an alternative to Node and Deno. Bun is different though. It is built with performance and ease of use in mind. It is a batteries included tool for javascript development.

It has more or less the same APIs as Node.js, which is a big relief for developers as we need not learn yet another set of APIs.

One of the other awesome features of Bun is, it has complete support for existing npm packages. Therefore, from the start, Bun has an excellent and active collection of third party modules for almost everything.

And the best part, typescript, JSX, TSX, etc. just work without anything config!

From their site: “Run, test, transpile, and bundle JavaScript & TypeScript projects — all in Bun. Bun is a new JavaScript runtime built for speed, with a native bundler, transpiler, test runner, and npm-compatible package manager baked-in.”

Sounds promising. In this article, let me summarize how to setup a simple full stack notes application using Boa.js(similar to Express) and a React frontend all using Bun!

## Installing Bun.js

Installing Bun is simple. It is just a simple curl command. (Bun is not supported in Windows as of now).

```jsx
curl -fsSL https://bun.sh/install | bash
```

You can also use npm if you prefer:

```jsx
npm i -g bun
```

Hopefully, this is the last npm command you write 😝

## Setting up a backend server

For our backend server, we will be using [bao.js](https://github.com/mattreid1/baojs)

To install Bao.js in Bun, it is just a single command:

```jsx
bun create elysia ./Server
```

Here is a simple server setup using Bun and Elysia:

```tsx
import { Elysia } from 'elysia'

const app = new Elysia()

interface INote {
  id: string
  content: string
}

const notes: INote[] = []

app.get('/ping', () => 'pong')

app.listen(3000)

console.log(`🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`)
```

Now head onto port 3000 and you should see a “pong” text!

### CRUD operations:

```jsx
app.get('/:id', (ctx) => notes.filter(n => n.id === ctx.params.id))

app.post('/', (ctx) => {
    const note = ctx.body as INote;

    note.id = crypto.randomUUID()

    notes.push(note);

    return note;
})

app.put('/:id', (ctx) => {
    const note = ctx.body as INote;

    const currentNote = notes.find(n => n.id === ctx.params.id)

    if (!currentNote) {
        throw new Error("NOT_FOUND")
    }

    currentNote.content = note.content;

    return currentNote;
})

app.delete('/:id', (ctx) => {
    const currentNoteIdx = notes.findIndex(n => n.id === ctx.params.id)

    if (currentNoteIdx < 0) {
        throw new Error("NOT_FOUND")
    }

    notes.splice(1, currentNoteIdx);

    return;
})
```

### Simple error handler:

```tsx
app.onError(({ code, error, set }) => {
  if (error.message === 'NOT_FOUND') {
    set.status = 404

    return 'Not Found :('
  }
})
```

Use the following command to start the server:

```tsx
bun src/index.ts
```

## Creating the frontend:

Creating the front-end using bun cli is similar:

```tsx
bun create react ./Client
```

Bun by default supports front end transpiling of JSX, TSX and other files. We can create a simple component and use bun to serve the dev server:

```tsx
import React from 'react'
import useSWR from 'swr'
import { API_PATH } from '../constants'
import { INote } from '../types'

export const ListNotes = () => {
  const { data, error, isLoading }: { data: INote[]; error: any; isLoading: Boolean } = useSWR(
    `${API_PATH}/`,
    (url) => fetch(url).then((res) => res.json())
  )

  return (
    <>
      {isLoading && <p>Loading...</p>}
      {error && <p>error occurred</p>}
      {!isLoading && !error && data.length > 0 && (
        <ul>
          {data.map((note) => (
            <li>{note.content}</li>
          ))}
        </ul>
      )}
      {!isLoading && !error && data.length === 0 && <p>No data present</p>}
    </>
  )
}
```

Use bun dev to serve the files:

```tsx
bun dev
```

## Conclusion:

In this short article, we explored bun to get an idea of a simple full stack app. As far as tooling goes, bun is awesome. It has unparalleled performance compared to other bundlers and servers in the node ecosystem.

Here is the code:

https://github.com/laxmanvijay/BunHello


Quick overview of Bun.js


Have you ever thought of why did AI became a mainstream technology in the past 10 years although it has been tried and failed several times in history?

The answer is twofold. One is the vast availability of data after the internet era and the other is the advanced hardware capable of processing that data.

Today let’s look at one such amazing technology which greatly helped AI in reaching its current shape — Nvidia’s CUDA.

CUDA is a parallel computing platform and programming model developed by NVIDIA for general computing on its own GPUs (graphics processing units). CUDA enables developers to speed up compute-intensive applications by harnessing the power of GPUs for the parallelizable part of the computation.

GPUs are very old. In fact they are invented around the same time mainstream personal computers itself were getting started — like the 70s.

NVIDIA started trying to compete in the 3D accelerator market with weak products, but learned as it went, and in 1999 introduced the successful GeForce 256, the first graphics card to be called a GPU. 

Although the first ever GPU was launched during 1999, its only purpose was to improve performance during gaming. 

It was only on 2006, GPUs were experimented for other purposes in engineering, simulation, etc. But in order to do this, computer programmers have to access GPU to write programs that work on them. That became possible after Nvidia released its interface called CUDA (Compute Unified Device Architecture) as a platform in C (programming language).

It became a huge paradigm shift for compute intensive workloads. But the problem is, CUDA is only for Nvidia GPUs. In an attempt to break this, AMD released OpenCL as an alternative in 2009, but it didn’t do well.

CUDA became supported in every mainstream industry — Finance, Weather modelling, Defence, Manufacturing, Media, Medical imaging and of course AI and deep learning. 

Basically anything that requires compute intensive tasks became offloaded to the GPU.

But how could GPUs improve performance of normal computer programs other than graphic rendering?

![CPU vs GPU](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/b5043d70-11a6-40ba-0a50-60fa2290420f.png)

Basically, a CPU has something called as an ALU - Arithmetic and Logical Unit which performs mathematical operations. The problem is, a CPU cannot parallelize well. It is designed to be a decision making system and not a computation platform. Here’s where GPU comes into the picture. They have so many mathematical units - several 1000s of them. But they can only perform simple mathematical operations in extreme  parallel speed.

Thus, whenever, parallel mathematical operations like Matrix multiplication and addition are involved, the GPUs can vastly outperform the CPUs. And that’s why, image processing and graphic rendering (which is just an RGB matrix) is very fast on a GPU.

Deep learning uses this idea and converts every input into a matrix and sends it to the GPU for performance gains.

Explaining Nvidia's CUDA in a simple manner

An ELI5 explanation of CUDA


Ever wondered how NPC characters in games work?

Every game these days has a mechanism to introduce NPC characters, villains, bosses, animal friends, etc into their games these days. 

Like for example, if you have played Far cry 5, there is Boomer (which is the cutest).

But ever wondered what goes behind these NPC characters that make the game so much interesting?

That’s right! These are all AI systems trained beforehand.

Let’s look at one of the popular training mechanisms and a historical game event that took place.

## Deep Reinforcement Learning

There is this idea of reinforcement learning in AI where in an AI agent is treated with rewards if it performs as expected and is penalised if it is not performing as expected. This is not new. It is a mechanism that prevailed from the 90s.

![RL Agent](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/3acf73be-1621-9e8c-2945-1e901ddd26a1.jpeg)

But what is new is deep learning integrated into reinforcement learning and transformed into deep reinforcement learning.

Deep learning is an idea in which a large number of input training data (like images, videos, text, etc) is fed into a system and generates a output by simply multiplying the inputs with a weight. The value of weight is trained and improved over time.

The system is called a deep learning model. There are several architectures and patterns for these models to generate different types of responses. One of the famous examples is the ChatGPT. It uses a model architecture called as GPT (Generative Pre trained Transformer) developed by OpenAI which itself was inspired by an interesting architecture called as Transformers released by Google.

Back to DRL, now combining deep learning and reinforcement learning is not difficult if you think about it. (Or at least from a theoretical standpoint)

A deep learning model can help the AI agent see the world (its environment) more precisely. Hear the environment more precisely. Understand the environment more precisely. 

For example, a vision model can help identify an object present in front of the game AI (like a sword present in front of it). This vastly improves the ability of the game agent to improve its actions. 

This same idea can not only be applied to game agent, even self driving cars like Tesla, Waymo, Zoox, etc. are all based on the this fundamental principles. Although these systems can be more sophisticated because of the complexity of the real world than a simulated game environment. 

But with that gentle introduction, here are some ways in which we can train our own systems.

There is a ML agent training system within Unity called as ML agents ([Build More Engaging Games with ML Agents | Unity](https://unity.com/products/machine-learning-agents))

Check this blog for more explanation on ML Agents: [Training intelligent adversaries using self-play with ML-Agents | Unity Blog](https://blog.unity.com/technology/training-intelligent-adversaries-using-self-play-with-ml-agents)

OpenAI has something called as OpenAI gym. ( Back in 2022, they moved their reinforcement learning tools to a new non-profit organisation called Farama). Here is the link for that: [Gymnasium Documentation (farama.org)](https://gymnasium.farama.org/)

Gym is amazing because of the bootstrapped nature of their environments. All it takes is a 6 line code to simulate a 2d lunar lander.

```python
import gymnasium as gym

env = gym.make("LunarLander-v2", render_mode="human") 
observation, info = env.reset() 

for _ in range(1000): 
    action = env.action_space.sample()
    observation, reward, terminated, truncated, info = env.step(action) 
    if terminated or truncated: 
        observation, info = env.reset() env.close()
```

## AlphaGo

Although there are several tools like the Gym and ML Agents as mentioned above, it is all relevant these days only because of a historical game event that took place back in 2016.

In march 2016, Lee Sedol, an 18 times world champion in the ancient Chinese game of Go would be challenged by Google’s DeepMind for a match. Little at that time did Sedol knew that that match would be written in history for it being the first one to host an AI agent beating a Go world champion. 

Unlike Chess, Go was more difficult and had unimaginable complications and was never beaten by an AI before. (Chess was first beaten by AI by IBM DeepBlue against Garry Kasparov).

Although Sedol beat AlphaGo once, AlphaGo beat him 4 times and won the match in a clean 4-1 victory. Since then, Google’s DeepMind was the all the rage everywhere and it popularised Deep reinforcement learning to the masses.

Learn more about it here: [The Challenge Match (deepmind.com)](https://www.deepmind.com/research/highlighted-research/alphago/the-challenge-match)

An ELI5 introduction to deep reinforcement learning

An ELI5 introduction to Deep reinforcement learning


We all know the ongoing AI wars that Microsoft and Google have started. The hype began last year with the advent of Generative AI tools like DALL-E and ChatGPT by OpenAI. These technologies shifted the landscape drastically from other overhyped technologies like blockchain and web3 (which still searches for a problem to solve) to AI. Several new AI influencers, AI artists, AI writers, AI tools, AI logo generators and a lot other utilities were created. With only a short prompt, DALL-E can generate amazing images. Like for example as provided in [AssemblyAI blog](https://www.assemblyai.com/blog/how-dall-e-2-actually-works/), “a bowl of soup that is a portal to another dimension as digital art”

[DALL-E generated images](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/c155b2a6-74ba-3616-772f-fc3b6b470564.png)

But behind all this amazing technology is an amazing history of over 50 years. Over this period several people and companies have tried so hard to make this possible. 

It all started way back even before the first personal computers starting hitting people’s homes. In 1943, a seminal paper published by Warren McCulloch and Walter Pitts on artificial neurons is the first to explore this topic. Here is the paper if you wish to read: [A logical calculus of the ideas immanent in nervous activity | SpringerLink](https://link.springer.com/article/10.1007/bf02478259)

Following their paper, in 1950, the genius scientist Alan Turing published a method to analyse and measure “computing intelligence” called as Turing test. It is relevant even today. 

Following that, in 1956, John MacCarthy coined the term “Artificial Intelligence” at the historical [Dartmouth conference](https://en.wikipedia.org/wiki/Dartmouth_workshop). It was at this moment that AI gained its name, its mission, its first success and its major players, and is widely considered the birth of AI.

Remember, it was a time, old languages like FORTRAN were developed and companies like Apple and Microsoft didn’t even exist. IBM was the top tech company. 

So many successful AI projects were developed till 1974. One of them is the famous [WABOT-1](https://www.humanoid.waseda.ac.jp/booklet/kato_2.html). But after 1974, the first AI winter began. Investors stopped believing in the potential of AI because most of the systems at that time were overhyped and internally they were just programmed if else statements.

Again in 1980, a conference held at Stanford university, sparkled the interest for AI yet again. This time, AI came back with Expert systems. It was more or less the same if else statements but more sophisticated. It was doomed to fail.

The second AI winter began in 1987.

After several years, in 1997, [IBM’s DeepBlue](https://www.ibm.com/ibm/history/ibm100/us/en/icons/deepblue/) - a chess AI, for the first time defeated the then world champion in chess, Garry Kasparov. It was at that moment, everyone started looking into AI again. But this time it was different. Several new algorithmic approaches were created. This includes the idea of Machine learning, [Back propagation](https://www.nature.com/articles/323533a0), etc.

After 2000, several practical AI systems that are focussed on a specific task were developed. Technology became sufficiently advanced to collect large data and process them.

Several companies like Google, Facebook, Apple, Amazon, Microsoft, etc. started investing in AI and it became integrated in commercial products.

And fast forward 20 years, here we are today with advanced AI systems paint for us, write for us, talk and book an appointment at a saloon for us, even drive us to office. We are so much invested into AI than we realise. And with the rate, AI is advancing it is hard to imagine the innovations that will come out this year.

A short summary of the history of the revolutionary AI technology

History of AI


If you are a front end developer and are working on [React](https://reactjs.org/), you must have heard about [Next.js](https://nextjs.org/) and its impressive rendering methods. Next.js is an advanced react framework with so many little things taken care of. One of the important features that is taken care of is the ability to Server side render the pages in the react application. In this article, let me explain the various rendering methods in Next.js and what to use when.

## Client Side Rendering: (CSR)

Let’s start with the most simplest and most straight forward rendering approach available in React. It is Client side rendering. This approach takes the entire application and loads it into the client. Further requests and processing are then made by the client. This approach started with the introduction of [Single Page Applications (SPAs)](https://developer.mozilla.org/en-US/docs/Glossary/SPA) way back in 2008 and frameworks like [Angular](https://angular.io/), [React](https://reactjs.org/) and [Vue](https://vuejs.org/).

This was a radically new approach to rendering at that time. People were used to server side technologies like ASP.NET, Java Spring, Ruby on Rails and PHP. With this new approach, it felt like a breath of fresh air.

### But what was the problem in server side?

Since there were so many frameworks [ASP.NET](https://dotnet.microsoft.com/en-us/), [Java Spring](https://spring.io/), [Ruby on Rails](https://rubyonrails.org/) and [PHP](https://www.php.net/) that used to render the page on the server and then send it to front-end, what was the problem there? There were quite a few:

- With traditional server-side rendering, the server responds by generating and returning a completely new page for every interaction. This often slows load time, uses more bandwidth, and creates a less responsive user experience. Client-side rendering avoids making unnecessary requests for a full page when only a portion of the page has changed
- Hosting an [Angular](https://angular.io/) application was much cheaper than hosting a full blown Java Server application. It reduced the complexity and provided the front end developer with more abilities in their arsenal. Deployment is also often very simple in a static application.
- Hate for existing frameworks and tools - during that time, everything about the backend was quite difficult. Writing a [JSP](https://docs.oracle.com/javaee/5/tutorial/doc/bnagy.html) application required tweaking and setting up so many configurations and it was quite difficult to manage. People were searching for a fresh alternative and a new approach to do things.

### Enter Angular.js

During that time around 2008, Ryan Dahl introduced [Node.js](https://nodejs.org/en/) as a runtime for Javascript. Till that time, browsers like Chrome and Firefox were the only ones that could parse and execute Javascript code. With the introduction of [Node.js](https://nodejs.org/en/) , Ryan revolutionised the idea of executing Javascript in a backend environment. Although [Node.js](https://nodejs.org/en/) used Chrome’s v8 engine for parsing and executing Javascript, it was a much needed alternative.

![Ryan Dahl](https://i.ytimg.com/vi/M3BM9TB-8yA/maxresdefault.jpg)

Ryan Dahl

This triggered a series of javascript technologies to be released one after the other. One such interesting release is the release of Angular.js by Google. Interestingly, it started as a side project by one of the Googlers. They came up with the approach to switch the rendering from server side to client side in an increasing mobile based world. Angular.js became a huge success although it was needlessly complicated and had so many drawbacks. It had first class support for Client side rendering and abandoned server side rendering. Considered a welcome move at that time.

Due to the heavy drawbacks, many other frameworks like [Ember.js](https://emberjs.com/), [Meteor.js](https://www.meteor.com/) and eventually [React.js](https://reactjs.org/) by Facebook was also launched. It became an instant success and loved by millions worldwide.

But soon enough people started realising CSR has its own set of drawbacks. One of the major drawback is its hinderance in SEO and very high loading times for the site because it has to download the entire bundle from the server.

## Server Side Rendering: (SSR)

To improve these drawbacks, alternative rendering approaches like SSR and SSG were developed. With SSR, all the rendering is done on the server at request-time. For every request, the server assembles the fetched data and HTML document and sends the client a complete document. The key thing to note here is the server builds and renders a new page for every request made.

SSR has grown in popularity in recent days due to the surge of JamStack apps and tools. Particularly [Next.js](https://nextjs.org/) and [Vercel](https://vercel.com/) has made this idea popular and extremely easy to implement.

### But isn’t this the same as server rendered pages like JSP?

Yes. Its just the same old server rendered pages but the advantage right now is, these SSR tools like Next.js utilise modern javascript frameworks and toolings. They also have a clear separation of concerns from the backend. This isn’t the typical server rendered pages like JSP or ASP.NET. Next.js still uses REST APIs to fetch the data to render from the backend service and then renders it during the build time of the front end application.

### How to do SSR in Next.js?

Its easy. You just have to invoke the getServerSideProps() method like so:

```jsx
export async function getServerSideProps(context) {
  return {
    // This props object will be passed to the page so they can be used on the frontend.
    props: {},
  }
}
```

But with SSR, since the page is rendered with custom data, each time a new request comes in, it is generally slower than SSG.

If you are mostly doing static sites, then ultimately its not worth it to do SSR.

## Static Site Generation: (SSG)

SSG and SSR are nearly the same. The one big difference is that SSG does all of its rendering does it at build time and fully ready files are served from a CDN. SSG builds fetched data and HTML into a page once and then reuses the output from that build for all requests to that page until the next rebuild of the site.

It is the ultimate fastest way to render beautiful static sites using your favourite tools like React and Next.js. Since the pages are stored on a [CDN](https://www.cloudflare.com/learning/cdn/what-is-a-cdn/), they are loaded extremely fast and are excellent for SEOs. Next.js recommends doing SSG whenever possible. It is better to try and avoid SSR in favour of SSG. They also provide other advantages like image optimisation, font optimisation, caching, etc.

Apart from Next.js, there are several SSG tools like Gatsby, etc.

### How to do SSG in Next.js?

It is mostly the same as SSR except the name changes a bit.

```jsx
export async function getStaticPaths() {
  return {
    // The paths to be pre-rendered at build time. E.g. /post/1, /post/2, etc
    paths: [{ params: { id: '1' } }, { params: { id: '2' } }],
  }
}

export async function getStaticProps(context) {
  return {
    // This props object will be passed to the page so they can be used on the frontend.
    props: {},
  }
}
```

But as with every approach, SSG has some drawbacks: The SSG pages are rendered on build time. Therefore, any updates to the content in the CMS (like Sanity) might have to wait for next rebuild of the frontend application to be reflected in the site.

## Incremental Static Regeneration: (ISR)

But Next.js have already thought of this issue and have come up with the fix for it already. ISR addresses the one possible challenge with SSG, which is the need to rebuild your entire website to update a page’s content. With content updating frequently (e.g. on a blog), SSG might cause you to rebuild the entire site very frequently for changes that are contained in a single page. ISR allows you to rebuild only the updated pages after the site is built.

If you are running a blog site for example, there are 3 cases where this is useful:

- You have updated the existing content
- You have created a new article
- You have deleted an article

In Next.js, you have two key properties to perform ISR: `revalidate and fallback`

- revalidate - rebuilds the page for every given interval period.

```jsx
export async function getStaticProps() {
  const res = await fetch('https://.../posts')
  const posts = await res.json()

  return {
    props: {
      posts,
    },
    // Next.js will attempt to re-generate the page:
    // - When a request comes in
    // - At most once every 10 seconds
    revalidate: 10, // In seconds
  }
}
```

- fallback - constructs the url path by fetching from backend if it is not present

```jsx
export async function getStaticPaths() {
  const res = await fetch('https://.../posts')
  const posts = await res.json()

  // Get the paths we want to pre-render based on posts
  const paths = posts.map((post) => ({
    params: { id: post.id },
  }))

  // We'll pre-render only these paths at build time.
  // { fallback: blocking } will server-render pages
  // on-demand if the path doesn't exist.
  return { paths, fallback: 'blocking' }
}
```

These two take care of the problems faced by SSG pages.

## Verdict:

Use SSG with ISR all the time. That gives you enormous optimisation and performance boosts. If the application mandates custom data, go for SSR and at last consider CSR - for full fledged client side apps like a spreadsheet app, for example.

Thanks for reading :)


Explains concepts like CSR, SSR, ISR and SSG in Next.js context

Explaining weird frontend terms - SSG, SSR, CSR and ISR and some history


Bard is Google’s version of conversational AI similar to ChatGPT which has taken the internet by storm over the past few months. This is due to the nature of human like conversational abilities by these AI systems, more and more people finding it using for a variety of tasks.

When it comes to conversational AI, Google is undisputed given the amount of research and development they have done over the years in this field. Bard is the next addition in their lineup. Although given the timing, Bard is simply recognised as a competitor to ChatGPT rather than a flagship product from Google.

Bard is based on the Language Model for Dialogue Application or LaMDA which was released 2 years also by Google. 

“Bard seeks to combine the breadth of the world’s knowledge with the power, intelligence and creativity of our large language models. It draws on information from the web to provide fresh, high-quality responses” according to the [announcement blog](https://blog.google/technology/ai/bard-google-ai-search-updates/) from Google.

This new product adds to Google’s portfolio of AI models including LaMDA, PaLM, Imagen and MusicLM. All these provides more tools to enhance generational AI and impacting the creativity space. 

As of now, there is no demo version of Bard similar to how [ChatGPT has one.](http://chat.openai.com) However, Google says, these new features will be integrated into Google search soon. 

Also, Google plans to release developer APIs from next month starting with Language API powered by LaMDA and followed by other models soon.

Google introduces Bard which is a conversational AI similar to ChatGPT.

Google introduces Bard, Its answer to ChatGPT


A DNS records is a collection of entries that map a URL to an IP address. These are stored on DNS servers. Although initially, DNS servers only had an URL to IP address mapping, they have evolved and started storing several other information about the URL. All these records have a TTL (time to live). It indicates how long the record is cached in the DNS server.

In order to access a website, a DNS server must store several mandatory records about that website and multiple other optional ones. In this article, let me explain about the most common DNS records.

## The A record

The A record is the most fundamental record in a DNS record. It provides the IPv4 address of a given URL. This is the record that provides the mapping for a URL to an IP address. The browser automatically fetches this record by sending a query to a DNS server.

```jsx
example.com         IN  A       192.168.1.42
```

They are also used for DNSBL list (DNS Blackhole). This is used my mail servers for blocking known mail spammers.

Typically there is only one A record for a single domain name but there can also be many in some cases. This allows to perform load balancing across servers. For example, Route53 in AWS has several multi-region load balancing options based on the health, weight, round-robin, etc. [Refer here](<[https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html)>) for more info.

The default TTL of A record is 14400 seconds or 4 hours.

## The AAAA record

DNS AAAA records match a domain name to an IPv6 address. DNS AAAA records are exactly like DNS A record except that they store a domain's IPv6 address instead of its IPv4 address.

IPv6 are longer form IP address created to address the limitations of IPv4. It is 128 bit whereas IPv4 is 32 bit. This radically increases the number of possible IPv6 addresses.

Except for this change, everything else is same as the A record.

## The CNAME record

The CNAME or Canonical Name is used to notate when a subdomain is an alias of another domain. All CNAME records must point to a domain, never to an IP address.

A lot of websites have domains have subdomains like www.google.com, m.google.com, etc. These domains are pointed to A record(google.com) in a CNAME record. Thus the client can fetch the actual IP address. Once the actual IP address is obtained, the URL is then processed as is, meaning if [shop.amazon.com](http://shop.amazon.com) is the URL, it will have a CNAME to amazon.com and after knowing the actual IP from the A record, the route will still be processed as shop.amazon.com by the server.

A CNAME record can also point to another CNAME record but it is mostly inefficient because it requires two hops to reach the IP address.

Some cloud providers have similar concept but with different name. For example, AWS Route53 has an Alias record which is similar to a CNAME record but a Alias record can point to specific AWS resources like S3 bucket, ELB, API gateway, Cloudfront, etc.

## The MX record

A DNS 'mail exchange' (MX) record directs email to a mail server. It provides information on how to route emails following the SMTP protocol.

```jsx

a.example.com.          IN      MX      mailhost1.example.com
```

The MX records must always point to a domain name.

### Why exactly is a MX record needed?

Similar to how an A record provides information about the IP address, MX record provides information about the mail server. This query is performed by a Mail Transfer Agent(MTA). The MTA then establishes connections to those servers via SMTP protocol.

If you are setting up a custom email domain using a provider like [Google Workspace](https://workspace.google.com/intl/en_in/) for example, then you must configure the MX record and point it to Google’s mail servers.

## The TXT record

The TXT record allows a domain administrator to place text notes.

```jsx
a.example.com.          IN      TXT      hello
```

Most DNS providers place a limit on the number of characters that can go into the TXT record thus it cannot store large values. AWS Route53 has a limit of 255 characters [Refer](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#TXTFormat)

One of the main purposes these days of a TXT record is domain ownership verification. This comes into play in several places. Examples:

- You registered a domain from a domain registrar and now you wish to host a web application using another hosting service (like [https://vercel.com/](https://vercel.com/dashboard)) in that domain. You have to first verify the ownership via a text record.
- If you are managing SEO for a website(example [https://search.google.com/search-console](https://search.google.com/search-console?utm_source=about-page&resource_id=sc-domain:lyrj.space)), you have to first confirm it is your site using a TXT record.

## The NS record

An NS record (NameServer record) is a DNS record that contains the name of the authoritative name server for that domain. It really is another DNS server that could contain your DNS record. This can also be considered a backup mechanism. For example,

```
a.example.com.          IN      NS      c.example.com
c.example.com.          IN       A      192.168.1.2
```

If you have the above configuration,

If a client requests for a.example.com (or any other subdomains like b.example.com) it will be redirected to 192.168.1.2 to get the actual IP address.

A single domain can have multiple NS records for increased availability. Typically, there is one primary name server and multiple secondary name servers. Updating the primary nameserver will trigger an update of the secondary nameservers as well.

## The SOA record

The SOA record(Start of Authority) record stores important information about a domain such as the email address of the administrator, when the domain was last updated, and how long the server should wait between refreshes. All DNS zones need an SOA record in order to conform to IETF standards

## Follow up

Here is the list of all the other DNS records: [https://en.wikipedia.org/wiki/List_of_DNS_record_types](https://en.wikipedia.org/wiki/List_of_DNS_record_types)

Thanks for reading :-)


Blog explaining various DNS records like A, MX, AAAA, NS, etc.

DNS Records and types


File archiving is used when one or more files need to be transmitted or stored as efficiently as possible. Linux supports lots of file archival mechanisms. This article describes the most popular ones.

Before looking into those here's a quick definition of compression and archival

**Compression:** Makes the files smaller by removing redundant information.

**Archival:** Combines multiple files into one, which eliminates the overhead in individual files and makes the files easier to transmit.

Simply compression reduces size and archival combines files.

## Compression algorithms:

- gzip
- bzip2
- xz

### gzip:

gzip (GNU zip) is a compression algorithm. It uses the **Lempel-Ziv-Markov (LZMA) chain** algorithm. It is quite fast but the file size may be larger.

```
gzip {filename}
```

The original file is deleted and replaced by the compressed file.

#### Decompression of gzipped files:

Decompression is done using `gunzip` command.

```
gunzip {gzipped filename}
```

- Including `-l` flag will show the compression information without actually compressing/decompressing.

### bzip2:

bzip2 uses a different compression algorithm called **Burrows-Wheeler block sorting**, which can compress files smaller than gzip at the expense of more CPU time.

```
bzip2 {filename}
```

#### Decompression of bzip2'ed files:

Decompression is done using `bunzip2` command.

```
bunzip2 {bunzip2'ed filename}
```

### xz:

xz also uses the LZMA algorithm. It has the benefits of both gzip and bzip2. It compresses quickly and also results in smaller file sizes.

```
xz {filename}
```

#### Decompression of xzed files:

Decompression is done using `unxz` command.

```
unxz {xzed filename}
```

## Archival:

- tar
- zip

### tar:

Tar is a short form of **TApe Archive.** The tar command takes in several files and creates a single output file that can be split up again into the original files. The tar archived file is often called a tarball.

```
tar -f {filename} {options} {files to archive}
```

The tar command has three modes (pass the appropriate flag to mention the mode):

- Create: Make a new archive out of a series of files. (-c)
- Extract: Extract files out of an archive. (-x)
- List: Show the contents without extracting. (-t)

Tar can also compress the resulting archive using the above compression algorithms.

Provide any of the following flags to mention the compression algorithm.

- gzip (-z)
- bzip2 (-j)
- xz (-J)

The `-v` flag can be provided for a verbose result.

Example:

```
tar -cvJf backup.tar.xz projects/
```

This creates a tarball of the `projects` folder that is compressed using **xz** with a filename of backup.tar.xz

The extension can be anything but it is generally preferred to name this way.

- for gzip, it is `.tar.gz` or `.tgz`, `.taz`

- for bzip2, it is `tar.bz2` or `.tb2`, `.tbz`, `.tbz2`, `.tz2`

- for xz, it is `tar.xz`

#### Listing:

You can list the contents inside the archive without actually extracting using the `-t` flag.

Example:

```
tar -tvf backup.tar.xz
```

This command lists the contents of `backup.tar.xz`

#### Unarchival:

Unarchival is done by passing `-x` flag.

Example:

```
tar -xvJf backup.tar.xz
```

This command extracts the file in the same folder. If you wish to change it, pass the `-C` flag. (which will change directory to the specified one, therefore the directory should be present.)

```
tar -C backups -xvJf backup.tar.xz
```

This will extract in backups folder.

In order to extract a specific file/folder from the archive, provide the relative path of the file/folder.

```
tar -xvJf backup.tar.xz projects/project1
```

This will extract only project/project1 from the archive.

**It is important to note that `-f` flag should always precede the filename**

### Zip:

Zip is an archival and compression mechanism. It does both. The compression is lossless. The default compression algorithm is [DEFLATE](https://en.wikipedia.org/wiki/DEFLATE). It is more common than tarballs. It has builtin support in Windows and Mac. Therefore, it is more preferred for archival than tar.

```
zip {options} {output filename} {files to compress}
```

By default, zip will not compress recursively. Therefore in order to compress files/subfolders inside a folder, use `-r` flag.

Example:

```
zip files.zip temp*
```

This will compress all files starting with _temp_.

```
zip -r projects.zip projects
```

This will recursively compress all files inside the projects folder.

#### Unzip:

the `unzip` command is used to extract the contents of the zipped archive.

Example:

```
unzip projects.zip
```

To just list without extracting,

```
unzip -l projects.zip
```

To extract specific files/folders inside the zip,

```
unzip projects.zip projects/project1
```

This is similar to tar.

Thanks for reading :)


Explanation of common compression and archival techniques

Compression and archival in linux


There are several major important networking protocols that have made the internet possible. Learning about them could be overwhelming as a beginner to computer networks. However, knowing these will help you understand how the internet works. Here are the major protocols which I think are the most interesting ones.

## HTTP

HTTP is the very first in the list and the easiest to understand. If you have used the internet, you have used HTTP. Any site you visit works on the basic principles of HTTP. This protocol describes how the browser and a server should transfer files between them. It is stateless i.e The browser fires a request, the server responds and that’s it. The server then never remembers the client again. The most common resources a browser requests are the following: HTML, CSS, JS, Images, Fonts, etc.

HTTP was designed and developed by the genius dude Tim Berners-Lee in 1989 at CERN. Interestingly, he is also the one, who developed the first browser and also the WWW protocol. HTTP/1 was released in 1996 followed by HTTP/1.1 in 1997 and then in 2015, HTTP/2 was released. The latest successor HTTP/3 was released in 2022.

HTTP uses headers which are key value pairs to provide more information about the request and the response. Like this for example:

```jsx
Access-Control-Allow-Origin: *
Age: 2318192
Cache-Control: public, max-age=315360000
Connection: keep-alive
Date: Mon, 18 Jul 2020 16:06:00 GMT
Server: Apache
```

A typical HTTP connection relies on the presence of a reliable transport protocol like the TCP protocol. Making an HTTP call is very simple in most programming languages. Here is an example for Javascript:

```jsx
fetch('http://example.com/movies.json')
  .then((response) => response.json())
  .then((data) => console.log(data))
```

There are also so many other ways to make HTTP calls including CLI tools like cURL and applications like Postman, etc.

## TCP/IP

TCP/IP stands for Transmission Control Protocol and Internet Protocol. TCP/IP is also commonly called as Internet Protocol suite. These are the set of rules that govern the internet. Understanding this suite means you understand the majority of the concepts. These are the layer 4 and layer 3 protocols.

![OSI](https://ik.imagekit.io/v3papq9tf/osi.png?ik-sdk-version=javascript-1.4.3&updatedAt=1675439905713)

The internet operates on the basis of abstraction. A HTTP request does not care about how it reaches the server. A TCP protocol does not care about which computer it talks to. The IP protocol does not care about how the data is sent over the wire. Each of the layer receives a packet, adds additional info to that packet and then sends it. Moreover, these are just software operations written in the Operating system rather than a physical individual layer.

In this regard, TCP/IP defines how a packet is routed, addressed and received. Here is a summary of the operations:

- Once a packet comes from an upper layer using protocols like HTTP, the layer 4 protocol TCP adds information like source port, destination port, sequence number, etc.
- It is then sent to layer 3 which is the IP protocol. It then adds more information to the packet like Source IP address, destination IP address, etc.
- It is then sent to successive layers for transmission over the wire.

### But how is the port and address is determined?

That is the interesting part. Since there are two parties involved in a single request ( client and server ) we need two sets of ports and IP addresses.

Determining the port for a server is easy. It typically depends on the layer 7 protocol. For example, a HTTP server is typically operated in port 80 whereas HTTPS server in port 443. SSH in port 22, etc. These are predetermined and everyone follows these ports.

However, a client is not a server and does not need to operate in a standard port. Therefore for each request, a random port is chosen called the ephemeral port.

### But what is a port in the first place?

A port is a software construct managed by the Operating System. It is used to identify network processes running in a computer. It is a 16 bit integer ranging from 0 to 65535. If you imagine the computer to be a house, ports are the electric sockets through which data flows.

### Now coming to IP addresses

IP address is the network address of a computer or a device. It is typically assigned by the ISP and it changes every time a device reconnects to the network. There are 2 types of IP addresses namely IPv4 and IPv6. IPv4 is 32 bit address whereas IPv6 is 128 bit address.

Thus every server like Google or Apple will have an unique IP address. The data packet is sent to this IP address from the client via the router. The router uses several algorithms to find the shortest path to reach the destination similar to how Google maps find the shortest distance to reach the destination. I will be writing those in detail in future articles.

But if the address of a server is a 32 bit number, how do I reach Google if I type google.com? Good question, that is where DNS comes in.

## DNS

A DNS is a simple protocol that keeps a key-value pair of human readable names and binary IP addresses. Thus when you type google.com, the request is sent to a known DNS server and it returns the IP address of the server. The actual request to Google is then placed. The DNS also helps the server in updating its IP address without affecting the actual domain name.

DNS is known as Domain Name System. It is one of the oldest protocols in existence. The DNS is hugely distributed and could also be described as the phone book of the internet. The following diagram shows the hierarchical nature of the DNS.

![DNS Hierarchy](https://ik.imagekit.io/v3papq9tf/dns-hierarchy.gif?ik-sdk-version=javascript-1.4.3&updatedAt=1675408205855)

But if every computer and device connected to the internet has an IP address, one can imagine that the number of available IP addresses is going to be exhausted quickly. Thus few other concepts like CIDR and NAT were developed. Let’s look at those in a future article.

## ARP

Ok. I obtained the IP address from the DNS server. I know the port. I built the IP packet. But how do I transfer the data over the wire to the server?

This process is governed using some other lower layer protocols mainly the ARP (Address Resolution Protocol) and RARP (Reverse Address Resolution Protocol). To understand both, first we must understand what a MAC address is.

A MAC(Media Access Control) address is the hardware address of a network device (NIC). A MAC address is used by major network devices including Ethernet, Wi-Fi and Bluetooth. A MAC address is 48 bits in length and is usually fixed. It is also called as the burned in address because it never changes.

Now, back to ARP. It is a simple protocol that maps IP address to MAC address. This mapping is managed by the router and added every time a device joins the network. A router acts like the gateway to a network like a home network for example. Multiple devices can be connected to that router. Whenever the router receives a data packet, it must know to which device it must forward the packet to.

Thus it looks at the ARP table. Gets the MAC address for the equivalent IP address and then sends the packet to that device.

The following is an example mapping table:

![ARP Table](https://ik.imagekit.io/v3papq9tf/arp-table.png?ik-sdk-version=javascript-1.4.3&updatedAt=1675408343792)

## But how is the data transmitted over the wire?

There is an entire field of analog and digital communication and contributions from genius people through out history that has made this possible.

Thanks for reading :)


Interesting Networking Protocols - Part 1


In this article, I have used top down manner to explain linear algebra for deep learning.First providing the applications and uses and then drilling down to provide the concepts.

Definition of linear algebra in wikipedia:

> **Linear algebra** is the branch of mathematics concerning **linear** equations and **linear** functions and their representations through matrices and vector spaces.

### Table of contents:

- Introduction.
- Mathematical perspective of Vectors and matrices.
- Types of matrices.
- Decomposition of matrices.
- Norms.
- Vectorization.
- Broadcasting.
- External resources.

**Introduction:**

If you start to learn deep learning , the first thing you will be exposed to is the feed forward neural network, which is the most simple and also highly useful network in deep learning. Under the hood, the feed forward neural network is just a composite function, that multiplies some matrices and vectors together.

It is not that vectors and matrices are the only way to do these operations but they become highly efficient if you do so.

![](https://cdn-images-1.medium.com/max/800/1*pI5c92ACX6Burmzet8uQYQ.png)

The image above shows a simple feed forward neural network that propagates information forwards.

The image is a beautiful representation of the neural network, but how a computer can understand this. In a computer, the layers of the neural network are represented as vectors. Consider the input layer as X and the hidden layer as H. The output layer is not concerned for now.(The computation process of feed forward neural networks is not concerned here.)

So, it can be represented as a vectors and matrices as,

![](https://cdn-images-1.medium.com/max/800/1*xmWCqN_VbKQXJg8veEpXug.png)

The above image shows the operations needed to compute the output for the first and the only hidden layer of the above neural network(the computation for the output layer is not shown). Let’s break it down.

Every single column of the network are vectors.Vectors are dynamic arrays that are a collection of data(or features).In the current neural network, the vector ‘**x**’ holds the input.It is not mandatory to represent inputs as vectors but if you do so, they become increasingly **convenient to perform operations in parallel**.

Deep learning and in specific, neural networks are computationally expensive, so they require this nice trick to make them compute faster.

**It’s called vectorization. They make computations extremely faster.This is one of the main reasons** [**_why GPUs are required for deep learning_**](https://www.analyticsvidhya.com/blog/2017/05/gpus-necessary-for-deep-learning/)**, as they are specialized in vectorized operations like matrix multiplication.(we’ll see this in the end in depth).**

---

The hidden layer H’s output is calculated by performing $$H = f( W.x + b )$$

Here W is called as the Weight matrix, b is called bias and f is the activation function.(this article does not explain about feed forward neural networks, if you need a primer about the concept of FFNN, [look here](https://towardsdatascience.com/deep-learning-feedforward-neural-network-26a6705dbdc7).)

Let’s breakdown the equation,

the first component is **_W_**.**_x_** ; this is a **matrix-vector product,** because W is a matrix and **_x_** is a vector.Before getting into multiplying these, let’s get some idea about the notations: _usually vectors are denoted by small bold italic letters(like_ **_x_**_) and matrices are denoted by capital bold italic letters(like_ **_X_**_).If the letter is capital and bold but not italic then it is a tensor(like_ **X**_)._

**In a computer science perspective:**

Scalar: A single number.

Vector : A list of values.(rank 1 tensor)

Matrix: A two dimensional list of values.(rank 2 tensor)

Tensor: A multi dimensional matrix with rank n.

**Drilling down:**

![](https://cdn-images-1.medium.com/max/800/1*h44UirtotiOItVLZGBI6Nw.png)

**In a mathematical perspective:**

**Vector:**

**A vector is a quantity that has both magnitude and direction.It is an entity that exists in space**, it’s existence is denoted by **_x∈ ℝ²_**_if it is a 2 dimensional vector that exists in real space.(Each element denotes a coordinate along a different axis.)_

![](https://cdn-images-1.medium.com/max/800/1*OGCWkaenQbXJ7vgWOLgAJw.png)

red and blue color vectors are the basis vectors.

All vectors in 2D space can be obtained by linear combination of the two vectors called **basis vectors**.( denoted by i and j )(In general, a vector in N dimensions can be represented by N basis vectors.)They are **unit normal vectors because their magnitude is one and they are perpendicular to each other**. One of these two vectors can’t be represented by the other vector. So they are called as **linearly independent vectors**. (If any vector can’t be obtained by a linear combination of a set of vectors, then the vector is linearly independent from that set). All the set of points in the 2D space that can be obtained by linear combination of these two vectors are said to be the **span** of these vectors.If a vector is represented by a linear combination(addition, multiplication) of set of other vectors, then it is **linearly dependent** on that set of vectors.(there is no use in adding this new vector to the existing set.)

Any two vectors can be added together.They can be multiplied together.Their multiplication is of two types, dot product and cross product.[Refer here.](https://ltcconline.net/greenl/courses/107/vectors/dotcros.htm)

**Matrix:**

A matrix is a 2D array of numbers. They represent **transformations**. Each column of a 2 \* 2 matrix denotes each of the 2 basis vectors after the 2D space is applied with that transformation.Their space representation is **_W ∈ ℝ³\*² having 3 rows and 2 columns._**

**A matrix vector product is called transformation of that vector, while a matrix matrix product is called as composition of transformations.**

There is only one matrix which does not does any transformation to the vector.It is the identity matrix(**_I_**). **_The columns of_** **_I represent the basis vectors._**

**Determinant** of the matrix **_A,_** denoted by det(**_A_**)the the scaling factor of the linear transformation described by the matrix.

**Why is a mathematical perspective important to deep learning researchers? Because they help us understand the basic design concepts of fundamental objects**.They also help in crafting creative solutions to a deep learning problems._But no worries, there are a lot of languages and packages that do these implementations for us. But it’s also good to know their implementations._

One such library is numpy for python programming language.

![](https://cdn-images-1.medium.com/max/800/1*zE4NFdMVbMCA0CGujquaeA.png)

There are lots of resources for learning numpy.(which is very important for learning deep learning, if you use python.) [look here](https://docs.scipy.org/doc/numpy-1.15.0/user/basics.html).

_Here, np.array creates a numpy array._

_np.random is a package that contains methods for random number generation._

_the dot method is to compute product between matrix._

_We can change the shape of the numpy array and also check it._

_here you can see that, the product of W.x is a vector and it is added with b, which is a scalar. This automatically expands b as transpose(\[1,1\])._ **_This implicit copying of b to several locations is called as broadcasting. (we’ll see in depth in a moment.)_**

_Did you notice the word transpose:_ **_The transpose of a matrix is a mirror image of the matrix across the diagonal line(from top left to the bottom right of the matrix.)_**

```
## numpy code for transpose
import numpy as np
A = np.array(\[\[1,2\],
              \[3,4\],
              \[5,6\]\])
B = np.transpose(A)
##or
B = A.T
```

**Types of matrices:**

**Diagonal matrix**: All the elements are zero except the main diagonal elements.

![](https://cdn-images-1.medium.com/max/800/1*niNtr3lEec8Ng56E74NAXw.png)

diagonal matrix

**Identity matrix**: a diagonal matrix with diagonal values as 1.

![](https://cdn-images-1.medium.com/max/800/1*h2En9F9dKvpd7PW0xTxMTA.png)

identity matrix

```
## numpy code to create identity matrix
import numpy as np
a = np.eye(4)
```

**Symmetric matrix**: a matrix which is equal to it’s transpose. A = transpose(A)

**Singular matrix**: a matrix whose determinant is zero and columns are linearly dependent.Their rank is less than the number of rows or columns of the matrix.

**Decomposition of matrices:**

a **matrix decomposition** or **matrix factorization** is a factorization of a matrix into a product of matrices. There are many different matrix decompositions; each finds use among a particular class of problems.One of the most widely used kinds of matrix decomposition is called **eigen decomposition**, in which we decompose a matrix into a set of eigenvectors and eigenvalues.

An Eigen vector of a square matrix **_A_** is a non zero vector **_v_** such that multiplication by **_A_** alters only the scale of **_v._**

**_A . v_** = lambda . **_v_**

here **_v_** is the eigen vector and lambda is the eigen value.

```
## numpy program to find eigen vectors.

from numpy import array
from numpy.linalg import eig
# define matrix
A = array(\[\[1, 2, 3\], \[4, 5, 6\], \[7, 8, 9\]\])
print(A)
# calculate eigendecomposition
values, vectors = eig(A)
print(values)
print(vectors)
```

![](https://cdn-images-1.medium.com/max/800/1*z_yGwdmC993Zs2iUjMcAQA.png)

Eigen decomposition is very useful in machine learning. It is particularly useful for concepts like dimensionality reduction.

For more about eigen decomposition, refer deep learning book, [chapter 2](http://www.deeplearningbook.org/contents/linear_algebra.html)

There are also several other matrix decomposition techniques used in deep learning. [Look here.](https://heartbeat.fritz.ai/applications-of-matrix-decompositions-for-machine-learning-f1986d03571a)

**Norms:**

**Overfitting and underfitting:**

**W**hen you attend a deep learning lecture, you often hear the term overfitting and underfitting.These terms describe the state of the accuracy of the deep learning model.

![](https://cdn-images-1.medium.com/max/800/1*_7OPgojau8hkiPUiHoGK_w.png)

This image is the best explanation of overfitting and underfitting.

Overfitting refers to a model that learns the training data too well.It literally mugged up the training data.In overfit models, the training accuracy is very high and validation accuracy is very low.

Underfit models have not managed to learn the training data.In underfit models, the training and validation accuracy are both very low.

Both overfitting and underfitting can lead to poor model performance. But by far the most common problem in applied machine learning is overfitting.

To reduce overfitting, we have to use a technique called **Regularization. _It prevents mugging up the training data, so as to avoid the risk of overfitting._**

It is the **most important responsibility** of the deep learning engineer to create a model which fits generally to the input. There are several methods of regularization.Most notably the **L1 regularization( Lasso ) and L2 regularization( Ridge ).**

The details of these are not provided, but to understand these you must know what is a norm.

**Norm:**

Norm is the size of the vector.The general formula for norm of a vector **_x_** is given by,

![](https://cdn-images-1.medium.com/max/800/1*51aoPMb2DjeeuLCBQ0qT2Q.png)

the **L² norm** with p=2 is called the euclidean norm because it is the euclidean distance between origin and **_x._**

The **L¹ norm** is simply the sum of all the elements of the vector.It is used in machine learning when the system requires much more precision.To differentiate clearly between a zero and a non zero element. The L¹ norm is also known as **Manhattan norm**.

There is also **max norm,** which is the absolute value of the element with the largest magnitude.

The L² norm equivalent for a matrix is the **frobenius norm.**

![](https://cdn-images-1.medium.com/max/800/1*OTD-K5jjCklutYc-c-dkQQ.png)

frobenius norm.

Not only in regularization, norms are used also in optimization procedures.

Ok, now after all these concepts and theory, we have come to cover the most important part required for deep learning.They are vectorization and broadcasting.

### **Vectorization:**

It is the trick of reducing execution of loops and make process execute in parallel by providing data as vectors.

Many CPUs have “vector” or “SIMD”(Single Instruction Multiple Data) instruction sets which apply the same operation simultaneously to two, four, or more pieces of data. SIMD became popular on general-purpose CPUs in the early 1990s.

For more detailed information, look for [Flynn’s classification.](https://en.wikipedia.org/wiki/Flynn%27s_taxonomy)

![](https://cdn-images-1.medium.com/max/800/1*23cQOr3db-kngEFo8l9z1w.png)

Vectorization is the process of rewriting a loop so that instead of processing a single element of an array N times, it processes (say) 4 elements of the array simultaneously N/4 times.

Numpy has heavily implemented vectorization into their algorithms. Here is an official note from numpy.

> Vectorization describes the absence of any explicit looping, indexing, etc., in the code — these things are taking place, of course, just “behind the scenes” in optimized, pre-compiled C code. Vectorized code has many advantages, among which are:

> vectorized code is more concise and easier to read

> fewer lines of code generally means fewer bugs

> the code more closely resembles standard mathematical notation (making it easier, typically, to correctly code mathematical constructs)

> vectorization results in more “Pythonic” code. Without vectorization, our code would be littered with inefficient and difficult to read for loops.

**Code example:**

```
\## to add two arrays together.

\## consider two basic python lists.
a = \[1,2,3,4,5\]
b = \[2,3,4,5,6\]
c = \[\]

\## without vectorization.

for i in range(len(a)):
    c.append(a\[i\]+b\[i\])

\## using vectorization.

a = np.array(\[1,2,3,4,5\])
b = np.array(\[2,3,4,5,6\])
c = a+b
```

The above code example is an overly simplified example of vectorization.And **vectorization really comes into picture when the input data becomes large.**

For more details about vectorization, [look here.](https://en.wikipedia.org/wiki/Array_programming)

### Broadcasting:

The next important concept is broadcasting. Sir Jeremy Howard in one of his machine learning lectures, told that broadcasting is probably the most important tool and a skill to have for a machine learning programmer.

From the [Numpy Documentation](https://docs.scipy.org/doc/numpy-1.10.0/user/basics.broadcasting.html):

    The term broadcasting describes how numpy treats arrays with different shapes during arithmetic operations. Subject to certain constraints, the smaller array is “broadcast” across the larger array so that they have compatible shapes. Broadcasting provides a means of vectorizing array operations so that looping occurs in Cinstead of Python. It does this without making needless copies of data and usually leads to efficient algorithm implementations.

![](https://cdn-images-1.medium.com/max/800/1*AbfEjGON0C52GcwQ18bvTw.jpeg)

code example:

```
 a = np.array(\[1.0, 2.0, 3.0\])
 b = 2.0
 a \* b
 array(\[ 2.,  4.,  6.\])

this is similar to

a = np.array(\[1.0, 2.0, 3.0\])
b = np.array(\[2.0, 2.0, 2.0\])
a \* b
array(\[ 2.,  4.,  6.\])
```

The array b is expanded so that arithmetic operation can be applied.

Broadcasting is not a new concept. It is a relative old tool that dates back to 50’s. In his paper [“**Notation as a tool of thought**”](http://www.eecg.toronto.edu/~jzhu/csc326/readings/iverson.pdf), [Kenneth Iverson](https://en.wikipedia.org/wiki/Kenneth_E._Iverson) describes several tools for mathematical usage that allows us to think in new perspectives. Broadcasting was first mentioned by him not as a computer algorithm but as a mathematical procedure.He implemented many of these tools in a software called [APL](https://en.wikipedia.org/wiki/APL_%28programming_language%29).

His son later extended his ideas and went on to create another software called [J software](http://www.jsoftware.com/http://www.jsoftware.com/). This gesture means that with software what we get is over 50 years of deep research and using these we can implement very complex mathematical functions in a small piece of code.

It is also very handy that these researches have also found their way into languages we use today like python and numpy.

_So bear in mind that these are not very simple ideas that came overnight. These are like the fundamental ways to think of mathematics and it’s implementation in software. (The above content is extracted from fast.ai machine learning course.)_

for more details about numpy version of broadcasting, [look here](https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html).

Ok, that’s enough, this article introduced a lot of new words and terminologies to the beginner.But I have also skipped several in depth concepts of vector algebra.This can be overwhelming but still I made the concepts as practical as possible,(feedbacks welcome!).

As I have just started in deep learning stuff, I decided to help others who have started, by providing them intuitive articles about deep learning terminologies and stuffs. So if you feel any mistake in these articles, please post it in comments.

**Below are some of the useful resources:**

In depth intuitive linear algebra videos: [3blue1brown](https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab)

e book: [https://www.math.ucdavis.edu/~linear/linear-guest.pdf](https://www.math.ucdavis.edu/~linear/linear-guest.pdf)

Best site to learn deep learning: [fast.ai](https://www.fast.ai/)

A complete learning book: [deep learning book by Ian Goodfellow.](https://www.deeplearningbook.org/)

Thanks for reading :)


Explains concepts like matrices, vectors, eigen values, etc

Linear algebra for deep learning

Explains concepts like bayes theory, variance, distributions, markov chains, etc

Probability and Statistics explained in the context of deep learning


This is a list of useful Linux commands. Most of them are basic and they can be used as a reference for developers.

#### files and directories

- ls => list all files
- ls -a => list all files along with hidden ones
- ls -R => list all files and folders recursively
- ls -l => list in long format (shows more info)

- rm \<filename> => deletes a file
- mv \<filename> \<directory path> => moves a file
- mv \<srcFileName> \<destFileName> => renames a file
- cp \<srcFileName> \<destFileName> => copies file
- cp -R \<srcDir> \<destDir> => copies directory

- cat filename => read contents of a file
- cat > filename => writes to file
- touch filename => creates a file, touch is basically used to change file timestamps. Refer [here](https://www.howtoforge.com/tutorial/linux-touch-command/)

- mkdir directory name => makes a directory
- rmdir directory name => removes a directory
- rm -rf directory name => removes a directory recursively along with the files
- mv dirname1 path or dirname => moves or renames directory

- history => list all commands used in the current session
- clear => clears the terminal screen
- pwd => displays the path of the current working directory.

#### file permissions

File permissions will be provided to users, groups and others (in the same order). They can be provided as numbers or letters.

r - read, w - write, x - execute
u - user, g - group, o - other, a - all

0 - no permission
1 - execute
2 - write
3 - execute + write
4 - read
5 - read + execute
6 - read + write
7 - all

- chmod number filename => gives permissions to user,group and others.

Eg: `chmod 777 ex.txt` => gives all permissions to all users, groups and others.

'+' - gives permission
'-' - removes permission
'=' - assigns the given permission

Eg: `chmod u=rw ex.txt` => gives read/write to user
Eg: `chmod a= ex.txt` => removes all permission to all users.

- chgrp group name filename => changes group for a file
- chown user filename => changes owner of a file

#### input/ output directions

- '>' write (stdout)
  Eg: ls -al > filename => writes the output of "ls -al" to the file. If the file already exists, it is **overwritten**.

- '>>' append (stdout)
  Eg: `echo "hi" >> filename` => appends to the file

- '\<' input

File descriptors : 0 - stdin, 1 - stdout, 2 - stderr

##### Error redirection:

This is used to redirect errors to a log file, rather than cluttering the terminal.

Eg: `cat ex.txt 2> error.log` => tries to read the file, if there is any error, it is written to error.log

Here, '2' is the file descriptor for stderr.

#### working with pipes

##### pg, more and less

Show large text in the terminal as scrollable chunks by piping it to the pg, more or less commands.

Eg: `cat large_file.txt | less` => gives a scrollable viewer.

##### grep

Search for a string in the output by piping to grep.

Eg: `ls | grep key` => shows files that have a string "key".

Flags:

- -i => case insensitive
- -c => displays only count
- -n => displays matching line and number
- -v => displays output that didn't match

Eg: `ls | grep -cv key` => displays count to output that didn't match

- grep can also accept regular expressions. Refer [here](https://www.guru99.com/linux-regular-expressions.html)

##### sort

Sort the contents

Eg: `ls | sort` => displays in alphabetic order

Flags:

- -r => reverse
- -n => numerical
- -f => case insensitive

Eg: `ls -l | sort -nk2` => displays content numerically sorted on the second column. (number of hard links in this case)

#### variables

- VARIABLE=value => Set variables in the session.
- $VARIABLE => gets the value of a variable.
- unset VARIABLE => unsets the variable.

#### networking commands

- ping ip => checks the connection
- dig hostname => performs a dns lookup
- ssh -i key username@ip => connects to a remote computer securely. key is the private key file.
- scp -i key.pem source dest => copies a file. remote location should be `host:file`.
- lsof -i protocol:port => list all processes listening on a port.

Eg: `lsof -i tcp:3000` lists all processes listening to port 3000

#### process management

- top => lists all running process
- kill pid => kills a process with the given process id

#### mount device

- lsblk => list all block devices
- mount device id directory => mount a device to a directory

Eg: `mount /dev/sda4 /ex/mnt`

Flags:

- -a => mounts all devices in /etc/fstab
- -l => lists all mounted devices
- -t => type of filesystem (eg: ext4)

- umount device id => unmounts a device

#### manual

- man command name => shows usage of a command

Thanks for reading :)
