Forem: lucasprag

Underrated VSCode feature: Native Tabs

lucasprag — Thu, 18 Apr 2024 21:48:56 +0000

At work, I often have to make changes to many repository-based projects at the same time. They can be multiple back-end projects, multiple front-end projects, documentation, infra as code, etc.

With so many projects, I used to often struggle with many VSCode windows.

I tried working with VSCode Workspaces, but they didn’t really click for me.

However, there is a feature called Native Tabs that allows me to group all my VSCode windows together and move between them easily. Notice how each project is in a different tab:

How to setup Native Tabs

Look for Native Tabs on Settings or add "window.nativeTabs": true to your settings.json.

Restart VSCode.

How to move between Native Tabs

Add shortcuts to workbench.action.showPreviousWindowTab and workbench.action.showNextWindowTab to move between them without having to navigate throughout the screen with the mouse cursor.



[
  {
    "key": "ctrl+shift+h",
    "command": "workbench.action.showPreviousWindowTab",
    "when": "!terminalFocus"
  },
  {
    "key": "ctrl+shift+l",
    "command": "workbench.action.showNextWindowTab",
    "when": "!terminalFocus"
  }
]

Also add a shortcut for creating a new Native Tab.



[
  {
    "key": "ctrl+shift+t",
    "command": "workbench.action.newWindowTab"
  }
]

Done. Enjoy your Native Tabs.

A year of ruby meetups in Kitchener

lucasprag — Mon, 23 Dec 2019 04:43:53 +0000

I've been living in Kitchener for over an year and in the first time I attended to the ruby workshop I created my first PR to Rails 🎉

It was quite simple of course, but in that workshop I've learned that it's not that hard to do open source. Eventually I found a small problem in Rails and I created another PR.

Then I started doing more open source in projects that I was using at work like viscacha, sprockets, lightline.vim, tabulous PR #1 and #2, vscode-run-rspec-file and hopefully this list is only going to grow overtime.

In other ruby workshops, it was really nice to be able to help other people's projects.

The meetup when Jay El-Kaake gave a talk about how to make Rails faster than the speed of light was really interesting, I've learned a few things on how to do speed tests, how to reduce latency when connecting to your app/postsgresql/redis and much more!

In the workshop focused on Hacktoberfest I helped a developer to participate and I decided to participate myself which was great. 🌟

I missed the talk about Rails and Docker, that was a shame, I wish I could have made for that one.

In the Career, Business and Software Development talk by Martin Basiri I've learned one thing or two about the business side of tech companies. He also talked about his first endeavor which was earphones that made it easier to untangle their cable - 4 seconds less than others - and how it failed when wireless earphones got popular.

It was quite inspiring to see so many students and developers asking interesting questions in the Building a Career in Technology talk by Rob Sciuk and Ralph Janke.

Not all meetups are very productive, but the last one of 2019 was really special and this is why:

I talked to someone who was new to Ruby, did the classic blog tutorial
I did open source by working on an issue to automate the deployment of the KWRuby's website.
we talked about Elixir, pattern matching and Declan gave us a lesson -- almost a talk by itself -- on aspects of the Erlang's OTP
we talked about new things comming up to Ruby like pattern matching on ruby 2.7
and there were lots of Pizza 🍕

Definitely one of the best ruby workshops. So many things happened in just one meetup.

Big thanks to Andrew, the person behind this group and all the people who have helped him.

If you are in Kitchener/Waterloo I strongly recommend you to attend a few times to the KWRuby meetup. If not in the area, try to see if there are groups in your city. It's totally worthy.

2020 is going to be great! 💎

How to add columns with a default value to large tables

lucasprag — Sun, 17 Nov 2019 01:13:08 +0000

If you worked with a large database you know that you can't just run an alter table to add a column with a default value, maybe you tried it and it failed -- like me awhile ago 🤕 -- but what if you really need to do that? That's what I'm about to tell you in these four simple steps:

1. Add the column with no default

class AddCurrencyToAccounts < ActiveRecord::Migration[5.2]
  def change
    add_column :accounts, :currency, :string
  end
