Seafile and Photoprism

Amidst all the chaos with my file synchronisation and Ecosystematic-Wall with Nextcloud, it was probably the best decision to move to Seafile and Photoprism. I spent the last week testing things and they turned out well and I quite like them!

Seafile and Photoprism are amazing in their respective domains and they have their own issues to solve in their own domains. So arguably that makes the platform better and better with time. I have a lot of hopes on both of these services since they have made my life so much easier with file storage and photos/videos organisation.

However, Photoprism lacks multi account support as of now (its on the roadmap) and I’m hopeful for this release since the service is already very neat and polished!

What Test? MINETEST!!

I just love minetest! I had played the game before, but boy oh boy! when it’s paired with other players who are your friends and relatives in your own server, the fun is almost ten folds than that of single player. I kind-of hate myself for not trying it out during the lockdown since this would have been a fun way to virtually meet my buddies (I hope).

Better late than never! Now I have finally created a world and I have added tons of mods to the server and made it customisable to my needs. Just in case you want to build one for yourself, you can find the mod info here. I will eventually open it to the world once I learn how to moderate the server better. I want my world to be a fun filled place, I just gotta learn to be a good admin :)

And I hope you are having a nice day, or nice night, depending on where you are reading from :)

Categorized Under #SelfHostedExperiments

Tags : #Nextcloud #Photoprism #Seafile #Minetest

Timestamp : #June2021

So, Minetest!

I had been playing a lot, like a loooot lately. The best thing about minetest is that it is open source. So you get a ton of community attention over the game and the community makes the game better by sending PR’s and patches that make the game better altogether. I also added tons of mods that were community contributed (trust me, that took a while to setup) But that just means you can mod the game any way you want to. Sky is the limit here!

So out of excitement I uploaded this screenshot of a beautiful morning on fediverse!

Minetest ♥️

Categorized under #SelfHostedExperiments

Tags : #Minetest #Game

Timestamp : #June2021

So, What Happened?

I was trying to move photos from Nextcloud to Photoprism (Docker). Photoprism has a feature where I can add a WebDav folder and it will sync the photos automatically. That’s great! Because I don’t need to download the photos manually and then upload it to Photoprism. I was seriously liking the whole process and it made my life a bit simpler while setting up these services. After the sync, I deleted the WebDav folder from Nextcloud (of which the photos were synced) like a good boy since the photos were already copied and started organising the photos in Photoprism.

It was genuinely a good productive day. Things had gone as per the plan and it couldn’t have been any better. And I called it a day and had a very sound sleep.

The next day, to my surprise, the photos that I carefully collected over the years were lost (Mysteriously). There was nothing more terrifying at that moment when I saw my gallery folder empty!!

Yeah, But How?

Apparently, Photoprism and Nextcloud folder was on sync. That means, whenever the folder in Nextcloud changes, Photoprism also does that change in its folder and its consequent database.

After the sync, Like I deleted the WebDav folder from Nextcloud (of which the photos were synced) like a good boy and started organising the photos in Photoprism.

This is where I did a blunder and everything was gone! Since Photoprism saw no photos in the Nextcloud folder, it went ahead and deleted everything from its folder. Simple!

And, How did you recover them?

So, Nextcloud has a built in trash feature which I had enabled while I had installed Nextcloud in my server. After the migration, I had deleted the Nextcloud folder in the Nextcloud web interface which will move the folder from files to files_trash.

It took me a while to get there since web_ui in Nextcloud was unresponsive and amidst all this confusion, I forgot that there was even a files_trash folder in the Nextcloud setup. I should have removed the Nextcloud <–> Photoprism sync first before deleting one of the folders.

Then a quick copy and import recovered all the photos and videos. However then I carefully deleted my Nextcloud without affecting any other components in the setup. Phew! it was a really long morning. A Lesson for Life.

Categorized under #Note

Tags : #Lessons4Life #Nextcloud #PhotoPrism #Seafile #Photos #Videos

Timestamp : #June2021

“The efforts that I’m putting into self hosting and maintaining xyz service on my RaspberryPi really worth it? Or should I move to some other service or create an account in somebody else’s self hosted setup?”

After this self-introspection, it occurred to me that there are a few changes I had to make in my self hosted setup, and this is a result of a lot of brainstorming related to it.

Why not Nextcloud?

Yes exactly, Why not Nextcloud? It’s amazing. It has a lot of add ons, plugins, custom css and many more. Just make sure you install it properly and you don’t need to worry about installing another service for news/podcasts/calendar/contacts and much more.

