DEV Community: Angad Sharma

Self hosted GitHub Actions using Raspberry Pi

Angad Sharma — Sun, 20 Dec 2020 08:36:44 +0000

We live in a time where anyone can write code. What matters is how efficiently you write and test it and of course how you distribute it. Continuous integration has become a major part of GitOps and github actions has make it very easy to write simple configurations for CI and associate it with an event on your code repository (for example: on code release).

The need

The Github Actions platform provides developers with the power to test and package their code on github's infrastructure for free. But like all free things, this also comes with a catch. You can only run your actions as per a limited quota provided by github. This forces developers to compromise their pipeline to ensure that CI builds run less often. What if I told you that your cheap credit-card sized raspberry pi can be used as a machine to run all of your github actions automatically? Well such is the power of SBCs(single board computers) in 2020.

Ever since the launch of raspberry pi 4, single board computing has reached new heights, with more than 35 million copies sold as per the publishing date of this article, with around 44% of the units sold to industrial customers. In light of this development, this article will be all the more relevant to a wide variety of consumers willing to run more workloads from their internal networks and self hosted comfort zones.

Let us start by elaborating why you would want your github actions to run on the raspberry pi:

Unlimited github actions quota
No need to expose infrastructure from the internal network
Low power draw
Full and sole ownership of data

If you are an enterprise user (or part of an organization that is an enterprise on github), you can pretty much configure your entire organization actions to run on self hosted solutions, but if you are an individual user, you can only do so on a per-repository level. With this information, let us get started with how to offload your github actions to your raspberry pi.

Steps to run your own actions on a raspberry pi

Firstly you will need a raspberry pi with any linux distribution. I prefer Ubuntu server 20.04. Run a quick update and upgrade on it to set it up. Remember that you don't need to configure any kind of port forwarding since this solution will work even if you raspberry pi is not exposed on the external network. You do need an internet connection though since your pi will have to connect to the GitHub servers for this to work.
Go to the Actions setting in your repository (remember, this is a repository level setting rather than a global one. If you are an enterprise user, you can go into your enterprise settings for the same) and press the option to add a new Self Hosted Runner.
In the add self hosted runner section, choose operating system as linux and architecture as ARM64 if you are using a 64 bit raspberry pi, or just ARM if you are using a 32 bit version.
The add self hosted runners section gives you the necessary commands to run inside your raspberry pi to set everything up. After you have pasted those commands one by one, you are ready to starting the service in your pi that will listen or any dispatched actions and perform them internally.
./run.sh allows you to start listening immediately. If you want this service to run permanently in the background, you can run the following command:

sudo ./svc.sh install
sudo ./svc.sh start

Configure your actions to use this infrastructure by using the keyword self-hosted in the actions configuration for the repository for which you have set up the actions. For example:

name: Go Build

on:
  push:
    branches: [ main ]

jobs:

  build:
    name: Build
    runs-on: self-hosted
    steps:

    - name: Set up Go 1.x
      uses: actions/setup-go@v2
      with:
        go-version: ^1.15

    - name: Check out code into the Go module directory
      uses: actions/checkout@v2

    - name: Run Build
      run: |
        make build

Conclusion

Raspberry pi attracts a huge community of enthusiasts who use it for various use cases. There have been amazing projects like the turing pi, which make use of the more compact Compute module 4 of the raspberry pi to provide server grade computing. Projects like these have enabled developers and system administrators to get cheap compute for self hosted workloads. Easy GitOps is just another fun yet sustainable solution to configure to your own satisfaction, whether it be for a fun project or an industrial use case.

InstantWM: Animations in a Window Manager!

Angad Sharma — Thu, 08 Oct 2020 13:29:24 +0000

InstantWM is a window manager to InstantOS, which is an Arch-Linux based operating system that aims to work right out of the box and also cater to power users. It went through a lot of scrutiny and controversy in it's development process, primarily due to faulty reviews from a particular youtuber (distrotube).

The developer subsequently released a video with some bugs either excavated, or altogether nullified by the faulty review. When the smoke settled, people started reviewing InstantOS, but no one has really made a standalone review of InstantWM, which is the window manager that the OS uses, and can be installed on any distribution. I feel like this window manager deserves its own "series" of reviews.

First Impressions

I usually start my reviews with features and the installation procedure, but for this particular WM, I felt that a first impressions review is necessary due to the underlying controversy.

It is the best and the most versatile window manager I have used in a while

Considering I have used stable and extendible WMs such as xmonad and i3, instantWM bring a lot to the table. On first glance, it looks like a dwm fork. That is because it is, but only 40% of the suckless code is remaining in the instantWM repository.

It's versatility comes in the fact that it is both a tiling and a floating window manager. It has a menu like awesome, and you can even use it with a mouse instead of a keyboard, which makes it suitable for newcomers as well. It's modernity is in the fact that it is both minimal and fashionable at the same time, with it's attractive window animations and compsiting effects without sacrificing any functionality.

Features

InstantWM is no joke. It is feature rich without sacrificing on functionality and usability. Some of its main features include.

