If you want to know how to Create a file in VIM's explorer, I have a TIL from some time ago.

Googled a bit today and found out about list in VIM. In which enables the strings to use in 'list' mode and for the :list command. So, instead of shows just an empty space, it will show a character instead (this is configurable, and below I show how to do it).

For you to configure this, you need to set listchars and add some parameters.

Parameters that I'm using:

So if we go inside vim and do the following:

:set listchars=eol:$,space:-,tab:>#,trail:~
:set list

A normal text like the first two paragraphs will be:

I-usually-use-VIM-to-code,-and-sometimes-I-have-problems-finding-indentation-or-some-random-spaces-in-the-end-of-a-line.$
$
Googled-a-bit-today-and-found-out-about-`list`-in-VIM.-In-which-enables-the-strings-to-use-in-'list'-mode-and-for-the-`:list`-command.-So,-instead-of-shows-just-an-empty-space,-it-will-show-a-character-instead-(this-is-configurable,-and-below-I-show-how-to-do-it)$
~~~~~~~~~~$
The-line-above-has-10-spaces$
The-line-below-has-two-tabs$
>######>######$

It might be a little bit too noisy, so I created an alias to enable and disable that on ~/.config/nvim/init.vim (I use neo vim).

You can find how to do that here: https://gist.github.com/airtonzanon/fae437d4b0808d5b9946a25945e9fc07#file-init-vim-L22

A simple explanation about Linux Screen:

Screen or GNU Screen is a terminal multiplexer. In other words, it means that you can start a screen session and then open any number of windows (virtual terminals) inside that session (this is a quote from Linuxize, in this link you can see how to install and so many other commands, tricks and so on, I'll only state here the commands that I use)

screen -ls - List all screens

screen -S name_of_the_screen - Create a new Screen with the given name

CTRL A + D - Detach from a screen

screen -r 123.name_of_the_screen - Reattach to the given screen (the screen needs to be detached)

screen -D 123.name_of_the_screen - Detach an attached screen

If you want to flash a recently edited or something that you changed recently on the configuration file, you might need to use the command line for that. There was when I questioned "How will I do it for the Elite-C?".

I use Arduino Pro Micro for almost all keyboards that I built, but because of micro usb not being the best when it comes to durability, I choose Elite-C to be the microcontroller for one of the keyboards that I created.

So here's how you flash it:

Arduino Pro Micro:

qmk flash -kb sofle -km default -bl avrdude

or stay in the root of qmk_firmware folder and run the command below

make sofle:default:avrdude

With that, the keymap will compile and it will ask flash the Arduino, if you connect reset to ground, it will accept the flash.

Elite-C:

qmk flash -kb sofle -km default -bl dfu

or stay in the root of qmk_firmware folder and run the command below

make sofle:default:dfu

With that, the bootloader used will be DFU instead of avrdudes (used for Arduino Pro Micro). You don't need to do anything in the board to flash it.

This is simple and easy, but I took a while to find this info, so here it is :D

For more info about QMK and flashing, go to their wiki page https://github.com/qmk/qmk_firmware/blob/master/docs/flashing.md

I tried to find a PHPStorm plugin for that, but couldn't, so I thought, macros in VIM is something that I've seen the power watching some twitch developers programming, but I never did it.

I got really happy with how easy it is to set up and run the macros, so here we go:

Press q this will start the macro recording

Give a name to it, for example m it only accepts one character

Make all the movements that you want to record and reproduce in the future.

In my example above, for typed properties in PHP from the PHP Docblock, I put the cursor in the beginning of the line of the one line docblock and wwwwvwhyjhhpkddjj0. This will pick the type from the docblock, add it after the property visibility but before the property and goes to the next line of docblock.

Press q again.

With that, you got yourself a recorded macro.

To run, type @m, if you want to do it multiple times (5 for example), type 5@m, this will run the macro 5 times.

Sometimes I get a little bit worried about typos / wrong spelling as I'm not a native English speaker sometimes I do some silly errors (also on grammar, but that's another post for here hehe)

Vim already have a spell checker that we can set the language like that:

set spelllang=en

And enable it with set spell, if we want to have this enabled every time that we open VIM, we need to add the "set spell" on our .vimrc or .config/nvim/init.vim for neo Vim

As now we have it enabled, we should be able to use it, so here are some commands that I've been using:

Adding spell check per file type

If you want to enable the spell checker automatically based on the type of the file you can add the code below on your .vimrc or .config/nvim/init.vim for neo Vim.

autocmd BufRead,BufNewFile *.md setlocal spell

This will enable the spell checker only for markdown files, so you won't get errors on some code stuff that it's not really wrong.

If you want to take a deeper look on the spell checker, take a look on the documentation here http://vimdoc.sourceforge.net/htmldoc/spell.html

Hope it helped someone, if you have suggestions or if I did something wrong here, just ping me on Twitter

But sometimes we feel that we should add something more to really explain what we're doing on that commit, as we need to keep 72 (50 preferable) characters on the title, it's not possible to leave that on the commit title, and sometimes we shouldn't, as it isn't on the context of the title.

So I go and open vim, even if It's "a simple commit", because I need to add more paragraphs to explain my changes.

The thing is, I was going around Twitter and I saw a tweet from @stefanjudis saying that we can use multiple "-m" when doing a git commit

So next time that you want to do a commit on the command line, and not open a editor, you can do something like:

$ git commit -m "This is the title" -m "This is the second paragraph"

Another way, that I already knew but I keep forgetting it, is leaving the quote open:

$ git commit -m "This is a title
$ dquote>
$ dquote>This is the second paragraph
$ dquote>
$ dquote>This is the third paragraph"

Either way, thanks for @stefanjudis for raising up this, if you want to check this TIL post click here.

class NamedConstructor:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def create_person_from_dict(person_data: dict):
        return NamedConstructor(
            name = person_data['name'],
            age = person_data['age']
        )

test = NamedConstructor.create_person_from_dict({'name': 'Airton', 'age': 24})

print(test.name)
## output: Airton

As I'm a noob Pythonist I accepted this solution, because this is pretty much what we do in PHP, as we can't create multiple constructors or multiple methods with same name and different signatures.

Something that I didn't know in the time is that Python has a decorator called @classmethod, this, instead of accepting the argument self - that points to the object instance - on the method, accepts cls that points to the class.

Knowing that, we can rewrite this class as:

class NamedConstructor:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    @classmethod
    def create_person_from_dict(cls, person_data: dict):
        return cls(
            name = person_data['name'],
            age = person_data['age']
        )

test = NamedConstructor.create_person_from_dict({'name': 'Airton', 'age': 24})

print(test.name)
## output: Airton

There are some other usages for the @classmethod, but used this decorator for it.

If you know some better way for do that or wants to talk more about this, send me a DM on twitter

As I already knew, creating a file with vim is kinda easy, like: vim file.txt

But something that I didn't know it's that on vim we can create multiple files at once, so we can do it:

vim file1.txt file2.txt file3.txt

Inside vim we only need to press esc and write: :next, doing that, you can take a look on the bottom that the name of the file will change, so for each :next that you do, it will go to the next file.

One thing that I was struggling was creating new files there, because I always needed to put VIM in background, then create the file, and then editing it on VIM. That was making me madness.

So I started searching and some TIL articles or even the documentation says, use % when on Netrw and it'll ask the filename. Noob as I'm I was trying to do :%.

But it's just pressing the character %, so: shift + 5 (at least in my keyboard hehe).

I hope it also helps some people that doesn't pay attention as myself.