Yes, I get that. That’s what anyone would tell. But the flipside of the coin is that, you are using one service to be a base for every other type of service you use. So even when one of the service starts being janky, you are deemed to stay with it. Since I use a RaspberryPi to self host most of my services, Nextcloud would take up almost all the memory not to leave any space for any other service I would like to deploy.

I used nextcloud as a drop-in replacement for Google drive and Google photos all in one. Eventually I started to make it as my ecosystem keeping my calendar and contacts in sync with it. It’s a really good service but not good enough to be self hosted on a raspberry pi and low-memory chips.

What next?

I’m planning to move to a diversified ecosystem than putting all my eggs in one basket. I’ll focus on services that does one thing and does it well. (I briefly spoke about it in this toot) And have different services to host files (?seafile) and host photos/videos (?photoprism). So that when they become unusable for my use-case, they can be easily replaced. Hopefully when I upgrade my setup to use machines with better memory, maybe I’ll come back to Nextcloud. Until then, Bye Nextcloud :(

Categorized Under #MyTechXperiments

Tags : #nextcloud #ecosystem #files #photos #selfhosted

Timestamp : #June2021

What went wrong with hugo?

Don’t get me wrong, I really like Hugo. I really love the way it is customisable to its core. You can create new pages from the existing template, or write a new layout altogether. And boy oh boy! there are tons of themes available. All you gotta do is just run a command and the theme is live. I loved this idea so much that I had made my own Theme for Hugo which then was used to theme my own website.

However, that’s about where the advantages end. Eventually things started to crumble down when I started putting more efforts in setting up the layout and theme for my website when I should be spending more time writing my articles. In the end of the day I would spend so much time just fixing the layout, I would have no more patience to write an article on top of that. As exciting as building a brand new statically generated fully customisable website sounds, it sure comes with its qualms.

…And, Write.as?

Yes. So I decided to move to write.as since I believe it offers me a proper balance between customisability and usability. It lacks some features that I enjoyed having in Hugo (separate tags and categories to organize my content well). But I think I’ll find my way around it as I go. Write.as has theming support that lets you add Custom CSS and JS to your site. So yeah! I don’t regret moving to write.as for my personal website and blog.

I’ve really missed how I can just jump in, write my mind and publish! ✌🏻

Categorized Under #MyTechXperiments

Tags : #Hugo #WriteAs #PersonalWebsite #Blog

Timestamp : #June2021

Originally Posted on Apr 2, 2021

Categorised under #MyTechXperiments

I had always been interested in writing about the things that were of interest to me. Especially, when I started coding with technologies that were unknown to me, everyday was a new beginning and everything was something that I can tweak around with and come up with something entirely new to me. The whole process was so exhilarating that I wanted to document it in it’s entirety and write about things that pick my interest.

Therefore I took the path that was obvious to anybody who would want to write articles on the internet, Medium. To be very honest, I don’t have a problem with Medium. Nor that I had any in the past. But, I always wanted to post my articles in my own domain where I have more control over my infrastructure and my content. Where I TRULY own my content. It was not possible in the past since I wasn’t so technically sound to build an infrastructure for web hosting, and renting one was a far cry.

8 months ago, I bought my first raspberrypi microcontroller to learn networking and self hosting. And I was also fascinated by the infinite possibilities of building things with this credit-card sized computer. Hosting my own website was definitely not a priority to me then. I just wanted to acquire knowledge, so much that, I don’t panic when things go wrong with my setup (which happens all the time). And it definitely took me a lot of making-and-breaking to get things setup properly and finally to be able to host my own website and post my articles in my domain. (Of which this is a first one)

Currently I self host Nextcloud (A self hosted cloud), Jellyfin (A self hosted media center) and Gitea (A self hosted git service) On my raspberrypi microcontroller and access these services outside of my home network. And I’m amazed by how modular and convenient the setup could be when combined with docker to manage the containers running on top of the host. Self hosting has given me a new dimension to think about the tools that I could use to make my digital life more convenient and more user friendly. It has also been an amazing place for me to learn things that I have never thought I would ever come across. I have learned more about things that would not work than things that would. All in all it was a fun journey. And cheers to many more to come. :)

Originally Posted on Feb 5, 2018

Categorised under #Opinions

