surya on Suriya's site

There’s a fantastic performance article by the legendary Jeff Dean, Sanjay Ghemawat that covers the vast span of Performance optimizations that captures a good mental model for performance awareness.

I was reading this paper , It appears you don't have a PDF plugin for this browser.

an agent that learns and optimizes will outperform a frozen 1.8 trillion parameter model. i’m not saying a 7B model is smarter than a frontier model. on a zero-context task the big models win. what i’m saying is that the moment you fix a task, a customer…

mintlify’s cofounder wrote an article about why you should “remember to not smile ”.

It’s been 100 days since I met the guy who will be holding most of my attention for the upcoming decades.

back in 2012 when I moved from pattiveeranpatti, a small village to Chennai, a city in Tamil Nadu. there was something interesting, the kids there had no mental model of villages, farming or the culture around it.

When traced through literary history, there’s a clear trend of smaller and smaller books, War and Peace (Leo Tolstoy, 1869): ~587,000 words.

I hate elon for his political affiliations and his lame comments as much as the next guy.

Postgres is awesome, but can You get away with it being a filesystem or stash space for your application. here are some calculations I did.

What is the cloud ?

drone trained by RL beat the world’s best human pilots (2023) UZH, 2023.

God as an it. everything is subjective perspective of of the self, interacting with the world. because we consider something as thou does not take away the fact that, something is an it. thou is a subjective emotion evoked as a function of the world.

Recursion is often taught in Computer Science 101 as an elegant, mathematically pure way to solve problems and used widely in leetcode style problems.

In the past few weeks there have been examples of successful agent usage at a shocking scale. some in production no less.

make a release build!!!!

I love working at oxen because we strive to be the fastest data versioning tool in the market.

This is such a front loaded question, because depending on where you are in life or where this question is being pointed at (family, career, etc.) and the timeline given It is going to be wildly different.

It is now possible to create content that is, a few order of magnitude more than the total time available to all humans currently alive. and I’m confident a major percentage of them can be tailored to be interesting for a person with specific psyche.

I really love just taking notes, run code and having it in my blog.

I love poor Richard’s almanack specifically because the wisdom hidden within the words is malleable and every time I come back to read it I take something new based on my life experiences since then.

There is work underway to convert this into english. just haven’t gotten to it yet.

convert RW2 format to jpg with imagemagick. while maintaining quality. for f in *.RW2; do magick "$f" -quality 85 "GooglePhotosBackup/${f%.*}.jpg" exiftool -tagsFromFile "$f" -all:all "GooglePhotosBackup/${f%.*}.jpg" -overwrite_original done convert mp4

Overall I loved this book a lot. bought me a new passion for reading fiction. astrophage.

the core principle: think slow, act fast The vast majority of big projects fail—they are over budget, over time, and under benefits.

The question was Implement a program that performs element-wise addition of two vectors containing 32-bit floating point numbers on a GPU.

#include <cuda_runtime.h> float silu(float x){ return x*(1/(1+std::exp(-1*(x)))); } __global__ void swiglu_kernel(const float* input, float* output, int halfN) { int id = blockDim.x * blockIdx.x + threadIdx.x; if(id<halfN) output[id] = input[id%hal…

import torch import torch.nn as nn # input, model, and output are on the GPU def solve(input: torch.Tensor, model: nn.Module, output: torch.Tensor): model.eval() with torch.no_grad(): output.copy_(model(input))

#include <cuda_runtime.h> __global__ void silu_kernel(const float* input, float* output, int N) { int id = blockDim.x * blockIdx.x + threadIdx.x; if (id<N) output[id] = input[id]*(1/(1+std::exp(-1*(input[id])))); } // input, output are device pointe…

#include <cuda_runtime.h> #include <iostream> #include <stdio.h> __global__ void reverse_array(float* input, int N) { int i = blockDim.x * blockIdx.x + threadIdx.x; if (i<N/2) { std::swap(input[i],input[N-i-1]); } } // input is device pointer exte…

ReLU(x) = max(0,x) #include <cuda_runtime.h> __global__ void relu_kernel(const float* input, float* output, int N) { int id = blockDim.x* blockIdx.x + threadIdx.x; if (id<N) output[id] = std::max(0.0f,input[id]); } // input, output are device point…

#include <cuda_runtime.h> #include <iostream> #include <stdio.h> __global__ void matrix_transpose_kernel(const float* input, float* output, int rows, int cols) { int i = blockIdx.x * blockDim.x + threadIdx.x; int j = blockIdx.y * blockDim.y + threadIdx…

The tricky part in this was that, I took some time to intuit that each thread should associate to each value in the output matrix.

#include <cuda_runtime.h> #include <stdio.h> #include <iostream> __global__ void copy_matrix_kernel(const float* A, float* B, int N) { int idx = blockDim.x* blockIdx.x + threadIdx.x; if (idx<N){ B[idx] = A[idx]; } } // A, B are device pointers (i…

#include <cuda_runtime.h> __global__ void matrix_add(const float* A, const float* B, float* C, int N) { int id = blockDim.x * blockIdx.x + threadIdx.x; if (id<N) C[id] = A[id]+B[id]; } // A, B, C are device pointers (i.e. pointers to memory on the…

#include <cuda_runtime.h> __global__ void leaky_relu_kernel(const float* input, float* output, int N) { int id = blockDim.x* blockIdx.x + threadIdx.x; if (id<N) output[id] = input[id]>0?

#include <cuda_runtime.h> __global__ void count_equal_kernel(const int* input, int* output, int N, int K) { int id=blockDim.x * blockIdx.x + threadIdx.x; if(id<N && input[id]==K) atomicAdd(output, 1); } // input, output are device pointers (i.e. poi…

#include <cuda_runtime.h> __global__ void count_2d_equal_kernel(const int* input, int* output, int N, int M, int K) { int idx = blockDim.x*blockIdx.x + threadIdx.x; int idy = blockDim.y*blockIdx.y + threadIdx.y; if ((idx<N && idy<M) && input[idx*M+id…

#include <cuda_runtime.h> __global__ void invert_kernel(unsigned char* image, int width, int height) { int i = blockIdx.x * blockDim.x + threadIdx.x; image[i*4] = 255 - image[i*4]; image[i*4+1] = 255 - image[i*4+1]; image[i*4+2] = 255 - image[i*4+2…

#include <cuda_runtime.h> #include <iostream> #include <stdio.h> __global__ void convolution_1d_kernel(const float* input, const float* kernel, float* output, int input_size, int kernel_size) { int i = blockDim.x * blockIdx.x + threadIdx.x; int outpu…

parkinson’s law “work expands so as to fill the time available for its completion” When Northcote made this observation, this was designed for organisations, but I believe this is a good representation for personal tasks as well.

cold emailing is very powerful, but doing it effectively is a very difficult task.

functional programming (FP) has always seemed like a curiosity – a realm of mathematical purity with little bearing on the practical realities of building robust, scalable software.

Amodei focusing on AI comes from a belief that these risks are the primary obstacles to an overwhelmingly positive future. because if AI is as promising as it is, then it is our job to be that much more careful about it.

I will start out by saying I’m a big fan of ridiculously successful people taking their hobbies/passtimes to extreme ends.

tools hex is the package manager. similar to pip. mix tooling to build, run, test, and release Erlang applications. kinda like cargo for rust.

I used to listen to Charlie Munger’s psychology lectures a lot.

He would have been 27 today.

Every week there is a new agent that the twitter micro-cosmos gets fired up about.