end

This is going to run this SQL:

ALTER TABLE "accounts" ADD "currency" character varying

2. When creating new records for that table, set the desired default value using your code

There are tons of ways of accomplishing it and it really depends on how you create your records, but this is good enough for the example:

account.currency ||= "USD"

3. Backfill all your table rows with the desired default value

If you have a large database you also probably already have a way of running code for all your records asynchronously to finish it really fast -- If not let me know -- but if you don't have it, a .find_each or a .find_in_batches would probably do the trick:

Account.where(currency: nil).find_each do |account|
  # .update_attributes doesn't touch updated_at
  account.update_attributes(currency: "USD")
end

Why not just run Account.where(currency: nil).update_all(currency: "USD") ?

Because this ☝️ is going to lock your table while your database updates all your rows, that's why we need to update individual records so the database locking only happens per row.

4. Finally, add the default value to your column 🎉

class AddDefaultToCurrencyOnAccounts < ActiveRecord::Migration[5.2]
  def change
    change_column :accounts, :currency, :string, default: "USD", null: false
  end
end

This is going to run this SQL

ALTER TABLE "accounts"
ALTER COLUMN "currency" TYPE character varying,
ALTER COLUMN "currency" SET DEFAULT 'USD',
ALTER "currency" SET NOT NULL

After that you can remove your code that sets the default value when creating your records from step #2 and it's done 🎉

Little trick to use ctags to jump to definition even inside gems like Rails on vim

lucasprag — Wed, 06 Nov 2019 01:40:52 +0000

If you don't know what is ctags

Ctags is a programming tool that generates an index file of names found in source and header files of various programming languages. Depending on the language, functions, variables, class members, macros and so on may be indexed. -- Wikipedia

In the case of Ruby you can jump to a method definition, class, etc using ctags which doesn't work 100% of the time but it helps a lot.

vim

Vim has a native functionality where you can :tag MyClass and it opens your class based on the index created by ctags.

You can extend this functionality as much as you like

" open tag of the word under the cursor, requires to run "ctargs -R ." before
command! JumpToTag execute ':tag ' . expand("<cword>")

command! JumpToTagOnVsplit :vsplit
      \| execute ':tag ' . expand("<cword>")

command! JumpToTagOnSplit :split
      \| execute ':tag ' . expand("<cword>")

but there is one limitation when using Rails and other gems; you can't jump inside them, like :tag ApplicationRecord.

the trick

You can run bundle install and set the path to install gems inside your project so when you run ctags -R . all the gems get indexed.

bundle install --path=vendor/bundle

But remember to git ignore them

# ~/.gitignore_global
vendor/bundle

gutentags

If you don't like run ctags -R . all the time, there is a plugin for vim that runs ctags in the background while you are coding. It's called vim-gutentags. All you need to do is install it.

That's it, I hope you enjoyed this little trick to make our lives a bit easier when coding Rails on vim. 👍

My editor journey: sublime, vim, emacs, vscode

lucasprag — Sat, 04 Aug 2018 17:55:16 +0000

I will talk about my experience using each of those text editors, maybe it could be useful for someone evaluating text editors to invest time learning.

sublime text

I started learning about programming when I was in high school, it was so much fun to write some code and see the results on the browser. I used sublime text because I was learning with blog posts and videos and most of the content mentioned sublime text. Also, it was fast and I had a few plugins installed to handle php, html, javascript and css. I used it for a few years at work too until the day I joined a company that had vim and emacs users.

vim

The vim users worked on projects more closed to my own project so I started to check how they did things and then I started learning about vim. It was not cool, it was too hard to learn how to use it, to load new config files I had to restart vim every time and so much other problems, but since they did, I convinced myself that I could learn it too so I did.

I used vim for a few months and what I like about vim the most is that it's optimized for editing files not creating new ones. For the most of the time, we're editing files and moving between lines of code so that makes sense. Finally I was happy and productive using vim.

neovim

One day I heard about neovim, not sure exactly why I switched to it, but take a look on the github project for both projects:

Wait what? Only one contributor on the vim repository? How only one person could have done that? Checking the pull request list I saw that the author applies changes from other people as it was his changes. Ok, I didn't liked that, so I changed to neovim which gives credit for people when they contribute.

UPDATE: I agree that my survey is too shallow. My see this comment. But I still don't like that.

nvim + tmux

At that time people was talking about tmux which is a terminal multiplexer so you could split your terminal and have tabs and customize everything from shortcuts to how tmux looks like for example adding useful info to your status bar. I tried and I liked. Since I was using nvim in the terminal it worked very well and I even found some plugins to integrate them smoothly. Here is how it looks like:

I don't use nvim anymore, but you can still find my configuration for vim and tmux.

I used this stack for 3 years and I was happy.

Then I see myself managing configs and plugins for nvim, tmux, zsh to run well on terminator on my Debian at work and iTerm on macOS at home. Not everything worked well between plugins too, for example I had auto completation on nvim and it works well unless I'm using multiple cursors which is a feature from another plugin, the auto completation would work only for the first cursor because they didn't integrated with each other. I got other frustrating problems like that one and I see myself spending too much time debugging or trying alternative plugins, so I was tented to try something different and this is where emacs came to my attention.

emacs

Emacs has a GUI app which makes me don't need terminator or iTerm anymore and it has his own shell written in elist called eshell, so I'd have one config and plugins for everything. I tried to start from scratch writing down every config as I did with vim, but it was too much to learn and I had to get some work done so I tried spacemacs and with some help I could be productive in no time.

Spacemacs has vim key bindings so I was at home, I just needed to learn to handle different aspects of spacemacs like layouts and workspaces. It was easier to do things because it has a real-time display of available key bindings, so while you type you can see your options, also it is mnemonic so if you want layouts you'd use SPC + l, if want to toggle something you'd use SPC + t, if you want buffers you'd use SPC + b, for projects SPC + p, for files SPC + f and to save a file you'd combine commands like SPC + fs which means spacemacs -> file -> save and SPC + pt to see the project tree of files. Very straightforward right?

It took me like a month to understand everything and to work well. I was not happy with everything, I got some bugs which is ok, I reported and I tried to fix them but I had to learn one more language (elisp) to be able to do that. It was a great experience because I was learning a lot of elisp which is a great language in my opinion so I was having fun, which made me use spacemacs for 6 months.

Then I saw this video:

Wait what? 10 years of love for Emacs undone by a week of VSCode? I have some friends who are happy with vscode too, they strongly recommend it. Ok, let's give it a try.

vscode

I had to do some coding in a weekend so I switched to vscode and overall the experience was great, but I had to use the mouse a lot initially.

I installed the vim key bindings which for my surprise also has support for common vim plugins like vim-easymotion, vim-surround, vim-commentary and others that I've never heard of.

Killer features for me that I found in vscode:

cmd + p to open files using fuzzy search is faster and more intelligent (it puts recent files on top)
shortcuts are more similar with browser shortcuts which makes my life easier as web developer
config files are JSON files and there is no need for too much customization (my config file has 22 lines and that's all)
the integrated multiple terminal works really well and it has splits like tmux
vscode is maintened by Microsoft which I think it's great to have a team working on it and adding features that integrate well with each other
I don't need to debug vscode and I didn't find any bug so far
I don't need to install too much plugins
jump to definition for React

Vscode plugins I have installed:

Vim Keybindings
Project Manager - easier to switch between projects using ALT + CMD + p
Bookmarks - ALT + CMD + k to add a bookmark and ALT + CMD + l to jump to the next bookmark
File Utils - easier to duplicate or rename files without using the mouse
Support for Ruby
Support for Ruby Haml
Autocompletation for Ruby
Linting for Ruby
Support for Python
Support for Elixir
Support for React
ESLint
One Dark Pro Monokai Darker Theme - my favorite color schema

That's my experience with text editors. Today I don't have to debug my editor to make simple things happen and I still can customize it for my needs. Yeah, I'm pretty happy with vscode and maybe you should try it too. I hope it was useful for someone.

Also I'm looking forward to hear your opinion and experience about those text editors. Thanks.

Use-case oriented rails applications

lucasprag — Tue, 31 Jul 2018 14:54:27 +0000

I will bring here an approachable solution for building rails applications using some fundamentals of the so-called clean architecture. But, what is it?

clean architecture

It's hard to tell what it is without telling about the problem.

The problem is, look at your rails application, try to identify what it does, open your app folder and try to identify again.

We can see some folders like controllers, models, helpers and so on. Even when opening one of those folders we cannot say what is does, but we can only say what that application have, like users or products. The clean architecture came to try to solve this problem.

One thing we can notice on that rails applications is that it's screaming web framework!.

But one thing we can never forget is that the web is a delivery system and should not dominate our code.

the proposal

A picture is worth a thousand words so let's check some images from Robert C. Martin illustrating his proposal of what path the request should follow:

the user interacts with the system

the delivery mechanism builds a request model and passes it to the boundary/interface

the interface knows which interactor to use and passes the request model to it

and the interactor executes the business rules

and interacts with entities

the interactor builds a result model and give it back to the boundary/interface

which will give it back to the delivery mechanism and the user

As you can see, the framework is just a detail in that architecture, it's a delivery mechanism. The interface to the user can be a website as well as a command line tool, the business rules go on the use cases which can interact with entities.

what about MVC?

MVC (aka Model View Controller) is an architectural pattern which the user interacts with a controller who manipulates a model who updates the view where the user sees the result. I got this image from wikipedia to illustrate better:

The MVC pattern was created by Trygve Reenskaug to use with SmallTalk for graphical user interface (GUI) software design in 1979.

But what happens when we use this approach to build our entire web application?

It gets messy.

I'm not saying the MVC is bad, I'm saying that it's part of the delivery mechanism not of the application architecture.

real world use case

As an user, I want to pay an invoice

Imagine you have a web application and you send invoices to your users, and then they pay their invoices. So that use case could be named 'pay_invoice' and to group related classes I will create a module call Accoutant.

The goal is to call the use case in the controller like this:

class InvoicesController < ApplicationController
  def pay
    if Accountant.pay_invoice(params[:invoice_id], credit_card_params)
      format.html { redirect_to @invoice, notice: 'Invoice was successfully paid.' }
    else
      format.html { redirect_to @invoice, error: 'We got a problem paying that invoice' }
    end
  end
end

In order to have that use case available we need to create a class like so:

require 'caze'

module Accountant
  class PayInvoice
    include Caze

    attr_accessor :invoice_id, :credit_card

    export :call, as: :pay_invoice

    def initialize(invoice_id, credit_card)
      @invoice_id = invoice_id
      @credit_card = credit_card
    end

    def call
      # register payment thought payment gateway (maybe background job)
      # change invoice status
    end

    private

    def invoice
      @invoice ||= Invoice.find(invoice_id)
    end
  end
end

some points to notice:

there is only one public instance method (call)
this class has one responsibility
easy to write specs
I used the caze gem to have a simple DSL to define use cases instead of doing this:

def self.pay_invoice(invoice_id, credit_card)
  self.new(invoice_id, credit_card).call
end

We add that use case to the Accountant module like so:

require 'caze'

module Accountant
  include Caze

  has_use_case :pay_invoice, PayInvoice
end

Now we can say one thing that this application does which is pay invoices. Take a look on how the files are organized:

You don't really need to use the caze gem, the important part of all this is:

We separated what the application HAS

models like invoice, account and so on that doesn't change very much (stable)

of what the application DOES

behaviors and use cases tend to change a lot while the business grows

when to write use cases?

When you only need to manage resources, you can and should use the rails way which is resource oriented so it makes sense, but when you have a special logic and it's very unique to your business rules, you write use cases like the code above.

conclusion

After all that work we can look on our application and quickly see what it does instead of just seeing resources which is what it has, you can also move between frameworks or create new interfaces to use your unique business rules.

Keep in mind that there is no silver bullet in programming, but this is for sure a very effective approuch to keep your use cases organized and keep your software architecture clean.