“Leave this ecosystem? No way! Why should I leave it when they are providing everything for free and it’s so convenient when everything is just there when you want it!” Yep! This is me approximately one year ago when I was heavily tied into the Google Ecosystem and I had been totally involved in all aspects inside this Ecosystem for five to six years straight. And it took me couple of months to actually explore the internet and discover why it was a bad idea. It’s very easy to say that any service on the internet is convenient because it makes your life so easier. However, every convenience comes with a cost. In here, your freedom of choice and your privacy is at stake!

The Problem

I didn’t find the idea of moving out of my ecosystem was considerable because my Ecosystem seemed like my ‘Eden Garden’ where everything I wanted to do was in my hand’s reach. Want to store and retrieve photos easily? Use Google Photos. Want to store your documents? Use Google Drive. Want to edit those documents? Use Google docs. Want to add your photos to those documents? Google photos is integrated with Google docs. It’s as if the your Ecosystem knows what you want to do even before you even think of doing it. This nature of an Ecosystem poses us with two big problems.

• Privacy : Your Ecosystem knows a lot about you already to understand what you would possibly want to do (Only if it’s collecting your data which is what most of the ecosystems do).\
• Restriction : Your Ecosystem confines you inside its walls restricting you from even thinking about migrating from your services because if you do, you may have to give up some of that convenience. And it’s gonna take a lot of time to unhook the hooks the ecosystem puts on you.

Privacy in an Ecosystem is a bigger discussion in itself. I want to specifically talk about the second one where it confines you inside its walls, which had happened to me. Convenience is like a drug (to put it bluntly). And even if I had known that my ecosystem tracks me 24⁄7, I was reluctant to give away my convenience. When you are heavily tied into an Ecosystem, you stop looking for other services which are clearly better because whatever your Ecosystem provides is the one that would work best for you in the current state and even if it’s something crappy and something you didn’t like, you would have to live with it. This is how the Ecosystem suppresses your freedom of choice by making you enslaved for what you are being provided, not for what you have demanded. That is basically monopolistic nature put into digital media.

The Realization

Last year, I chose to read ‘Permanent record’ by Edward Snowden. It really changed my outlook and it made me question my online presence. It was really implicative when I looked back at my “Ecosystematical” lifestyle and how much I was missing out on the true essence of what makes the internet special. And, I decided I would migrate my data to those services that are clearly better and explore the wide world out there. And the journey was painfully slow because I had an archive of 50+ GB’s of photos in Google Photos and most of my documents were backed up in Google Drive.

The Takeout Process

Google has a takeout program where you can select all of your data and then request for a copy. Google then aggregates your data and then compresses them down to a zip file. You’ll get an email in your gmail inbox. Then you can download your data through the link. Easy right? No!!

What Google does, is it lets you choose how big of a data chunk you want to download. Say you have an archive of 20GB, you can download it in two chunks of 10GB each or 10 chunks of 2GB each. And those downloads will fail if your internet connection drops down certain threshold. Then you need to retry. If it fails more than 3 times, you need to request for the data again. Most of the people would give up here and choose to spend some more time in this ecosystem until they try again and the cycle repeats.

I had to request for my data thrice and I still couldn’t download all my data. And the only inconvinient process around the whole ecosystem was the takeout process. I don’t know if it was done deliberately, but I had to let go of my 50GB+ of archive which had very important documents and photos. My Eden Garden was punishing me when I decided to move away from it.

The Solution

The solution is to move towards open source projects or towards the services that focus on your privacy. When any service focuses on your privacy, it just means they value you as an end user. Internet means Freedom. So, you should be the one who own your free will to navigate around and call yourself at home. It sure takes a lot of trial and errors to make yourself comfortable by finding a balance between convenicence and digital privacy. But it’s gonna be worth it. The more private you go, less convinient your experience will be. However, there are so many alternatives on the world wide web which is enough for you to build your own convenient ecosystem.

You might want to look at NextCloud Project which is a self hosted cloud solution which has plugins for any use case that you might have.

If you want to start self hosting cheap and best, you might want to look at Raspberry Pi Project which is a credit card sized computer which can be used to host your self hosted setup which can be scaled further in future. The possibilities are endless.

So, Instead of living in someone else’s Eden Garden where you live in their terms, why don’t you make your own Garden and live by your terms. Isn’t that what freedom tastes like?

Originally Posted on Jan 20, 2018

Categorised under #HowTo

