Forem: pspiagicw

My Journey from Vim to Emacs

pspiagicw — Fri, 04 Dec 2020 04:59:48 +0000

A Kingdom of Vim:Vimdom

I was a astute vim user for the last 5 years. I read hundreds of books on Vim and Neovim . Saw every last screencast of Drew Neil and worshipped Tim Pope and Junnegun . I followed closely with the neovim repository . Experimented with making my perfect neovim config . Tried Spacevim and multiple distributions of vim just for getting the feel of a complete config of vim . Spent atleast 5 hours per week on making Vim more efficient .

Living in the Vimdom.

The biggest thing that I hated was that I could not live in vim. I tried living in the terminal so that I could run my life from a terminal. Tried running st(terminal) as a the only root window in Xorg so that I could run every software inside Vim with the terminal emulator integrated into it. You could say I was mostly successfully . But there some thing's that always bugged me . Vim was implemented as a text editor it only succeeds as a text editor. The way everything is implemented it just makes sense for efficiency and speed.

My Views

After much thought I saw the idea behind Vim . It was not a text editor . It was a editing racer.It was build so that you just race through whatever you were editing.It was not build as a environment.It was not build as a way of life.It was build to fit in your life . Not become your life.

A Forgotten Ruin.

I thought about using emacs as a text editor for a while and tried and failed to adopt it as a text editor multiple times . My pinky finger pained for multiple days after using emacs for a week.I could not imagine using it for my life. But I knew about Doom Emacs from Distrotube's video and decided to try it as a text editor.I failed again because of my habit to open everything in neovim by typing nvim in the terminal.I decided to move to vim again but I did not delete the Doom Emacs configuration.I just kept it in my home folder.

A lost treasure.

Distrotube posted a video about how exwm could make Emacs your window manager.I was quite intrigued by that and decided to try it. So I installed Emacs Again but due to my Doom Emacs config already there I was happy that I did not have to install anything.I just moved to ExWM.And after a week of using it.I cannot tell how happy I am.The joy of using absolutely one software for everything is phenomenal.I don't think I would switch atleast for a few months.It has been a month since I have typed 'nvim' in a terminal.I have uninstalled everything except the base necessary and Emacs.I am writing this post in emacs.

My Summary.

If you are not able to adapt to the Emacs world . It would be good to switch to EXWM as this forces you to literally live in emacs.I would tell that Emacs as a editor is not efficient and definately not speedy.But Hell Yeah!It is convenient for everything I do.

Drop you comments below on your editor journey. And let us discuss about it.

WTF Python 2:PYCAT

pspiagicw — Fri, 20 Nov 2020 04:47:18 +0000

Introduction

Welcome to the second post of WTF Python. Last time we made a pure python clone of 'ls' tool used in GNU/Linux distributions.Last articles focus was using git branches to add new features in our application.
Today we will make a pure python clone of tool 'cat' which stands for concatenate which is used to print contents of a file or concatenate contents of multiple files.

Today's focus

Today we will discuss a lot of Test Driven Development.We will start using unittest and even use tool called coverage.py to find the coverage of our tests.

Let's start

If you have not already create a directory called pycat(Our project name) and create a git repository inside it.Then create directory inside the original pycat directory called pycat and make it a module by creating a '__init__.py' file inside it.Then make '__main__.py' so that we can use our project as a python module.Ex

mkdir pycat
cd pycat
mkdir pycat
touch pycat/__init__.py
$EDITOR pycat/__main__.py
python -m pycat

Approach and Milestones

This project's very easy. So easy that we need no more than one file.I will not be revealing any code but if you are stuck more than a hour then refer to my code.
There are some milestones that we will follow this breaks the project into small objectives .So that you can focus on one functionality only.

First one is that we should accept a list of files as arguments.We do not want to check if it's a valid file or not.Just print the list of files passed as arguments.If you don't already know ,you should look at argparse module.It's the best way to implement this feature.If you are stuck look at this or this.Be sure to not copy the code in the article and understand and implement it yourself.

python -m pycat file1 file2 file3
# Output>> ['file1','file2','file3']

The next objective would be that to read the contents of the given files and print it's content.If you are stuck at this part you should look at this article.But again be sure to not copy the code in the article and simply understand the usage and implement it yourself.

TDD

Now that we have somewhat working project we should write tests for it.Though according to TDD(Test Driven Development) we should write test even before writing the starter code.But I am letting this part go as this was my first time using TDD Development.
We will be using unittest module in the python standard library to write tests.If you want to use pytest or nose2 as a testing framework.You can do that after implementing unittest tests.

Testing

For testing create a directory in our project root called tests.

mkdir tests

then create a file that has 'test_' as the first part of the file.As unittest requires it by default.You can configure unittest for other patterns but it depends on your coding style.
Refer to unittest's documentation on doc.python.org or refer to a more friendly documentation.But refer to official documentation for the true reference.
If you are confused then look at my code.
After you have implemented basic tests for argument testing and whether it actually print's contents of a file.You can move to the next section

Moving Forward

Before implementing the next feature.We would write it's test following TDD.The next feature will be numbering the lines.Write a test for it and run the test suite.It should fail.

New feature.

Now that the tests fail we should write the feature out.And yes we will be doing in a git branch format.If you are uncomfortable with it.Just refer to my previous post.
It should be pretty easy and once finished run the test suite once it run's successfully then. We are done.Merge the feature branch with the master branch.

Extensions.

Referring to manpage of cat.We do not have more features to implement that are cool.If you think about it please comment below.If you think you can do it, implement it and share it in the comments below.Your comments are the best thing about this series.

Coverage.py