Patchless configuration (you don't have to manually patch things into the config)
Modern window transition animations without sacrificing on speed
Full multimedia and multimonitor support out of the box
Instantutils offers a rich set of utilities for support
Hybrid window manager (floating + tiling)
Tag system reminiscent of dwm, with tag pinning support as well

Installation

If you are coming from a dwm background, you can simply skip this section.

You need to clone the instantWM repository and build it from source. This is the same way dwm works. Even the configuration is done in the code itself, and needs to recompile after every change.



git clone --depth=1 https://github.com/instantOS/instantWM.git
cd instantWM
./build.sh

These commands will generate a binary. You can then logout of your current DE or WM and login to instantWW, either using a display manager, or through changing your ~/.xinitrc to say the following:



exec instantwm

Before logging into instantWM, you can download the instantutils, which are available in the linux source repositories. We will touch on what these utilities do later on.



# instantutils is available in the AUR
yay -S instantutils

InstantWM uses the st terminal by default, so make sure you either have an st build or you change the configuration (termcmd) to point to another terminal.

Tiling Modes

The official web page has a rundown of all instantWM layouts. Some high utility ones are:

Grid Layout

This layout arranges windows in a grid of equally sized windows.

Centered Master

One of m favourite layouts, centered master is a layout where the window at the center is the master and all other windows pop up on the left and right hand sides.

Horizontal Stack Layouts - 1 and 2

These are your traditional tiling modes but tiling is done either horizontally or vertically.

Overview

This layout stacks windows in a way that each window is visible and is unchanged from its size in the previous layout.

Half Stack

The master area is tiled normally, but the stack works like the monocle layout with all windows layered on top of each other.

Other layouts are:

Floating
Monocle
Tiling Layout (Master and Stack)

Overlay Windows

Have you ever played games where you get an overlay console when you press the tilde button, where you can enter commands? You can do the same thing to your windows in instantWM.

super + control + w overlays your current window on top of the other windows and essentially locks it in place so it cannot be accidentaly removed. You can then press the same keybinding to undo the action. This gives you a lot of power when you are developing as well as looking at documentation, or a manpage. You can checkout available overlay animations.

Configuration

InstantWM can be configured the same way you configure dwm. If you haven't read my blog on how to configure dwm, you can give it a read here:

Dwm: The Suckless Window Manager

Angad Sharma ・ Apr 7 '20

#linux #opensource #ubuntu

Or you can directly go into the configuration section, to checkout how to tweak instantWM to your liking.

NOTE: A key difference between InstantWM and dwm configuration is that instantWM does not have a patch and diff system like dwm, and additional has a build.sh script that you can run everytime you change a configuration.

Multiple Monitor Support

I do not write about multiple monitor support a lot when I am doing my window manager reviews since the WMs that support this feature usually require xrandr commands to be run in order to set the display, but instantWM comes with an amazing utility for the same.

The moment you plug your external display in, an instantmenu pops up, asking if you want to mirror or extend your display out to the secondary display. This is a great feature that I hope more window managers incorporate.

You can easily switch between monitors and send current windows to the secondary display without leaving your keyboard, as shown in the video above.

Conclusion

InstantWM and its instantutils can be easily downloaded and configured for any system and you don't necessarily have to have instantOS for the best experience. People in the WM community are used to using minimal and lightweight WMs which often compromise on aesthetics. It is great to see a window manager with a modern user experience that is still minimal enough to be installed and used on low power machines.

As of now (when this article was written), instantWM is still in beta and actively looking for contributors. I am glad to see that the developer is also building towards ARM and 32 bit support. I can recommend this window manager to beginners as well as power users due to its outstanding versatility.

Judgement Rubric	Rating
Simplicity of use	❤️ ❤️ ❤️ ❤️
Simplicity of Configuration	❤️ ❤️
Learning curve (lesser is better)	❤️ ❤️
Productivity	❤️ ❤️ ❤️ ❤️ ❤️
Fun	❤️ ❤️ ❤️ ❤️ ❤️

Self Hosting to the Xtreme | Server on Mobile?!

Angad Sharma — Wed, 30 Sep 2020 18:05:37 +0000

How I got a server to run on Android without rooting it.

Continue reading on DSC VIT Vellore »

I Got Tired of Being Un-Informed | Not Anymore

Angad Sharma — Thu, 02 Jul 2020 16:13:24 +0000

How I started reading more than 100 articles a week!

Food for thought: How many times have you wished you could read more? And how many times have you felt disheartened by the fact that you are not reading enough? Well you would feel good to know that it is NOT you who is entirely to blame.

The internet has become a mess of different sources of information and all of them seem relevant, if not legitimate, primarily due to the fact that in this age of misinformation, a lot of us have evolved with an inherent radar for detecting bullsh*t. Still nowadays there are too many sources of legitimate information too, and it keeps on getting outdated and updated.

Then there is the talk of Embracing the Apotheosis of Apps_._ With each one claiming to bring new content to the table and each one aggravating imposter syndrome.

Photo by Aarón Blanco Tejedor on Unsplash

I am a developer by profession. So naturally I love to stay up to date on my GitHub feed. But then I also manage an organization so I need to be updated on that front too. Then I keep on getting notifications of subreddits that I follow, along with daily and weekly newsletters of a plethora of blogs being spammed in my mailbox. Moreover, platforms like DEV and Medium swarm you with an array of meaningful information to churn. I become swarmed! And for the longest of time, this demotivated me. Even though I had a lot of meaningful content at a touch of a button.

In this blog I am going to talk about how I optimized my workflow by organizing information. Subsequently, I am also going to answer the following:

How to get into a habit of reading more
How to stay true to your habit

Step 1: Bringing Everything to one place

Ditch the so-called apotheosis of apps. Ditch your Firefox bookmarks, delete your news apps, unsubscribe to all mailing lists. You don’t need them. THEY need you. They are the ones monetizing your data, which is costlier than oil these days. They are the ones earning from your suffering. If you are waking up in the morning and opening fifteen apps for checking your feed on different social media, then you are doing something wrong.

You can see where this is headed. Rest assured this blog is not an introduction to RSS. If you want that, go here. RSS feeds (or atom feeds), allow you to subscribe to your own feed and view it from special apps called RSS Readers. Almost every blogging and social media platform has an RSS feed. Just look for this sign:

RSS icon (look for this in every website)

The benefit of RSS is that now you only have one application that you need to open, which is your RSS feed reader. You can then get all of your latest news, blogs and feed directly into it. I use newsboat, which is a terminal based RSS reader:

newsboat

You can see that I have my GitHub, Reddit feeds along with so much more. Having this much variety of information would have otherwise required me to have all of the associated web pages bookmarked or their applications installed. This saves a LOT of time. Whenever I start my day anew, I just stir some coffee and go through my RSS feed to get all caught up with everything going around which is relevant to me.

Step 2: Know How to Podcast

Having all of the relevant information in one place means having your favourite podcasts as well. They might require you to open the webpage to listen to them. But you can integrate everything in your reader (at least an advanced reader such as newsboat).

The way I have configured my workflow is that whenever there is a podcast I like to listen to, I just press a macro which I have configured in newsboat, and it automatically plays that podcast in my favourite audio/video player. This saves me the time it takes to open up a browser and press controls that are alien to me, at least when compared to my favourite video player.

Step 3: Take Notes

If you really like something and want to remember it, then what will you do? Surely you won’t take hand written notes on it, especially when everything is written in a concise form anyway. At least I know I won’t. Then it is time to integrate your note distribution application with your RSS reader.

Now if your reader isn’t advanced enough then you can simply save the URL of the particular post you like. I like to integrate Joplin with my newsboat RSS reader. So, with just a press of a macro, I can save any blog/podcast I like (in markdown of course) and sync it across devices (yes, Joplin even has a mobile application).

Step 4: Choose the Right Font

Studies such as A study of fonts Designed for Screen Display claim that human performance in terms of both reading and productivity when working with a screen is affected greatly by the font used. Times New Roman is a great font for writing research papers and journals, but it was made with print in format rather than screen. Fonts like Georgia (serif) and Verdana (sans serif) are a good fit for screens. In the aforementioned research, subjective perception of fonts favoured Georgia, the serif font and participants found it easier to read on the screen than Times New Roman and ended up performing better in the case of the former.

JetBrainsMonoExtraBold font

I, personally, am a huge fan of the Nerd Fonts, especially monospaced fonts. Some of my choices include JetBrainsMono and SauceCodePro, and their respective bold variants. The photo you see above is an example of the JetBrainsMonoExtraBold Nerd Font. Notice how relaxing it is to read. Each and every character is distinguishable from the other and it makes skimming an overall pleasure. I like to use a keyboard with my laptop, so usually I am an extra few inch away from the screen, which makes this font perfect for me as I don’t have to strain my eyes or squint while reading. Note that it is about how comfortable you get, so check out a couple of fonts and decide which one suits your best. It will change your life.

Step 5: Dark or Light Theme?

Now I am a programmer, so you might be thinking you already know what the answer to this question is. The fact of the matter is that although my IDEs and GTK applications are dark themed, but my Joplin app uses the solarized light theme. This is because usually note making or reading is the thing I do in the morning, when my house is flooded with light.

Using dark theme when your background is full of light can actually be bad for your eyes. So, make the choice between using dark at “certain times” of the day, or stick to one or two apps that are always light themed. If you are a vampire and light burns you then you can go for a more solarized theme like I have in the photo above. It is soothing to the eyes without harming them in the long run when being used in a brightly lit environment.

Step 6: Prioritize Through Visibility

Okay so you got your feed reader and note application set up. But what will make you even more productive is you can prioritize certain textual information more than the others. For example, the title of a blog should be the first thing you see, and should be catchy to the eyes. Red is my preferred colour of choice. Although red stings the eyes a bit (more so than other colours), but it is complemented by the fact that we only read the title for a few seconds.

JetBrainsMono Nerd Font with text prioritized through visibility

The body of the document is where the fun begins. It is the part which requires most of your attention, after the title, so it should be catchy to the eyes. But it is the part which you read the most, so it is also supposed to be soothing. I prefer a green body. All of the other metadata like the author and data, are not very important to me so I give them a blue colour on a dark background. Note that these colours depend on the background of your choice to. So, sort out step 5 then take a look at optimizing visibility.

Step 7: Variety Variety Varaiety

One bad thing that I have seen a lot of specialists do is that they try to stick to reading content which is relevant to only their stream. This lack of variety leads to a feeling of repetition and might be a reason for your rut. Moreover, doing this regularly limits your perspective and you find it increasingly difficult to have a professional talk to people who are not part of your specialization. Everyone loves listening to romantic music from time to time. But imagine listening to ONLY romantic music!

Spice up your reading time with variety. Don’t let an essential brain-workout bore you. If you can’t eat pizza every day for the rest of your life, then why should you do the same thing with reading?

Ensure variety in what you read. This allows you to stay up to date with more than one fields and allows you to connect to people who are not in yours. In addition to a bunch of programming feeds, I also have some feeds related to comedy/humor, as well as about people and politics, and I am an avid reader about mental health too. Hackernews is one of my favourite feeds. Primarily because it offers a variety of blogs/news which somehow connect to my field.

Step 8: Tell People About It

Make a public commitment. Tell people about your workflow and what you are trying to achieve. And moreover, share what you have learnt with other people. Don’t be selfish or competitive, after all, knowledge is a source which multiplies the more you spread it.

Start small. Find a person and tell them at least one interesting thing that you read every day. Whether it is a fact, a joke, or some interesting blog about how Deno is the next Node.js. It doesn’t matter. The source must be textual. This ensures instant gratification and gives you a reason to carry on until you have successfully incubated the bookworm in you.

Closing Note

Take a day, take two days, take a week. You will never form a habit if you don’t find joy in doing it. Find what works for you and make it your workflow.

References

This Article was originally published on Medium under Developer Student Clubs VIT, Powered By Google Developers. Follow us on Medium.

My Mom Uses ArchLinux

Angad Sharma — Thu, 25 Jun 2020 09:07:54 +0000

It is almost impossible to install and operate Arch Linux without prior linux knowledge. So why does my mom use it?

Check out my latest article for DSC VIT »

XMonad: Hackability, At a Cost

Angad Sharma — Mon, 15 Jun 2020 14:13:12 +0000

I started using Xmonad a month ago. Usually I live in a Window Manager for a week or so before writing a post about it but took my sweet time with this particular WM, primarily because XMonad has so much to it that even a month of usage doesn't give me enough credibility to do it justice in my posts. Still I will make sure that a beginner can understand how to use it, and most importantly, whether to use it.

If you don't have time to read through the whole thing and want to Keep your confirmation bias at its peak check out some of the cool things you can do with XMonad

Key Features

Suckless in nature and has configuration written in the haskell programming language.
Reload and recompile on the fly.
Dynamic tiling window manager with the ability to add additional layouts yourself.
Custom run menu.
Tags and multi-monitor support.
Lightweight, no-bloat, and blazing fast

Installation

XMonad has different ways to install on different linux distributions. The main thing to note is that it has a core library (called xmonad) and a community library for additional feature support (called xmonad-contrib).

Installation can be done from source (using haskell cabal) or through the distro repositories. For example, in Arch Linux you can run the following to install XMonad:



sudo pacman -S xmonad xmonad-contrib

The installation is different for ubuntu/debian based systems. I suggest you read the documentation for the same.

Note that XMonad itself is minimal but it requires the whole haskell ecosystem to be downloaded on your machine, including the bloated ghc haskell compiler and it might install cabal too, based on the type of installation you opt for. Generally you can build from source, use cabal, or use the distro repositories to name a few.

To start xmonad write the following in your ~/.xinitrc and restart your system.



exec xmonad

Once you do so, you will be greeted with a black screen, and nothing else. You won't even know if you have logged in or not unless you press a right keybinding to spawn a window. You can press mod + shift + enter to spawn the terminal, where mod is the modifier key (windows key by default).

How to approach configuration

XMonad is not like i3 or dwm where you have a pre-populated configuration file which you can edit to your heart's content. The best way to approach it is to look at other people's configuration files. The alternative would be to learn haskell from scratch, look at the step by step guide and learn how to create a configuration of your own. While it is a fun and well documented strategy, it is a long one. If you want a fast result then you can use and edit what other people have spent months configuring. And no, it does not make you a pirate, in fact it is what the XMonad developers suggest on their official guide.

Let us take a look at a minimal configuration. Your config should reside in the following path: ~/.xmonad/xmonad.hs. You can recompile and reload your WM in real-time using the mod + q keybinding.




import XMonad
import Data.Monoid
import System.Exit
import qualified XMonad.StackSet as W
import qualified Data.Map        as M

myTerminal      = "alacritty"
myFocusFollowsMouse :: Bool
myFocusFollowsMouse = True
myBorderWidth   = 1
myModMask       = mod1Mask
-- The default number of workspaces (virtual screens) and their names.
myWorkspaces    = ["1","2","3","4","5","6","7","8","9"]
myNormalBorderColor  = "#dddddd"
myFocusedBorderColor = "#ff0000"

Even though you might not be familiar with the haskell programming language, still the configuration is quite readable. mod1Mask is your standard windows key. If you are like me and prefer to use Alt as a modifier then you can use the mod4Mask key. -- is for comments in haskell. I have added my configuration in the references. Changing keybinding is fairly simple:



  -- launch dmenu
    , ((modm,               xK_p     ), spawn "exe=`dmenu_path | dmenu` && eval \"exec $exe\"")

    -- close focused window
    , ((modm .|. shiftMask, xK_c     ), kill)

     -- Rotate through the available layout algorithms
    , ((modm,               xK_space ), sendMessage NextLayout)

    -- Move focus to the next window
    , ((modm,               xK_Tab   ), windows W.focusDown)

The first part in the parenthesis defines the key combination, where modm is your modifier key. If you want more than one modifier with a minor key then you can use the .|. syntax like I have used to close the focused window. All of these functions are well documented in the step by step guide if you want to learn about them more.

Custom Layouts

If you take a look at the end of the xmonad.hs file, there is a configuration map:



defaults = defaultConfig {
        terminal           = myTerminal,
        focusFollowsMouse  = myFocusFollowsMouse,
        borderWidth        = myBorderWidth,
        modMask            = myModMask,
        workspaces         = myWorkspaces,
        normalBorderColor  = myNormalBorderColor,
        focusedBorderColor = myFocusedBorderColor,

      -- key bindings
        keys               = myKeys,
        mouseBindings      = myMouseBindings,

      -- hooks, layouts
        layoutHook         = myLayout,
        manageHook         = myManageHook,
        handleEventHook    = myEventHook,
        logHook            = myLogHook,
        startupHook        = myStartupHook
    }

This config map is very powerful because you can add custom functions in it for handing some of the basic functionality of XMonad. For example, you can add your custom keymaps, logs, startup applications, mouse bindings, terminal etc. You can even add your custom layout in XMonad, which by default features with the master and stack layout variants. The myLayout is a layout map we have defined earlier in the file:



myLayout = tiled ||| Mirror tiled ||| Full
  where
    -- default tiling algorithm partitions the screen into two panes
    tiled   = Tall nmaster delta ratio

    -- The default number of windows in the master pane
    nmaster = 1

    -- Default proportion of screen occupied by master pane
    ratio   = 1/2

    -- Percent of screen to increment by when resizing panes
    delta   = 3/100

You can create custom modes of your own. Want a layout where 3/4th screen is horizontal and the rest is verticaly split? You can do that easily by following the xmonad documentation. With the help of distrotube, which I have linked in the description, I have some awesome layouts in my copy of the configuration file. Here are some of my favourites:

Tall Layout
This is the traditional master and stack layout that is very popular in all window managers. The new window comes on the left and all older windows are stacked onto the right hand side of the screen.

Grid Layout
Each and every window is given the same amount of space on the screen. This results in a grid formation of spawnables.

One Big Layout
This is a custom layout where 4 windows are allowed in tiling mode. After the 4th window, all subsequent windows keep stacking up on the last window. It gives more focus to the top left corner of the screen. It is perfect for a Dev + Ops operation where you might need 2 additional smaller windows for monitoring logs while you develop and deploy using the other two.

Space Layout
This layout is exactly lke the One Big layout, but it adds additonal spaces between windows for a more aesthetically pleasing look. Perfect for r/unixporn.

XMobar, the hackable status bar

Being suckless also means pluggability. Although XMonad does not impose any restrictions on using any status bars like dzen2, polybar or conky, but if you are going through the pain of learning and installng a WM that uses haskell, might as well use a status bar that goes along with it. XMobar is exactly what you want:



sudo pacman -S xmobar

You essentially need to write an xmobar script which you can then call from your xmonad.hs like the following:



import XMonad.Hooks.DynamicLog (dynamicLogWithPP, defaultPP, wrap, pad, xmobarPP, xmobarColor, shorten, PP(..))

-- the following line can be used to include xmobar in xmonad
xmproc0 <- spawnPipe "xmobar -x 0 ~/.config/xmobar/xmobarrc0"

The language is very straightforward but might feel intimidating at first. For example, here are the contents of my xmobarrc.

Notice that you can even define custom fonts and colours for each and every section of your status bar. I have it configured so that it shows me my CPU, memory and hard disk usage, along with my upload and download speeds, battery, date-time and my workspaces.

Some cool things you can do with XMonad

Here is a list of what xmonad can do (at least what all I have discovered so far).

Custom Layout Definition. You can decide how windows are drawn on the screen and come up with your own layouts, like this hilarious space layout:

Open Applications Grid. You can switch between all the applications you have open no matter which workspace they are on, using a grid that is spawned on screen:

Application Spawn Grid. You can define a grid to spawn that can be used to open any applications that you want, using the vim-key selection:

Promote Master. In a master and stack layout, you can promote a window to be your master. You can also demote the same. It is ideal when you want to shift focus without swapping the windows entirely.
Move a window to every workspace. You can copy a particular window to each and every workspace. The window will still remain in the first one but its copies will be made across every workspace. It is ideal if you are screen recording and want your front camera window to be on every workspace. You can also kill all other copies except the first one.
Custom window rules. Want your Gimp to always spawn in floating mode? Or your browser to always be on the third workspace. You can do that using managed hooks.
Different Prompts. You don't need to use dmenu as a run prompt. XMonad has a built in run prompt. In fact it has many other prompts, namely manpage prompt, ssh prompt among others. You can even create your own custom prompt for one liner command line outputs.
Key Sub-Maps. Running out of keybindings? You can have custom key maps. For example, for opening custom prompts, you can assign Mod + p to prompts and subsequently press the m button for the manpage prompt or r for the run prompt. So the whole command will end up being Mod + p + r for the run prompt and Mod + p + m for the manpage prompt.

At what cost?

Time! Time is the only thing you need to understand this beast and extend it to your liking. Although you can copy someone else's config, and there is nothing wrong with that, in fact it is a great way to start with XMonad, but learning the basics and being able to create your own config from scratch is an experience altogether. You don't need to be a haskell god for using it, but any functionality you want can be looked up in the awesome haskell wiki called hackage. It has syntactical queues and useful examples to build a config of your dreams.

Verdict

While XMonad is a very difficult window manager to configure in the beginning, especially if you are doing it from scratch, it is one of the most hackable, fast and reliable window managers that I have ever used. This WM is very old but there is a reason it is so popular even now. Some might argue that it is more suckless than dwm itself, and I agree, but it is certainly harder to setup than dwm due to the fact that you might end up writing (or copy pasting) a lot of code in a language you are likely not familiar with.

With that being said, I think I will use xmonad for another month or so before I make the next window manager hop!

Judgement Rubric	Rating
Simplicity of use	❤️ ❤️ ❤️ ❤️
Simplicity of Configuration	❤️
Learning curve (lesser is better)	❤️ ❤️ ❤️ ❤️
Productivity	❤️ ❤️ ❤️ ❤️ ❤️
Fun	❤️ ❤️ ❤️ ❤️ ❤️

References

Editor Almighty

Angad Sharma — Fri, 12 Jun 2020 12:06:35 +0000

How my search for the perfect text editor took me to SpaceVim

What compels people to migrate from their comfort zone? Is it boredom, monotony, or the bland impracticality of their ever so inertial state. I call it an itch, just waiting to be scratched.

This ever so inexplicable itch is what became the driving force behind my rather opinionated journey across editors.

One thing to clear right off the bat is that this blog, in no way, declares the superiority of one editor over the other, it merely explains which editor boosted my productivity. Feel free to form your own opinion after reading this post. Without further ado, let us get started.

Photo by Serghei Trofimov on Unsplash

What I started off with

I started my development journey, like most people do, with a minimal and easy to use a text editor called Atom. I soon learnt that VSCode (Visual Studio Code) was all of the buzzes, and I caught that fad pretty early on. Subsequently, I was amazed at the wide array of extensions that VSCode had to offer. From VCS to advanced debugging tools, and more.

Why I decided to drop VSCode

I had to depend on the mouse for navigation to an extent, even with vim bindings.
There was no real feeling of personal satisfaction when everything was handed over in a plate (personal choice).
I wanted something fast(er) and cheaper on my memory.
I did a lot of development on remote servers, which didn’t have VSCode at that time (now we have VSCodium, which I still don’t prefer).

Journey to the centre of vim

During the same time, I got interested in DevOps, and so felt a natural pull towards terminal-based editors. Emacs felt too intimidating, so the natural course took me to vim.

I was amazed at the world of opportunities that vim created for me, from granular customization to fast versatility, I couldn’t get enough of setting up my own .vimrc. Now at the same time, I had my semester finals (which obviously didn't go too well).

As my exams ended (along with a part of me), I figured out my perfect build. It included some popular plugins like:

And the following terminal tools (yes, I shifted to zsh):

So my environment started looking visually verbose, which is just the way I prefer:

Terminator split panes with CLI tools

Scaling the learning curve

I had the perfect setup I wanted, especially for development and operations. It was fast, highly customizable, and intuitive. But there was still something missing. I still hadn’t memorized the vim shortcuts and had a lot of trouble staying away from the mouse while working. Trouble in paradise!

Photo by Sebastian Herrmann on Unsplash

During this time, I would occasionally switch between VSCode and vim in order to boost productivity, although it was doing more harm than good. I followed the following guidelines which helped me be 2X more productive in vim that I ever was in VSCode:

Restrict yourself : Unplug your mouse, close all other editors, and no matter how slow you type, keep grinding. I was a back-end intern at Atlan during this time and I didn’t even install any other editor on my work computer other than vim itself. The first week was tough, but I soon got the hang of it and subsequently became quite productive.
Understand rather than memorize : In vim, all of the key bindings have a reason to be there. Understand the meaning of the commands that you are typing in. Vim will soon sound like a poem to you. For example: w means word in vim and c means change. Doing a c + i + w over a word in vim essentially means change in word.
Do what works for you : Do you want to change the key bindings? Sure, go ahead! Want to change the fonts, tab/spaces? Knock yourself out! Want to change how tiling works in vim? The world is your oyster! In the end, it is about productivity above all else. Never be afraid to seek help from others. Vim has a great community and you can learn a lot by simply watching the vim conference screen-casts on YouTube.

Shortcomings of vim

Fast forward a few months and I was using vim bindings everywhere, even in my browsers! Vim showed me how typing can actually be poetic, even though you might be writing something as mundane as skeletal HTML. It had some shortcomings though:

Built Synchronous: Vim (before 8.0) was built to be synchronous, which started causing a lot of problems after adding a plethora of plugins. Loading times would take seconds, even with vim v8+(might not sound like it, but actually that is very slow for an editor)!
Lack of out-of-the-box plugins: There are some plugins that you got to have. For instance, YouCompleteMe is a plugin for code auto-completion and nerdtree is a plugin for viewing a file directory structure in vim. These are some of the extensions that should come in-built, due to the nature of their utility.
Requirement of explicit plugin managers: Plugin managers like pathogen, vundle or plug are required for installing and configuring extensions in vim. This causes a lot of hassle when you are using one particular plugin but an extension only supports the other.

SpaceVim to the rescue!

SpaceVim is a community-driven vim distribution. What this essentially means is that it is a set of vim configurations which add an abstraction over vim. The following are the salient features of SpaceVim which attracted me:

Super easy installation: Installing SpaceVim involves running just a single command on your terminal. You get instant gratification. Fair warning though, your existing vim configurations are going to be overwritten.
Asynchronous plugin manager: SpaceVim has a neovim inspired plugin system. It only loads the most essential plugins during the initial runtime cycle and defers the loading of the rest of the plugins. This lazy-loading of plugins creates a seamless typing experience for the user.

Layer based plugin system: SpaceVim installs plugins in layers. Each layer defines a set of plugins, grouped together to offer maximum functionality to the user, per download. Each and every plugin inside a particular layer, as well as in different layers, is downloaded asynchronously by the SpaceVim PlugManager.
A plethora of off-the-shelf features: SpaceVim comes loaded with a ton of features right of the box. From asynchronous grep on the fly, to fancy TODO managers. It brings a lot to the table in order to add value to the users’ typing experience.

Spacebar oriented: As the name ever so discretely suggests, SpaceVim is big on using spaces as a macro for invoking a lot of in-built functionality. This is a fresh change from vim, where the spacebar has virtually no functionality in normal mode, even though it is the easiest key to hit on the keyboard, due to both its size and its stature. And no, SpaceVim has nothing to do with outer space.
Over 78 language packs supported: Language packs are layers (set of plugins) which offer a lot of functionality for development in a particular language. For example, a lang#go layer will offer functionality for go development.

All of these can be installed by simple adding the following lines to your ~/.SpaceVim.d/init.toml

[[layers]]
name = "lang#go"

Conclusion

SpaceVim is not the endgame. Nothing is. The aim is to keep on finding, and mastering whatever boosts productivity.

Efficiency is doing something which has already been done before, better.

YOU are the most important resource when it comes to productivity. So choose the editor which boosts YOUR productivity. After all, no one knows better than you :)

References

This Article was originally published on Medium under Developer Student Clubs VIT, Powered By Google Developers. Follow us on Medium.

Vim to the rescue: PDF Preview

Angad Sharma — Mon, 01 Jun 2020 12:07:33 +0000

Introduction

Some time ago, I was writing my resume. People suggested writing it in LaTeX. So I started reading up on it. Then I stumbled upon a tool called groff and found it much easier, faster and less bloat than LaTeX.

Both of these tools are used to write documents that can be converted into PDFs. I wanted a solution in vim so that I could live preview these PDFs as I was writing them. So I decided to make a vim plugin that does so:

L04DB4L4NC3R / texgroff.vim

A plugin to open groff output pdf in preview

texgroff.vim

A plugin to open groff/latex/markdown live pdf preview

Requirements

groff with the groff_ms macro
pandoc for markdown and latex
zathura pdf viewer

Installation

Without vim package management system: Copy the main.vim file to your .vim/autoload
Pathogen:

git clone https://github.com/L04DB4L4NC3R/texgroff.vim ~/.vim/bundle/texgroff.vim

Keybindings

Leader	Key	Action
/	p	Open live PDF Preview
/	q	Compile groff(.ms)/latex(.tex)/markdown(.md)

Demonstration

View the demo on Youtube

Made with ❤️ by Angad Sharma

View on GitHub

It supports LaTeX, groff, as well as markdown.

What we are going to use

Zathura: It is a very minimalist PDF reader for vim users.
Groff: The GNU document parser. It is installed by default on most linux systems
Pandoc: It is the general purpose document conversion tool. See my blog on pandoc:

Presentable DEV posts with Pandoc

Angad Sharma ・ Apr 21 '20

#tutorial #showdev #todayilearned #todayisearched

All of these tools are already available in most official linux repositories and can be downloaded using your vanilla packet manager:



sudo apt install groff pandoc zathura

On Arch based distros, zathura-pdf-poppler needs to be downloaded in addition.

What we want

We want that the \ + q keybinding to compile the document we are working on into a PDF and the \ + p keybinding to preview the PDF in zathura after compiling it.



# Compiling Markdown to PDF:
pandoc curr.md -s -o /tmp/op.pdf

# Compiling LaTeX to PDF: 
pandoc -f latex -t latex curr.tex -o /tmp/op.pdf

# Compiling Groff (ms macro) to PDF:
groff -ms curr.ms -T pdf > /tmp/op.pdf

Getting to the vim script

The following code divides the process into 2 functions, namely Compile and Preview. The former checks our current file type and applies the appropriate compilation command to it. The latter opens up the output PDF in zathura. Add the following code in your ~/.vimrc:



let mapleader="\\"

" Call compile
" Open the PDF from /tmp/
function! Preview()
        :call Compile()<CR><CR>
        execute "! zathura /tmp/op.pdf &"
endfunction

" [1] Get the extension of the file
" [2] Apply appropriate compilation command
" [3] Save PDF as /tmp/op.pdf
function! Compile()
        let extension = expand('%:e')
        if extension == "ms"
                execute "! groff -ms % -T pdf > /tmp/op.pdf"
        elseif extension == "tex"
                execute "! pandoc -f latex -t latex % -o /tmp/op.pdf"
        elseif extension == "md"
                execute "! pandoc % -s -o /tmp/op.pdf"
        endif
endfunction

" map \ + p to preview
noremap <leader>p :call Preview()<CR><CR><CR>

" map \ + q to compile
noremap <leader>q :call Compile()<CR><CR>

When we press preview, our zathura instance opens up. Now the best thing about zathura is that it watches the opened file. So after you press preview for the very first time, you don't have to press it again. Simply compile to view the changes in the PDF. Here is what our extension looks like:

Vim to the rescue: Subduing the Shell

Angad Sharma — Tue, 26 May 2020 15:21:08 +0000

Introduction

How many times have you ran a command on your terminal and copy pasted its output to vim? Maybe you want to include some terminal output data, or maybe you want to create an issue on github by editing it in vim first.

In this blog we will be learning how to get the output of shell commands in your current vim buffer.

For reference, here is what we are going to achieve:

Getting the output of a script

You can take the output of any shell script and paste it after your cursor position by using the following command:

" . means current line
:.! <shell_command>

Additionally you can take your cursor to the position where the command output ends:

:r! <shell_command>

The best part about this is that you can use the text inside your vim buffer and pass it through the command line. For example if your current buffer contains something like this:

My cow says:

cowsay "Hello, World"

You can go over to the cowsay command and press the following keys to get the output right in your buffer:

" passes the current line through a shell
:.!$SHELL

You will get an output like this:

Not only this, you can take the text from any line and paste its output:

" takes the text in the 5th line as input
:5!$SHELL

Mapping the madness

I have mapped <Shift> + q to the .!$SHELL command. So pressing the keybinding instantaneously returns the output of the current line when ran through a shell.

noremap Q !!$SHELL<CR>

Monsterwm: 700 lines of pure beast

Angad Sharma — Thu, 21 May 2020 04:07:59 +0000

Monsterwm is a dynamic tiling window manager forked from dminimalwm, which was inspired by dwm. It has a lot of similarities with dwm and feels like home for people who have used suckless tools. Read my blog on dwm to get additional insight on this particular WM, but you don't need to do so to understand this window manager:

Dwm: The Suckless Window Manager

Angad Sharma ・ Apr 7 '20

#linux #opensource #ubuntu

Monsterwm aims to keep its codebase under 700 SLOC (source lines of code), as compared to dwm's 2000 SLOC limit. It does so by removing the status bar altogether. It believes that the status bar should not be the responsibility of a window manager.

Features
Setting up
Layouts
Configuration and patching
- The monsterwm source
- Changing keybindings
- Installing patches
- Setting up a status bar
Verdict
References

Features

Monsterwm is only a single binary, and its source code is intended to never exceed 700 SLOC.
Customization is done by editing the source code, which is very easy to understand.
It is extremely fast and packed with bare essentials. Additional layouts and functionalities can be added by patching, as is the suckless anti-bloat philosophy.
It does not ship with a status bar, but outputs information about the desktop which external panels (like conky, dzen etc) can use.

Setting Up

Execute the following commands to get started with monsterwm:

# clone the source repository
git clone https://github.com/c00kiemon5ter/monsterwm.git

# enter the directory
cd monsterwm

# run a clean installation
make clean install

Now simply add the following line in your ~/.xinitrc:

exec monsterwm

Now that you are all set, logout and log back in again. Once you do, you will see a blank screen.

Layouts

To spin up a terminal in monsterwm, just press the following: <Alt> + <shift> + <Enter>. If it doesn't work then checkout the changing keybindings section where I talk about remapping the key bindings and customizing which terminal should open up.

If you keep on opening terminals up then you will notice that the focus shifts to the newest terminal in the stack. A stack is a LIFO (last in first out) data structure. Monsterwm makes sure that the most attention goes to the recently opened program.

Monsterwm has the following layouts by default:

Common tiling mode: It is like the master and stack layout in dwm. The master comes on the left hand side. The focus is shifted to the newest spawn by default:

Bottom stack (bstack) tiling mode: Here, the newly spawned windows are stacked in the bottom:

Grid tiling mode: In grid mode, each window is given an equal amount of space and thus windows tile themselves like a grid:

Floating mode: In addition to tiling modes, windows can also be made to float over each other:

In addition to these modes, monsterwm also has a monocle or fullscreen mode. Additional modes (like fibionacci mode) can be added by patching, which we will se in the upcoming section.

Configuration and Patching

Configuring and patching monsterwm might be difficult for beginners. The source code configuration file is similar to dwm, so if you have used dwm, then monsterwm will be even easier.

The Monsterwm Source

Using your terminal, go to whichever folder you have cloned monsterwm in and type ls.

You may notice the configuration files in the directory.

config.h and config.def.h are the files that you will need to edit when you are configuring monsterwm.

Open the Makefile and edit clean recipe to add the following line of code in it:

rm config.h

This will make sure that whenever you are configuring a patch, you won't have to make changes in both config.h as well as config.def.h.

Now whenever you make a change in the config.def.h, simply run make clean install for re-building monsterwm from scratch. Then logout and log back in again for the changes to take effect. Monsterwm requires its source to be rebuilt every time there is a configuration change, which is exactly like dwm.

Changing Keybindings

Open the config.def.h in vim.

The Key_key array stores all of the keybindings. The modifier key ( by default) is named MODKEY. Shift is called ShiftMask. All other keys are prefixed by XK_. For example, if I am talking about the "i" key then I will write XK_i. If I am talking about then I will write XK_Return.

Now let us look at line 3, where the keybinding for opening up a terminal is defined. By default, this line is the following:

/* modifier            key       function        argument */
MODKEY|ShiftMask     XK_Return    spawn         {.v = termcmd}

It means that for spawning a terminal, you would have to hit <Alt> + <Shift> + <Enter>. You can already see in the screenshot above, that I have removed ShiftMask from this line. So for opening up the terminal I simply do <Alt> + <Enter>.

In this way, by changing the modifier or keys, you can define custom keybindings. You can even add lines here to define some of your own keybindings.

Now for the changes to take effect, simply compile the code again by running the following commands, log back in, and you are good to go:

make clean install

Installing patches

Some extensions to monsterwm are supported in the form of patches. Easiest way to apply a patch, is to git merge that branch. Here is a list of patches for monsterwm:

centerwindow : center new floating windows on the screen and center any window with a shortcut
fibonacci : adds fibonacci layout mode
initlayouts : define initial layouts for every desktop
monocleborders : adds borders to the monocle layout
nmaster : adds nmaster layout - multiple master windows for BSTACK and TILE layouts
rectangle : draws only a rectangle when moving/resizing windows to keep resources low (ie through an ssh forwarded session)
showhide : adds a function to show and hide all windows on all desktops
uselessgaps : adds gaps around every window on screen
warpcursor : cursors follows and is placed in the center of the current window
windowtitles : along with the rest desktop info, output the title of the current window

Let us install the fibonacci layout. For doing so, simply run the following commands in the source repository:

git merge origin/fibonacci
make clean install

After doing so, simply restart the window manager. Look in the config.def.h for the changes added (as well as the keybinding). Activating this patch will make your windows spawn like a spiral:

Setting up a status bar

Monsterwm does not support a status bar but allocates (by default) 18 pixel on the top part of the screen for a custom status bar. This allocation is of course customizable. Whenever we run monsterwm, it outputs the workspace information as a stream. This stream can then be piped and the output can be shown to a terminal. In the following case, I am outputting the monsterwm to a temporary file. Let us name this file startup.monsterwm

#!/bin/bash

monsterwm > /tmp/monsterwm.fifo

In my .xinitrc, I will add the following, instead of executing monsterwm directly:

exec startup.monsterwm

Now when my monsterwm is up and running, let us switch workspaces and see the terminal output by catting the file in which we are piping our output:

You can see that it outputs real time information such as which monitor is being used, as well as how many windows are open per desktop. We can use this output as an input to dzen to show a status bar like this:

Check out these gists for some ready made scripts for setting up status bars. Copy any script you like to a file, and exec that in your .xinitrc.

Verdict

For those of you who thought dwm was minimal, monsterwm goes one step ahead to ensure a separation of concern between a window manager and its status bar, stripping down a lot of code in the process. It is one of the most lightweight and fast window managers.

Monsterwm is difficult to configure than your traditional window manager (like awesome or i3). But its patches are stable and do not break with monsterwm versions (ahem ahem dwm). Documentation can come from multiple sources since its configuration is almost exactly like dwm.

Judgement Rubric	Rating
Simplicity of use	❤️ ❤️ ❤️ ❤️
Simplicity of Configuration	❤️ ❤️
Learning curve (lesser is better)	❤️ ❤️ ❤️ ❤️
Productivity	❤️ ❤️ ❤️ ❤️
Fun	❤️ ❤️ ❤️ ❤️ ❤️

References

What is the stupidest thing you have done at work?

Angad Sharma — Sun, 17 May 2020 17:12:52 +0000

This one time, I pushed some code to my branch and later on I saw that I had pushed the .env branch with a lot of secrets on the repo. I panicked. Even more so by seeing that the .env file was in all of my commits for that branch. I started looking for git commands that can be used to completely erase the existence of a file from the whole commit history and found a very obsure and VERY long command which for the life of me I can't find again.

Anyways, after a copy paste later, I had created a duplicate commit for each of my commit in the tree. Each pair consisted of one commit that had the .env file and one that didn't. My 50 commits became 100 commits and my project lead was of course furious and curious as to why I had pushed 50 more commits at once. I explained the whole situation to him.

Turns out they themselves had pushed the .env file on the master branch and all of the credentials inside it were of the development cluster. When I asked why it is so, they said that the repository is private anyway 🤷.

Feel free to share your stupid work story :)

Medium Blogs on DEV

Angad Sharma — Thu, 14 May 2020 11:17:11 +0000

I was doing some digging and checking out varius RSS feeds and figured out that you can actually link your Medium articles to DEV! So whenever you publish something on Medium, the article is automatically added to your DEV dashboard as a draft. This can be done with other RSS providers also (not just medium). To enable this feature simply go to your DEV settings, to this page:

Expect to see some of my popular medium articles on DEV in the coming few days :)