I have been using Koa.js for a while now and it turns out to be great. I’m having a lot of fun playing around with it since its simple and configurable. And I was searching for a ground up way to execute file uploads so that I can tweak its functionality however I want to. And it turns out, It’s not as difficult as I thought. Before going forward, I’m assuming you have a basic knowledge of how to setup basic Koa.js server with routers since it’s being covered in so many articles. So I’ll be skipping the server setup with routers. Click here if you want to go through an article that covers the same. So, Lets get coding.

Server Page : app.js

// app.js
const Koa = require("koa");
const koaBody = require("koa-body");
const logger = require("koa-logger");

const router = require("./router");

const app = new Koa();

app.use(koaBody(
    { multipart: true }
));

app.use(logger());

app.use(router.routes()).use(router.allowedMethods());

app.listen(3000, () => {
    console.log("Listening at 3000");
});

The above app.js file starts up the server and starts listening in port 3000 for requests. Simple stuff, nothing fancy. But things to be noted are the koa-body module and { multipart : true } option. This part is really important, since koa-body parses the request body and populates Koa ctx object based on the form data being sent. When a file is being sent from the front-end, koa-body parses the request and the uploaded file attributes will be available under ctx.request.files which we can then access across Koa server to implement file upload functionality

Router and Upload Logic : Router.js

Well, Its not a good practice to add the server logic under router.js file since router is only used for routing the requests. You will have a controller file to take care of the logic when the request is being routed from router. But for the course of this tutorial, I have written the logic in the router itself.

In this part, you will need a package called promisepipe which I’ll explain in a second. For now, install the package by running the following command. And create a folder named uploads in the root of the project which will hold uploaded images.

npm install promisepipe

// router.js
const Koa = require("koa");
const Router = require("koa-router");
const promisePipe = require("promisepipe");
const fs = require("fs");
const path = require("path");

const router = new Router();

router.get("/", (context, next) => {
    context.body = "Hey";
});

router.post("/upload", async (context, next) {
    try {
        const uploadfile = context.request.files.file;
        const savefile = `${Date.now()}#${uploadfile.name}`;
        const readStream = fs.createReadStream(uploadfile.path);
        const writeStream = fs.createWriteStream(path.join("uploads", savefile));
        await promisePipe(
            readStream.on("error", () => {
                throw new Error({
                    errors: "File Read Error"
                });
            }),
            writeStream.on("error", () => {
                throw new Error({
                    errors: "Write Error"
                });
            })
        );
        context.body = {
            message: "File Uploaded"
        };
    } catch (err) {
        console.log(err);
        context.body = {
            message: "There was an error",
            errors: err
        };
    }
});

module.exports = router;

The Upload Logic

Anything that is written in the bold letters in router.js is important and I’ll be explaining the mode of execution one by one.

• /upload : This is the POST route handler that contains the logic of what needs to be done when the front-end makes an upload request with a file attached to its body. When the URL is hit, the function gets executed.\
• uploadfile : File attributes from parsed context.request.files.file in uploadfile stored in this variable so that its easier to access it later on in the code. In simple words, uploadfile contains the reference to the file to be uploaded to the server.\
• savefile : The file name to be stored in the folder has to be unique since the same name will be stored in the database to trace down the files from the folder later. So we use {Date.now()}#${uploadfile.nameto create unique name *(where uploadfile.name is the name of the file to be uploaded)*. Which will give us a string of 1560234246152#anyfile.txt for example. Since we add the timstamp, filename stays unique and it will be stored in savefile variable.\
• readStream/writestream : Stream is nothing but a flow of bits from one end to another end. In here, we create a read stream from user’s local computer and write stream to server’s uploads directory. We pass uploadfile.path which contains user’s local file’s path and uploads folder to write stream. That sets up the stream needed for the upload.\
• promisePipe : promisePipe is a package that takes in two streams ( read / write ) and starts reading from read file to the write file. In here, bits from the user’s local computer file will be written in streams to the uploads directory on the server with the name mentioned in the variable savefile . The best thing about promisepipe is it returns a promise. It returns a resolved response when the uploading is done or returns the rejected response when there is an error. So we can await untill the uploading is done and continue executing code thereafter, or we can use try/catch block to catch any errors while uploading and handle it.

By the end of execution, file will be saved in uploads folder and its name will be stored in savefile variable which can be added to the database for tracking down the files when they are requested. And if there is an error while reading or writing, it will be caught by the catch block and valid response to the front-end will be sent.

Summing it all up