If are up to this task.Let's begin by explaining what is coverage.py .It's a tool that find's out how much of your code is tested.To use it install it will pip

pip install coverage

You can refer it's official documentation and without putting much effort you should know the coverage percentage of you project.See if you can make it into 100%.Share your percentage in the comments below.

GoodBye

GoodBye fellas and meet in the next post.If are looking for something more like this. Then look at Robert Heaton's blog.His blog inspired me to write this series.Implement his project #7 as it would be used in the next post.

WTF Python 1:PYLS

pspiagicw — Thu, 12 Nov 2020 05:42:19 +0000

Welcome to my first post on WTF Python.
Today we will make a simple project.
We will make a ls clone in python.
If you don't know what is ls.
Just google it.If you are on windows
the similar command is dir.
We are naming it pyls

Approach

I will not give the code in anyway in this article.
If you get stuck for an hour or longer.
Then just skim through my code.
My Code:
https://github.com/pspiagicw/pyls

Introduction

This project is aimed at python beginners but any programming language can be used.
Just a little work is required to find alternative to the modules and packages.

Prerequisite

You should know basic python and comfortable using modules.
We will also use basic git in this project.
You should also know how to create a python project as a directory layout.
You if you don't know any of them.Just search for them right here in DEVTO.
My recommendation is Dead Simple Python Lesson 1 which is how to layout your project.

Getting Started

Start by making a directory for you project.Then create a git repository inside it.

git init

This is optional
but for a more professional feel.We would be adding features in form of git branches and merging them.
If you are not comfortable with it,No Problem you can still follow just skip all the git stuff.

Main Course

After you make a directory structure you create a main python file.
For the first step we will just print the contents of current directory.
For a hint you can use os.listdir for it.If you want more documentation google it.
Below is some psuedocode

function generate_output(directory:default:'.'):
    os.listdir directory
for i in generate_output():
    print i

If you can print the contents of current directory then let's make a git commit out of it.

git add -A
git commit -m "Initial commit"

Make a git commit and give a message like 'initial-commit'.
Moving forward let's add a feature in our program.

Create a git branch called hidden-files.If you didn't understand from the name we are adding support for hidden files.

git branch hidden-files
git checkout hidden-files

For now just make it ignore hidden files.
If you don't know what are hidden files.They are file which have name starting with a '.'.

If it works then merge the branch with the master branch.Don't forget to commit changes in hidden-files directory

git checkout master
git merge hidden-files

Let's add support for commandline arguments.This is done by the argparse module in python.

import argparse
parser = argparse.ArgumentParser(description='Pure python clone of ls command')
parser.add_argument('directory',default='.',help='The directory to use',nargs='?',type=str)

Make separate file for parsing the arguments.For now we will only support directory name.
Again for the same create a separate branch or it.

I should explain this point.What I mean by directory name.With that I mean that when 'pyls' is run without any arguments.

pyls
# Output --> python go clojure
pyls python
# Output --> pyls qutebrowser machine-learning

Then it should print current directory's contents.But when given given a directory name which is in the current directory.
It should print that directory's contents.

If it works then again merge the branch with the master branch.
One thing I would like to touch is the use of docstrings in each and every function.
This is a very weird thing to do.But I am trying to write good code and thus I am following it too.

The next idea I think we should tacke is the '--all' argument which prints the hidden files too.
Again for this we should create a separate branch and thus merge after working.

The above point is quite easy.

But the next idea is not so easy.
We are going to build the '--long' argument which means we have to get stats of each and every file.
This stats include read/write/execute permissions and even last-modified-date.

Again use git branches.

This was a big one.For a hint you can work with os.path and os.stat along with stat module for getting information about the file)

pyls --long
# Output --> drwxrwxrwx 4KB 10:20 README.md

I think this is enough for using on a daily basis.

Extensions

If you are up to the task.You can write multiple extensions to pyls

Color support: You can have color support for pyls.
More Options: Just look at man ls and try to implement things that you think you can do.
Recursive: This is one which requires recursion which is a little higher concept for beginners.(Just Google It)

Think of more extensions and implement them.
Give your feedback and give your opinions on my writing.You feedback is appreciated.
Send me your code and we will discuss them.
Send me ideas for future posts share links to such posts on the internet.

Introducing WTF Python

pspiagicw — Tue, 10 Nov 2020 17:36:39 +0000

Hey there, if this post is in your feed then thanks to DEVTO's algorithm for putting this on your feed.This is my first post in DEVTO.I wanted to write my coding adventure.Anyway this is the first post(Was that a little rude?Sorry) to my series WTF Python(Is that title good?Idk).Yeah I know a bold step for writing a series for my first post.Then again I am crazy(Hell! yeah you are).If you don't want to read this please mention in the comments the reason.How stupid it might be.(Example --> It's shit)

This is supposed to be the series that give me and you as a reader projects that are fun to code but not always easy.
I want to use tools like mypy and pytest in this series as I have not used them anytime in my life!(Was that exclamation point necessary?).I am not a professional developer,I am just a self-taught programmer here to have some fun with programming.If you are a professional developer then please go easy on me.

This series may have so many mistakes and so less readers but I am writing this as a way to improve my coding skills without feeling alone in my journey.

I plan to write one project per week and write how to go about writing one yourself.I hope my writing will strike a chord with my readers.

If you don't like my style please recommend changes in the comment section.

I will try to write according to the styles used in Robert Heaton's blog , Jason's Dead Simple Python or the Head First Books and the Grokking Series by Manning Publications.(Oh!! I love those)
I am seriously posting this without making any changes to it.I wanted to write a fancy post with catchy introductions but my writing is not that good.(I will get good)

Please mention your criticism in the comments.