Koa.js is an amazing lightweight configurable framework for Node.js. And arguably, There could be tons of better ways to achieve the same results but this turned out to be the best one for me where i can configure the functionality from the ground up. So if you know of any way to make this code better with added functionalities, I’d look forward to hear it from you. Happy coding. Have a nice day.

Originally Posted on Jan 10, 2018

Categorised under #HowTo

Docker! Sounds fancy and simple but trust me it has revolutionized how the tech industry builds, ships and deploys the applications lately. Docker is basically a mini-operating system where you build and run your applications which is totally isolated from the native operating system in your computer, and the same container can be deployed in the hosting platforms. If you are new to docker and want to learn more about its intricacies, i highly encourage you to go through the links given in the end of this article to learn more about it. So let’s get right in :)

Creating a Dockerfile

Dockerfile is the recipe of an image. Dockerfile specifies how your image should look like. However, we are not creating an image from the scratch. We will take the existing image and add our dependencies on top of that to create a customized image based on our requirements. You can setup the Dockerfile to either take the existing requirements.txt file and install dependencies from pip or install dependencies manually without requirements.txt. This is how the Dockerfile will look like in either of the situations.

    FROM python:3

    RUN mkdir /usr/src/app
    WORKDIR /usr/src/app

    # Below two steps are valid only if you have
    # requirements.txt in the project folder
    COPY requirements.txt .
    RUN pip install -r requirements.txt

    # If there is no requirements.txt,
    # You can install individual packages as follows
    # RUN pip install <package-1> <package-2>...<package-n>

• FROM: The image that we are building has to be built in such a way that we take an existing image and add our own functionalities to it. So we are choosing an image with python 3.x since we are dealing with Python developement. However, You can choose any image or any version you want.\
• RUN: This will run a command inside the image. Since our image is a mini linux OS (usually debian distribution) we can run linux commands inside it. Here we run mkdir /usr/src/app which creates a working directory for our application to run. Which is not absolutely necessary since its automatically created in the next step. This step was a demonstration of how to run commands inside an image.\
• WORKDIR: This specifies the working directory of our image. After setting the WORKDIR, Any RUN, CMD, ENTRYPOINT, COPY and ADD commands we execute, will be executed inside the WORKDIR . In our case, its /usr/src/app .\
• COPY: This command will copy any file specified on the left before the space to the directory specified on the right of the space. In our case, we are copying requirements.txt from our project folder on the host to our WORKDIR /usr/src/app in the image And running pip install -r requirements.txt on /usr/src/app which will install and save all the pip dependencies inside the image.

If there is no requirements.txt, you can skip the COPY step and install pip dependencies by specifying the pip install command in the RUN section one after the other. And save the Dockerfile with the name Dockerfile

We successfully created a recipe of how our image should look like, now the next step is to build the image based on this recipe.

Building from the Dockerfile

Now since we are done with creating our recipe, we need to build our own image from the recipe. To build the image, the command is as follows

docker build -t python/pack .

docker build is the command that tells docker that we need to build our own image. -t python/pack is where we add our own name for the new docker image. we can also add tags to the image using -t python/pack:latest where latest is the tag for the image. (although latest is a default tag for any new image) . tells the docker to use the current directory in lookout for Dockerfile . If the Dockerfile lies in different directory, you can specify the path from where you would want to build the Dockerfile . Once the build is finished, you will have a Customized docker image based on your recipe, and you can check it by running docker images command in the shell. You should see an image called python/pack

Creating a Container

Containers are the place where we execute our programs by mounting our local volumes to the container volumes. From where you can access the packages and dependencies installed in the container meanwhile, persisting the data to the host system. Run the following command in bash

docker run --rm -it 
-u $(id -u):$(id -g) 
-v /etc/passwd:/etc/passwd 
-v $(pwd):/usr/src/app 
python/pack 
bash

This creates a container based on the image python/pack where you can accesss your project files from the directory /usr/src/app and then you can execute the code as you would do in your host machine. Lets break this command down line-by-line:

• docker run –rm -it : docker run tells the docker daemon that we want to create a new container, -it is where we run this container in the interactive mode. -i basically keeps the STDIN open and -t allocates a pseudo TTY. In simple words, -it is essential to open a bashshell inside the container, later. You can also use -d instead of -it which starts the container in detached mode, which starts the container in the background.\
• -u $(id -u):$(id -g) : It is not recommended to start a container as a root user. So we specify -u flag and then user ID $(id -u) and group ID $(id -g) to start a container as a regular user. Now we will have previliges over only that directory which is mounted to the container and not the entire container. This is the cleaner way of creating a container.\
• -v /etc/passwd:/etc/passwd: This -v argument mounts /etc/passwd of the host to /etc/passwd of the container. Otherwise the docker container can’t access the usernames and display I have no name! in the bash prompt. Mounting /etc/passwd solves this problem.\
• -v \$(pwd):/usr/src/app: This -v argument mounts your project directory to /usr/src/app by doing which you can access your code in the project directory inside the docker container and the changes made inside the docker container will be available in the project directory (pwd prints the present working directory). So in simple words, this creates a shared space between the container and the host machine from where the host machine can access the packages and dependencies installed in the docker image.\
• python/pack: This is pretty straight-forward. This is where we mention, which image is the container will be based on. The resulting container will contain the architecture of the mentioned image.\
• bash: This is where we mention the command to be executed soon after the container is created. Since we want the bash prompt, we specify the command bash which opens a bash shell soon after the container is created.

By the end of this process, we will have a container which is built with the dependencies we need, sharing a same space as our project directory, totally isolated from out host machine. This is really useful since the dependencies are not installed in the host machine. The host machine only contains the project folder but it runs inside the customized container. Clean stuf !!

Extras/Troubleshooting

• Editing a Docker Image : Let’s say you have created a Docker image with 3 packages and now you want to install a new package to the already built image. You can do it by editing the imageDockerfile and running the same command docker build -t python/pack . and docker will make changes to the existing image from where the content of the Dockerfile has changed. To make these changes, it is important to note that Dockerfile is in the same folder as it was initially built. Because Docker daemon uses current Dockerfile folder as a build context and when changes to the Dockerfile is made, build context will be checked and from there the Image will be built.\
• Port Forwarding : Port forwarding is such a useful functionality inside docker container. Let’s say you are using Jupyter notebook inside your docker container and it exposes a port 8888. But it will be on the context of the container, and not on the host machine. So if you go to localhost:8888 in the host machine, it won’t work. So you map the host’s 8888 port to container’s 8888 port when creating the container and then you can access jupyter notebook by going to localhost:8888 on the host machine. You can map a port by adding -p 8888:8888 when creating the container where left side of the : is the port on the host and the right side is the port on the container.

Conclusion

Docker is a revolutionary tech, there is no doubt about that. Once the developement is over, the developed project can be containerized and the container can be deployed in hosting platforms like Digital Ocean. Containers can be made to talk to each other and each container can be used as a microservice. The possibilities are endless. It depends on you how would use this tech to the fullest. Happy coding :)

Essential Docker Commands

• Pull Image from Dockerhub : docker pull <image name>\
• Build a Docker Image : docker build -t <image name> <path>\
• Create Docker Container : docker run [-it/-d] --rm -u <user id>:<group id> -v <host directory>:<container directory> -p <host port>:<container port> <image name> <initial command>\
• List Running Container : docker ps\
• List All Containers : docker ps -a\
• List All Container ID’s : docker ps -aq\
• Delete Single Container : docker rm <container id>\
• Delete All Docker Containers : docker rm $(docker ps -aq)\
• List all Images : docker images\
• List all Image ID’s : docker images -aq\
• Delete single image : docker rmi <image id>\
• Delete all images : docker rmi $(docker images -aq)\
• Start Interactive session with a container started in detached mode (-d) : docker exec -it <container_name> bash

Important Links

• Installing Docker\
• Post Installation Steps\
• Dockerfile, full reference\
• Compose file reference

Originally Posted on Jan 5, 2018

Categorised under #SliceOfLife

Sounds Ridiculous! isn’t it ? Me comparing the Megabytes or Terabytes of senseless one’s and zero’s of code to something that is built with Lego bricks. Lego is supposed to be a fun process, right? But coding seems like spending too much time in front of the computer finding which semi-colon did you miss and where! And bang your head to the wall until you get it right. They’re nowhere close to a match. How is that even possible?

Yeah! you might say that rather sarcastically, or had that notion in your mind all along. But trust me, this is a perfect analogy that I can put forth when it comes to the creative process of coding in its entirety. I call it Lego Coding. And it is something that you are already familiar with, but never acknowledged it for how amazing it really is.

When I was 11 years old, I got my first real personal computer as my Birthday gift (The best birthday gift ever). Being a tech-geek, and being obsessed with pressing random keys in the keyboard for a mere fascination of seeing something on the monitor, coding was not my first intent. Moreover, I didn’t even know a process called ‘coding to makes wonderful things’ existed back then. I, the kid, who was building castles with Lego bricks and breaking it to build new one’s, came across coding C and C++, few years later. And it caught my attention right away. So I did what most of the budding computer geeks and beginners to the art of coding do, you guessed it,

printf(‘Hello My Computer, It’s your boi, Velan’)

(I might have missed the semi colon in my first few attempts, but you get the point) When I saw the output in the black screen, I was freaking out. Running around the house, shouting “My Computer knows my name”. It sounded ridiculous, yet amazing, that you can teach your computer to do things, and it just obeys you without arguing! That is how I was introduced into the art of coding. And it didn’t seem like something that is a tedious process of finding missing semi-colons, (Sometimes I do feel like banging my head against the wall, Sometimes) But It seemed more like building things that I love, with Lego bricks that I was obsessed with, prior to coding. It made me feel curious and expressive. It made me feel like, I can do anything and everything using my creative intent and my computer. And that kept me going to build things with code.

Growing up, I took an academic path where there is a lot of coding and computer science involved, because that is what I was interested in. It was a place of ecstasy to me, where i’m officially experimenting with things that i love doing. But, to my surprise, I was astonished to see not everyone was engrossed into the process of coding as much as I was. And when my fellow student said “I don’t like coding!”, My obvious reply was, “Are you freaking kidding me? How can you even not love playing Lego with code?”. Gradually I realised that, not everyone was introduced to coding like I had been. Not everyone coded because they loved the process, or I could say, They were never enchanted by the thought of playing Lego with code. While I saw C, C++ and other tools as Lego bricks that I can build my castles with, few others saw it as an ‘Academic-Getaway-Pass’ That can get them into introductory interviews, by showcasing good marks. And it was a let down to see an Art getting wasted, By people turning into primary job seekers than turning into primary artists who can build things they love.

Now i’m 21 years old and, I have been coding ever since. Playing Lego with code never gets old to me. And I can’t think of any other analogy that explains the process any better. I‘m never frightened by errors popping up in my code (Trust me, I get so many of them), besides I get frightened when I don’t get one. And coding has kept my childlike creativity and imagination going, and it has given me a new dimension to think about things that I would never have thought otherwise. I don’t code to save someone’s time or save this world from apocalypse or get people on mars, perhaps. I code because i’m enchanted by the mere process of coding as building something that I love, by keeping lines of code one on top of the other and create a system that is as beautiful as my Lego castle was. If my code goes on to save someone’s life or time, I’m glad it did. But my primary intent always remains to code because I love to do it. Nothing complicated. And I've never been tired of it, Nor will I ever be.

If you are someone who doesn’t like coding or someone who doesn’t know where to start coding from or if coding is not interesting to you anymore, Here’s my advice to you (I’m not a professional though. so, you have a total liberty to disagree with me) Coding neither has a how-to-guide, nor a shortcut to be a coding sensei. Starting with coding is as simple as starting with it. It is an art. And art doesn’t come with guides. It is a process of learning through trial and error. If you’re coding, it is highly unlikely that you’ll get things right on the first attempt, YOU DON’T! Most of the people quit here saying, “I’m tired, Let me eat something”. But if you keep the process going, make errors, and learn from them to know where you went wrong, you will have a whole new appreciation for the process of coding as of how it shapes your logic and makes you think in a different light. And few years down the line you will probably sit in front of the computer just like me and write an article on how coding shaped your life, made you a better person, filled your life with creativity. Just in case you do, I’ll be so happy to read through your story someday.

So unleash the art of coding as how you build things with Lego bricks. Write code, Make mistakes, understand the errors and solve them. When you were a kid, it’s highly unlikely that you build a beautiful castle in the first attempt. Similarly it’s highly unlikely that you’ll build a world class software in your first attempt. You will gradually get better with time and practice. And it’s gonna involve a lot of error solving and experimenting. And believe me, when you make something built with code, that you can call your own, You will have a whole new appreciation for the efforts that you’ve put to get there. And that‘s what LEGO CODING does to you. It makes you be proud of yourself for the castle-like structure you have built with your Lego bricks of code. So, have fun writing code, have fun exploring fun new challenges in this world full of possibilities. Have a good day.