I learnt to code around 2004 and started programming professionally in 2007. I never stopped. Even between 2022 and 2024, when I worked as an Engineering Manager, I kept coding in my spare time, listening to podcasts, watching YouTube videos, and keeping up with an ecosystem I've always been passionate about.

I love programming. Explaining to the computer what to do and how to do it is a joy that only those who do it can truly understand. It has its challenges, but it's rewarding, both professionally and financially.

Then AI arrived, and programming became one of the fields most affected by it.

Programming became reviewing diffs

At first, I used AI sporadically. As the tools evolved, I started using them more and more.

I've used editors like Vim, VS Code, and Cursor. Today, interestingly, my main tools are no longer terminal + editor/IDE, but terminal + a Git GUI app, which I used to open only occasionally and now use more than the editor itself.

In the terminal, tools like Claude Code, Gemini CLI, and similar ones are the stars of the moment. I've reached a point where it's rare for me to open the editor to change anything. Even for simple changes, I prefer to ask Claude Code and then review what was done via git diff.

Git has never been so important

I've always used Git. But when AI is creating or updating code, Git becomes even more essential. When something I'm working on isn't trivial, I ask the AI to make changes step by step and, after each interaction, I stage the modified files to review what changed. I only make a commit when a self-contained change is ready.

Git has become my layer of control over the AI.

I started using AI for everything. Productivity skyrocketed, but my satisfaction not so much

For most of last year, everything seemed great. I even laughed at this meme:

I laughed and agreed, but I didn't imagine it would hit me later.

Today I'm clearly more productive with AI. I deliver more. The code quality also tends to be better, though of course I still review everything the AI does. Clients and companies are more satisfied, after all we're delivering more in less time.

Even the famous project management triangle seems affected. Scope, time and cost have all improved simultaneously, without affecting quality - something we've always been taught is impossible. Of course, quality still depends on how the AI is used and reviewed, but the gains are undeniable.

The so-called vibe coding hasn't yet reached the point of leaving everything 100% in the AI's hands without supervision, but the trend is heading that way.

And yet, something bothers me.

We're outsourcing our brains to LLMs

I feel less challenged. Before, when a dependency was updated, I would:

• Read the Changelog
• Identify breaking changes
• Analyse the impact on the project
• Adjust the code manually

Today, it's far more practical to ask the AI to do it. It'll probably do it better and in a fraction of the time. So why would I do it manually? That's the bit that gets me.

Using AI or not is no longer a personal choice. Not using AI means falling behind, becoming outdated.

The new role of the programmer

In practice, my job today is:

• Understand the problem or requirement
• Discuss with the team until we align on a solution (high-level, not necessarily how the implementation will look)
• Think about UI and UX
• Plan integrations with existing systems
• Write a Jira card

After that, I send all the context to Claude Code and use Agents, Skills, MCPs and the like to execute. Even tasks involving multiple repositories - something common where I work - are handled quite competently by AI.

Even commit messages, PR titles and descriptions, and Jira cards often go through AI. I know it'll usually write them better than I would.

Day to day, what I do is review, simplify, and adjust what was generated. Sometimes I fix details in the code or documentation. But the hard part has already been done.

And I increasingly feel less desire to do it manually. Some days, I can't even be bothered. This leaves me with the feeling that I might be getting dumber, since the challenges are much smaller.

Loss of skill - or evolution?

For a while, I was hesitant to admit that I use AI for everything. When I don't use it, I feel unproductive. Talking to other people, I realised I'm not alone.

I'm not doing anything wrong. I'm pursuing productivity. Right?

Even so, the doubt arises: will I lose my programming skills? At least in the form they existed until now?

Perhaps.

But so what? AI will keep evolving. I'm still needed to review, contextualise and ensure the result makes sense. I'm not worried about losing my job - that's another discussion worth having (let me know in the comments how you feel).

My concern is different: my professional satisfaction.

Programming has always been something I loved. And now that's changing. Not necessarily for the worse. But it's changing.

AI made me 10x more productive... and 2x more insecure

Sometimes I catch myself wondering if we're heading towards something like Idiocracy - an exaggerated film, but with a grain of truth.

I'm not afraid of machines taking over everything and/or replacing us. I still feel useful. What worries me is the transformation of the joy of programming. Everything changed so fast. Think about what it was like 2-3 years ago.

It'll never be the same again.

Maybe I sound like an old man yelling at clouds, but the speed of change is staggering. And it'll continue, because there's too much money and interest involved.

I'm not against AI - quite the opposite. I use it extensively. I advocate for it. I recommend it. But I'm also trying to make an honest analysis of what's happening.

And, to be completely honest, I'm worried.

Eu aprendi a programar por volta de 2004 e comecei a programar profissionalmente em 2007. Nunca parei. Mesmo entre 2022 e 2024, quando trabalhei como Engineering Manager, continuei codando no tempo livre, ouvindo podcasts, assistindo a vídeos no YouTube e acompanhando um ecossistema que sempre me interessou.

Eu amo programar. Explicar para o computador o que fazer e como fazer é um prazer que só quem faz consegue entender. Tem desafios, mas é recompensador, tanto profissionalmente quanto financeiramente.

Então as IAs chegaram, e a programação foi uma das áreas mais impactadas.

Programar virou revisar diffs

No início eu usava IA de forma esporádica. Conforme as ferramentas evoluíram, passei a usar cada vez mais.

Já usei editores como Vim, VS Code e Cursor. Hoje, curiosamente, minhas ferramentas principais não são mais terminal + editor/IDE, mas terminal + um Git GUI, que antes eu abria de vez em quando e agora uso mais do que o próprio editor.

No terminal, ferramentas como Claude Code, Gemini CLI e similares são o destaque da vez. Cheguei a um ponto em que é raro eu abrir o editor para alterar qualquer coisa. Mesmo mudanças simples, prefiro pedir ao Claude Code e depois revisar o que foi feito via git diff.

Git nunca foi tão importante

Eu sempre usei Git. Mas, quando uso IA para criar ou atualizar código, o Git se tornou ainda mais essencial. Quando algo que estou trabalhando não é trivial, peço para a IA fazer mudanças passo a passo e, após cada interação, movo os arquivos modificados para a staging area para revisar o que mudou. Só faço o commit quando uma mudança auto-contida está pronta.

O Git virou minha camada de controle sobre a IA.

Passei a usar IA para tudo. A produtividade explodiu, mas minha satisfação nem tanto

Durante boa parte do último ano, tudo parecia ótimo. Eu até ri desse meme:

Ri e concordei, mas não imaginei que aquilo fosse me atingir depois.

Hoje eu sou claramente mais produtivo com IA. Entrego mais. A qualidade do código também tende a sair melhor, embora eu ainda revise tudo o que a IA faz. Clientes e empresas ficam mais satisfeitos, afinal estamos entregando mais em menos tempo.

Até o famoso project management triangle parece afetado. Escopo, tempo e custo melhoraram ao mesmo tempo, sem afetar a qualidade - algo que sempre aprendemos ser impossível. Claro, a qualidade ainda depende de como a IA é usada e revisada, mas o ganho é inegável.

O tal do vibe coding ainda não chegou ao ponto de deixar tudo 100% na mão da IA sem supervisão, mas a tendência é evoluir.

E mesmo assim, algo me incomoda.

Estamos terceirizando nosso cérebro para LLMs

Sinto que estou menos desafiado. Antes, quando uma dependência era atualizada, eu:

• Lia o Changelog
• Identificava breaking changes
• Analisava o impacto no projeto
• Ajustava o código manualmente

Hoje, é muito mais prático pedir para a IA fazer isso. Ela provavelmente fará melhor e em uma fração do tempo. Então por que eu faria manualmente? Esse é o ponto que me pega.

Usar IA ou não deixou de ser uma escolha pessoal. Não usar IA significa ficar para trás, ficar desatualizado.

O novo papel do programador

Na prática, meu trabalho hoje é:

• Entender o problema ou demanda
• Discutir com o time até alinharmos uma solução (de alto nível, não necessariamente como será a implementação)
• Pensar em UI e UX
• Planejar integrações com sistemas existentes
• Escrever um card no Jira

Depois disso, envio todo o contexto para o Claude Code e uso Agents, Skills, MCPs e afins para executar. Mesmo tarefas que envolvem múltiplos repositórios - algo comum onde trabalho - são feitas com bastante competência pelas IAs.

Até mensagens de commit, títulos e descrições de PR e cards do Jira muitas vezes passam pela IA. Eu sei que, na maioria das vezes, ela vai escrever melhor do que eu.

No dia a dia, o que faço é revisar, simplificar e ajustar o que foi gerado. Às vezes corrijo detalhes no código ou na documentação. Mas a parte mais difícil já foi feita.

E cada vez tenho menos vontade de fazer isso manualmente. Às vezes, dá até preguiça. Isso me deixa com a sensação de que posso estar ficando mais burro, já que os desafios são bem menores.

Perda de habilidade - ou evolução?

Por um tempo, fiquei receoso de admitir que uso IA para tudo. Quando não uso, me sinto improdutivo. Conversando com outras pessoas, percebi que não estou sozinho.

Não estou fazendo nada errado. Estou buscando produtividade. Certo?

Mesmo assim, surge a dúvida: vou perder minhas habilidades de programação? Pelo menos no formato em que elas existiam até agora?

Talvez sim.

Mas e daí? As IAs vão continuar evoluindo. Ainda sou necessário para revisar, contextualizar e garantir que o resultado faz sentido. Não estou preocupado com perder emprego - essa é outra questão que vale discutir (me conte nos comentários como você se sente).

Minha preocupação é outra: minha satisfação profissional.

Programar sempre foi algo que eu amei. E agora isso está mudando. Não necessariamente para pior. Mas está mudando.

A IA me deixou 10x mais produtivo... e 2x mais inseguro

Às vezes me pego pensando se estamos caminhando para algo no estilo Idiocracy - que é um filme exagerado, mas com um fundo de verdade.

Não estou com medo das máquinas dominarem tudo e/ou nos substituírem. Ainda me sinto útil. O que me preocupa é a transformação do prazer de programar. Tudo mudou muito rápido. Pense em como era 2-3 anos atrás.

Nunca mais será como antes.

Talvez eu soe como um velho reclamando, mas a velocidade da mudança impressiona. E vai continuar, porque há muito dinheiro e interesse envolvidos.

Não sou contra IAs - muito pelo contrário. Uso intensamente. Defendo. Recomendo. Mas também estou tentando fazer uma análise honesta do que está acontecendo.

E, sendo bem sincero, estou preocupado.

Olá, meus caros! Tenho o prazer de anunciar que o meu curso React: Direto ao Ponto agora está disponível gratuitamente para todo mundo! 🚀 O curso era pago, e as inscrições foram encerradas em agosto de 2023. Como não tenho planos de abrir novas turmas, decidi liberar o conteúdo completo de graça 😃

ACESSAR O CURSO

Recomendo assistir pelo menos à 1ª e à 2ª aula para ver tudo o que você vai aprender. Embora o curso não seja novo, cerca de 95% do conteúdo continua atual!

Por que React?

React é atualmente uma das tecnologias mais demandadas no mercado de desenvolvimento front-end. Com ele, você pode:

• Criar interfaces de usuário interativas e modernas
• Desenvolver aplicações web escaláveis
• Trabalhar com uma das tecnologias mais utilizadas por grandes empresas
• Ter acesso a um ecossistema rico de ferramentas e bibliotecas

Para quem é este curso?

Este curso é ideal para:

• Desenvolvedores que já conhecem JavaScript básico
• Profissionais que querem migrar para o desenvolvimento front-end moderno
• Estudantes que querem aprender uma tecnologia em alta demanda
• Qualquer pessoa interessada em criar aplicações web interativas

Metodologia

Como sempre, minha abordagem é direto ao ponto. Nada de enrolação, teoria em excesso ou conteúdo desnecessário. A ideia é focar no que realmente importa para você sair do curso criando aplicações React do mundo real.

Cada aula foi pensada para maximizar seu aprendizado em menos tempo, com exemplos práticos e exercícios que simulam situações reais do mercado de trabalho.

ACESSAR O CURSO

O que você vai aprender? (lista de vídeos)

• Introdução ao curso
• Introdução à React
• Instalação do Node.js & do Yarn
• VS Code (editor) e algumas extensões
• React Developer Tools (extensão para navegadores)
• Ferramentas
• Primeiro projeto e JSX
• Fragment
• Limpando o projeto
• Criando componentes
• Importando CSS e imagens
• Reusabilidade - Props (propriedades) & Children
• useState: o React Hook para gerenciar estados
• Evento onClick
• Evento onChange
• Desestruturação
• Repetições com map
• Atributo especial key
• Criando o projeto RGB (e como usar a extensão React Developer Tools)
• Componente para prever a cor
• Spread operator e Imutabilidade
• Passando funções como props
• Desabilitando elementos
• Renderização condicional
• Gerando dados aleatórios
• Criando o projeto Gerador de Senhas
• Estilizando a aplicação
• useEffect - o React Hook que executa efeitos colaterais
• Gerando a senha - parte 1
• Gerando a senha - parte 2
• Gerando a senha - parte 3
• Criando um componente para exibir a senha
• Expressões regulares para classificar e colorir a senha
• Copiando a senha para a área de transferência
• Introdução à Context API
• Criando o projeto Theme Switcher
• createContext, Provider e useContext
• localStorage
• Criando o projeto Timers
• CSS Modules
• onSubmit e FormData
• Atualizações Funcionais
• Spread Properties
• Fonte personalizada
• setInterval e clearInterval
• Componente com SVG
• Removendo timers
• Limpando recursos ao desmontar componentes
• Memoization
• React.memo
• useCallback e Shallow comparison
• useMemo
• Usando useRef para focar em um elemento
• Usando useRef com o ID do setInterval
• Função reduce
• Introdução à useReducer
• Criando um formulário de login
• Implementando com useState
• Refatorando com useReducer
• Buscando usuários na API do GitHub
• Consumindo lista de repositórios da API do GitHub
• Introdução ao Next.js
• Criando o projeto Pizzaton
• Next/Link
• Lendo dados de arquivos JSON
• Next/Image
• Rotas dinâmicas (parte 1)
• Rotas dinâmicas (parte 2)
• Redirecionamentos
• Deployment (colocando seu projeto no ar)
• Conclusão do curso

ACESSAR O CURSO

Ruby provides multiple ways to define class methods, and one common approach is to use the class << self block. However, this syntax has a subtle gotcha: methods defined inside the block are public by default, even if the block is nested inside a private section.

This behaviour can unintentionally expose class methods that should remain private, making your code harder to maintain.

Here's an example:

class MyClass
  private
  class << self
    def my_method # ← this is a public method 😱
      # ...
    end
  end
end

Why does this happen?

When you use class << self, Ruby opens the singleton class of the object (in this case, your class). While methods defined in a normal class body respect the current visibility context (private, protected, or public), class << self resets the default visibility to public. As a result, any method defined there will be public unless explicitly declared otherwise.

Option #1 to fix it: declare private explicitly

Within the class << self block, explicitly set the visibility to private:

class MyClass
  private
  class << self
    private # ← you have to declare `private` again
    def my_method # ← now this method is actually private!
      # ...
    end
  end
end

By the way, all subsequent methods defined in the block will also be private!

Option #2: use private_class_method

Although I personally don't like this approach, an alternative is to define the class method and then use private_class_method to set its visibility:

class MyClass
  class << self
    def my_method
      # ...
    end
  end
  private_class_method :my_method
end

Keep this in mind and you'll avoid a subtle visibility bug in your Ruby code.

Olá, meus caros!

Meu canal no YouTube finalmente está de volta, e voltou com tudo! Tenho publicado conteúdos novos sobre vários temas que espero que te interessem. Se você ainda não está inscrito, não perde tempo: tem muita coisa boa vindo por aí.

👉 youtube.com/lucascaton

Além do YouTube, minhas outras redes sociais também estão ativas. Se você quiser acompanhar mais de perto e ver conteúdos sobre programação, carreira, trabalho fora do Brasil, bastidores e muito mais:

Fica ligado, e até o próximo vídeo! 👋

I like being able to run locally the same tools I'd use on a CI server so I can catch issues early. There are various tools you might want to run:

• Automated tests
• Code analyzers, such as linters and security vulnerability scanners
• Anything else you'd run on your CI server

However, you may face the following issues:

• 👎 Running all these tools can sometimes take too long
• 👎 You might not want to run everything before pushing your changes to your code hosting platform, like GitHub
• 👎 You may forget what to run, especially if you need to run many different tools
• 👎 What you run, and how you run it, might differ from how a colleague on the same project does it

What I tried before (and didn't work as well as I expected)

In 2015 (9 years ago!), I created a Ruby gem called massa to help solve this problem. I'm no longer using or maintaining this project, but the idea was to create a YAML file where you could specify what you'd like to run and even define which tools are required. This way, optional tools wouldn't cause the process to fail if they encountered issues/offenses.

Eventually, I stopped using that and began relying on my ZSH history, ZSH autosuggestions, and fzf to remind me of everything I need to run. The only reason this isn't a (very) bad idea is that I was running everything in one single command. Here's an example for a Rails app:

bundle exec rubocop && bundle exec rspec && bundle exec brakeman --run-all-checks --exit-on-warn --exit-on-error --rails7 --no-pager

As you can probably tell, commands can get lost in the history, and this solution doesn't address some of the issues described at the beginning of this post.

New approach

I'm now trying something that seems to be a better overall approach: Git hooks. I've been using Git hooks for ages, but I had never spent time creating a formal process across the open-source projects I maintain and my side projects.

The first thing I did was create a default git pre-commit hook. With that and the [init] templatedir setting in my ~/.gitconfig (which you can also see in the linked commit), every time I clone a repo or create a new one with git init, it automatically gets a copy of that hook saved in .git/hooks/pre-commit.

This is what my pre-commit hook script looks like at the moment:

#! /bin/bash
set -euxo pipefail
# >>> For Node.js/React/React Native projects:
# yarn lint
# yarn test
# yarn test:all
# >>> For Ruby/Rails projects:
# bundle exec rubocop
# bundle exec rspec
# bundle exec brakeman --run-all-checks --exit-on-warn --exit-on-error --rails7 --no-pager --quiet
# bundle exec rails_best_practices . -c config/rails_best_practices.yml
# TODO: uncomment the above lines and remove the below line
echo "⚠️ Edit or remove the .git/hooks/pre-commit file"

For each project, I uncomment the lines that I want to run and remove the echo with the warning at the end of the script. When necessary, I add extra project-specific tools as well.

Now, every time you attempt to commit something, that script will run. If it fails, the commit will not be completed, and you'll see what's failing. I also like to keep the x flag in the set command to see what command is running. If all tools pass, i.e., if all commands finish their execution with status 0, the commit will be completed.

What if it takes too long?

In these cases, I like to have two hooks:

• pre-commit: runs quick things, usually linters and fast automated tests
• pre-push: runs everything, only when running git push

Aliases, because I'm lazy

I'm an alias addict. For different reasons, I may want to run the pre-commit hook before I'm actually ready to commit the changes, so I've set the following aliases:

alias ch=".git/hooks/pre-commit" # ch = (pre-)Commit Hook
alias ph=".git/hooks/pre-push" # ph = (pre-)Push Hook

Let me know in the comments how you solve this problem, and whether you use a different or better approach 🙂

Olá, meus caros!

As aulas que você está prestes a assistir faziam parte de um curso pago. As inscrições foram encerradas em agosto de 2023. Como não tenho planos de abrir novas turmas, decidi disponibilizar parte do conteúdo gratuitamente 🙂

Espero que goste. Sucesso em sua jornada! 👊

Olá, meus caros!

As aulas que você está prestes a assistir faziam parte de um curso pago. As inscrições foram encerradas em agosto de 2023. Como não tenho planos de abrir novas turmas, decidi disponibilizar parte do conteúdo gratuitamente 🙂

Espero que goste. Sucesso em sua jornada! 👊

Códigos usados no vídeo:

metodos.rb

def numeros_impares(min = 0, max)
  (min..max).each do |numero|
    puts "O número #{numero} é ímpar" if numero.odd?
  end
end
def media(elementos)
  elementos.sum / elementos.size
end
def rolar_dado(faces)
  return 'número de faces precisa ser maior que 1' if faces <= 1
  rand(faces) + 1
end
numeros_impares(80, 90)
puts '---'
numeros_impares(12)
# puts media([9, 1, 2])
# puts media([10, 20])
# puts rolar_dado(1)
# puts rolar_dado(6)

classes.rb

# 1ª demonstração
class Cachorro
  def latir
    puts "au au"
  end
end
class Gato
  def miar
    puts "miau"
  end
end
cachorro = Cachorro.new
cachorro.latir
Gato.new.miar
#################################################
# 2ª demonstração
class Conta
end
class Banco
  def criar_nova_conta
    Conta.new
  end
end
banco = Banco.new
conta = banco.criar_nova_conta

escopo_de_variaveis.rb

class Pessoa
  def definir_nome(novo_nome)
    puts "O novo nome é #{novo_nome}"
    @nome = novo_nome
  end
  def exibir_informacoes
    puts "Nome: #{@nome}"
  end
end
pessoa = Pessoa.new
pessoa.definir_nome('Lucas')
pessoa.exibir_informacoes
pessoa2 = Pessoa.new
pessoa2.definir_nome("Daniel")
pessoa2.exibir_informacoes

metodo_construtor.rb

class Pessoa
  def initialize(nome, idade)
    @nome = nome
    @idade = idade
  end
  def exibir_informacoes
    puts "#{@nome} tem #{@idade} anos."
  end
end
pessoa = Pessoa.new('Joana', 45)
pessoa.exibir_informacoes

setters_and_getters.rb

class Produto
  attr_reader :fabricante      # somente leitura
  attr_writer :preco           # somente escrita
  attr_accessor :nome, :codigo # ambos leitura e escrita
  def initialize
    @fabricante = 'Apple'
    @codigo = 1234
  end
end
celular = Produto.new
# celular.fabricante = 'LG' # tentando chamar o setter (x)
# puts celular.fabricante   # tentando chamar o getter (✓)
# celular.preco = 1000 # tentando chamar o setter (✓)
# puts celular.preco   # tentando chamar o getter (x)
# celular.nome = 'iPhone' # tentando chamar o setter (✓)
# puts celular.nome       # tentando chamar o getter (✓)
# celular.codigo = 6789 # tentando chamar o setter (✓)
# puts celular.codigo   # tentando chamar o getter (✓)

metodo_privado.rb

class Sorteio
  def initialize(participantes)
    @participantes = participantes
  end
  def sortear
    return if @participantes.empty?
    sorteado = @participantes.sample
    puts "O participante sorteado foi: #{sorteado}!"
    remover_participante(sorteado)
  end
  private
  def remover_participante(participante)
    @participantes.delete(participante)
  end
end
participantes = ['Bruno', 'Gabriela', 'Leandro', 'Marcia']
sorteio = Sorteio.new(participantes)
sorteio.sortear
sorteio.sortear
sorteio.sortear
sorteio.sortear
sorteio.sortear
# Não é possível chamar o método privado abaixo:
# sorteio.remover_participante('qualquer coisa')

metodo_de_classe.rb

class Tempo
  def self.agora
    Time.now
  end
  # Podemos misturar métodos de classe e métodos de instância
  # na mesma classe, sem problemas:
  def alguma_coisa
    puts "funciona!"
  end
end
puts Tempo.agora
# tempo = Tempo.new
# tempo.alguma_coisa
# # ou...
Tempo.new.alguma_coisa

Olá, meus caros!

As aulas que você está prestes a assistir faziam parte de um curso pago. As inscrições foram encerradas em agosto de 2023. Como não tenho planos de abrir novas turmas, decidi disponibilizar parte do conteúdo gratuitamente 🙂

Espero que goste. Sucesso em sua jornada! 👊

Instalando ferramentas de desenvolvimento (comandos executados):

# Somente no Windows:
wsl --install
wsl --set-default-version 1 # Pode não ser necessário
wsl --set-default-version 2 # Pode não ser necessário

# Windows e Linux:
sudo apt update && sudo apt upgrade
sudo apt install build-essential git automake autoconf libreadline-dev libncurses-dev libssl-dev libyaml-dev libxslt-dev libffi-dev libtool unixodbc-dev unzip curl zlib1g-dev sqlite3 libsqlite3-dev
git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch vX.X.X
echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.bashrc
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc
asdf --version

# Somente no Windows:
\\wsl$

# Somente no macOS:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install asdf
echo -e "\n. $(brew --prefix asdf)/libexec/asdf.sh" >> ~/.zshrc
asdf --version

# Todos os sistemas:
asdf plugin-add ruby
asdf install ruby X.X.X
asdf global ruby X.X.X
ruby -v

A little over ten years ago, I was looking for a job that held the potential to sponsor my work visa in Australia. At the time, I wasn't quite sure if I had what it took to secure one. It took a while but on April 15, 2013, the course of my life took a remarkable turn. That morning, I woke up to find a life-changing email in my inbox with the subject "Offer of Employment". It was from Bruce Stronge, who I'll forever be grateful for offering me an opportunity that would lead me to a life I could never have imagined.

On August 16, 2013, exactly 10 years ago, my wife Aline (Lily) and I embarked on a journey that would redefine our lives. Leaving our home in Brazil, we arrived in Australia with dreams and hopes for a fresh start. The anticipation and uncertainty marked the beginning of an adventure that would shape us in unimaginable ways. Today we're celebrating 10 Years in Australia! 🇦🇺

Beyond learning to love Vegemite and Tim Tam, the contrasts in language, habits, food, and even driving side have enriched my perspective and broadened my horizons.

Over the past decade, I've had the privilege of meeting remarkable people who have become part of my life. From colleagues at the three different jobs I've held to the camaraderie of my Taekwondo club and the shared joy of board game days, each connection has added vibrancy to my Aussie experience.

From the Australian breathtaking landscapes to its vibrant culture, I've found a home away from home that resonates with my soul in this amazing country.

Australia isn't just a place though; it's where our family grew. Our two beloved children, Harry and Noah, were born here, adding immeasurable joy and purpose to our lives. The memories we've created have intensified our connection to this land.

While the journey has been incredible, it hasn't been without its challenges. Being far away from family and friends in Brazil has been the toughest part. However, the strength of the bonds we've forged here and the connections we've made have provided comfort and support to us.

I want to take this moment to express my heartfelt gratitude to those who have made this journey extraordinary. Bruce Stronge, for the opportunity I mentioned in the beginning; you might not realise how important you were to me and my family and I can't thank you enough. Ricardo Bernardeli and Raissa Mantovani, your referral to NetEngine, support, friendship, and warm welcome to Australia will always hold a special place in my heart. To Thiago Aléssio (aka. Xis) and Vitor Pellegrino, your courage to pursue new horizons inspired my own leap of faith.

As I celebrate this milestone, I eagerly look forward to the future. The prospect of more years in Australia with new experiences, friendships, and growth excites me. With a heart full of gratitude, I embrace the journey that continues to unfold! 🦘🐨💚

Upgrading a Ruby on Rails app can be a daunting task, but I've found a strategy that works well, particularly for small to medium size projects.

Instead of using the rails app:update rake task, which is the approach recommended in the official Rails Guides, I prefer to generate a new app, for example with the following command:

rails new --database postgresql --skip-test /tmp/my-app
# Use any other flag to make it as close as possible to the original app

Then, I replace all the files in the current repository with the new ones, except for the .git directory. After that, I compare the changes in each file and decide whether to keep or remove them based on whether they make sense for my project running on the new version of Rails.

One of the benefits of this approach is that it addresses all the necessary changes at once, rather than only updating the strictly required files like the rake task does.

The rake task will always create a config/initializers/new_framework_defaults_[old-version].rb file, which is frequently overlooked and left unmodified (until it causes problems or during the next upgrade), resulting in the app running on the new Rails version with some of the old version's defaults.

The strategy I use can be a bit more time-consuming (after all, you're ripping the whole upgrade steps off like a Band-Aid), but in my experience, it has resulted in fewer issues.

For example, I recently upgraded an app and realised that with the rake task approach, it didn't upgrade the app/models/application_record.rb file at all, while this method would have replaced:

 class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
+  primary_abstract_class
 end

It's not a big deal but I'd like to have my app fully upgraded, almost like it was created using the rails new command from the latest Rails.

Overall, while both approaches can get the job done, I find that generating a new app and carefully comparing the changes is a more reliable strategy for upgrading a Rails app.

O ChatGPT é um modelo de linguagem de grande porte treinado pela OpenAI com habilidades em conversar e responder perguntas de maneira natural e humana.

Fiquei impressionado com a capacidade do ChatGPT em gerar respostas precisas e coerentes e estou animado para compartilhar esse conteúdo com vocês.

Espero que vocês gostem e se divirtam assistindo ao vídeo tanto quanto eu me diverti produzindo:

Depois de tanto tempo sem eventos presenciais, eu gostaria de compartilhar com vocês que a RubyConf+ 2022 será presencial e online!

Confesso que eu sinto muita falta desse tipo de evento. Sempre curti muito rever os amigos, assistir as apresentações, almoçar com a galera, conhecer gente nova (networking!) e claro, ir para o happy hour depois! 🍻😄

Por ser um "DEV Parceiro" do evento, tenho um cupom de desconto para vocês, que é válido tanto para o evento presencial, quanto online. É só usar o cupom LUCASCATON_25 para ganhar 25% de desconto ou clicar em um dos links abaixo:

• Desconto para o evento presencial 🛣🍔🥤
• Desconto para o evento online 👨‍💻📺👩‍💻

Outra novidade!

Vou aproveitar para compartilhar uma decisão que tomei depois de conversar muito com o meu sócio Mauricio. Há uns meses, nós decidimos que era hora de parar de vender o curso de Ruby/Rails e se focar nos outros cursos, principalmente no de React.

O principal motivo é que o curso não foi gravado usando a última versão do Rails e apesar de pouca coisa ter mudado na prática, não fazia mais sentido continuar vendendo um curso o qual não usa a última versão. Porém aconteceu algo que a gente não esperava: a procura não só não parou como aumentou! 😅

Através de conversas com interessados, ficamos sabendo que muitas empresas ainda têm vários projetos (a maioria, eu diria!) usando Rails 6 ou versões mais antigas, então reconsideramos já que tanta gente poderia se beneficiar com todo o conteúdo do curso (eu inclusive ao vender mais, hehe).

Isso significa que vamos reabrir as inscrições ainda essa semana, para ajudar quem quer chegar na RubyConf já com uma boa base! Cadastre seu email na lista de espera para não perder! 😉

Next.js é tão sensacional que meio que virou meu framework padrão para novos projetos. Além disso, eu também migrei vários outros projetos, include esse site/blog que você está lendo nesse exato momento, conforme documentei aqui.

Nesse tutorial, vamos desenvolver um blog com Next.js, React e Tailwind CSS. Os posts serão escritos em Markdown e convertidos para HTML no final.

E aí, bora codar? 😉

Criando e configurando o projeto

Antes de continuar, você precisa ter o Node.js e o Yarn instalados.

Abra o terminal e rode o seguinte comando para criar o projeto:

yarn create next-app -e with-tailwindcss blog

Agora, acesse o diretório do projeto e adicione as bibliotecas que vamos precisar:

cd blog
yarn add react-markdown gray-matter @tailwindcss/typography

Essas bibliotecas servem para:

• React Markdown: converter Markdown para HTML.
• Gray Matter: interpretar front matters (veremos mais sobre isso a seguir).
• Plugin "typography" do Tailwind CSS: estilização básica decente para artigos/posts.

Escrevendo o post inicial

Crie um diretório posts na raiz do projeto e dentro, crie um arquivo chamado hello-world.md com o conteúdo que você desejar:

---
title: "Hello World"
date: "07/12/2021"
---
Olá mundo!
**Texto em negrito** e _texto em itálico_.
- Lista
- com
- vários
- items

O que é "Front Matter"?

O bloco no começo de arquivos markdowns, entre os traços (---) é o que chamamos de "Front Matter" e é onde geralmente definimos metadados do post. Esse bloco precisa necessariamente estar no começo do arquivo e precisa usar uma sintaxe YAML válida.

title: "Hello World"
date: "07/12/2021"

Preparando a página inicial

Vamos mover o componente <Head> do arquivo pages/index.js para pages/_app.js e renomear o conteúdo da tag <title>:

pages/_app.js

import Head from "next/head";
import "tailwindcss/tailwind.css";
function MyApp({ Component, pageProps }) {
  return (
    <>
      <Head>
        <title>Meu blog</title>
        <link rel="icon" href="https://www.lucascaton.com/favicon.ico" />
      </Head>
      <Component {...pageProps} />
    </>
  );
}
export default MyApp;

Depois vamos deixar apenas um título Posts na página inicial:

pages/index.js

const Blog = () => {
  return <h1>Posts</h1>;
};
export default Blog;

Conferindo se está tudo bem até aqui

Vamos rodar o servidor para ver se está tudo certo até agora. No terminal, rode:

yarn dev

Abra o navegador e acesse localhost:3000. Você deve ver algo assim:

Criando e estilizando o cabeçalho

Vamos adicionar as tags <header> e <main> ao arquivo pages/_app.js com algumas classes do Tailwind CSS:

 import Head from "next/head";
+import Link from "next/link";
+
 import "tailwindcss/tailwind.css";
 function MyApp({ Component, pageProps }) {
@@ -9,7 +11,17 @@ function MyApp({ Component, pageProps }) {
         <link rel="icon" href="https://www.lucascaton.com/favicon.ico" />
       </Head>
-      <Component {...pageProps} />
+      <header className="py-10 bg-gradient-to-r from-green-400 to-blue-500 text-center">
+        <Link href="/">
+          <a>
+            <h2 className="text-5xl font-bold text-white">Meu blog</h2>
+          </a>
+        </Link>
+      </header>
+
+      <main className="my-6 mx-auto p-6 bg-white sm:shadow-lg rounded prose lg:prose-xl">
+        <Component {...pageProps} />
+      </main>
     </>
   );
 }

Personalizando a tipografia do Tailwind CSS

Vamos extender alguns comportamentos padrões de tipografia do Tailwind CSS e carregar o plugin oficial @tailwindcss/typography.

Para isso, abra o arquivo tailwind.config.js e adicione isso:

   darkMode: false, // or 'media' or 'class'
   theme: {
-    extend: {},
+    extend: {
+      typography: {
+        DEFAULT: {
+          css: {
+            a: {
+              color: "#3182ce",
+              "&:hover": {
+                color: "#2c5282",
+              },
+            },
+          },
+        },
+      },
+    },
   },
   variants: {
     extend: {},
   },
-  plugins: [],
+  plugins: [require("@tailwindcss/typography")],
 };

Adicionando classes CSS na tag <body>

Para fazer isso, precisamos criar um arquivo pages/_document.js com o seguinte conteúdo:

import Document, { Html, Head, Main, NextScript } from "next/document";
class MyDocument extends Document {
  static async getInitialProps(ctx) {
    const initialProps = await Document.getInitialProps(ctx);
    return { ...initialProps };
  }
  render() {
    return (
      <Html>
        <Head />
        <body className="bg-white sm:bg-gray-50">
          <Main />
          <NextScript />
        </body>
      </Html>
    );
  }
}
export default MyDocument;

Repare que eu adicionei as classes bg-white e sm:bg-gray-50 na tag <body>.

Lendo o conteúdo dos posts

Crie um arquivo lib/posts.js que será responsável por ler os arquivos Markdown e retornar uma lista de posts:

import { promises as fs } from "fs";
import path from "path";
import matter from "gray-matter";
const getPosts = async () => {
  const postsDirectory = path.join(process.cwd(), "posts");
  const filenames = await fs.readdir(postsDirectory);
  return await Promise.all(
    filenames.map(async (filename) => {
      const filePath = path.join(postsDirectory, filename);
      const fileContents = await fs.readFile(filePath, "utf8");
      const document = matter(fileContents);
      return {
        slug: filename.replace(/\.md$/, ""),
        title: document.data.title,
        date: document.data.date,
        markdown: document.content,
      };
    })
  );
};
export default getPosts;

Cada post é representado por um objeto com as seguintes chaves:

• slug: Representação do post que pode ser usada na URL. Para isso, vamos usar o nome do arquivo sem sua extensão (.md).
• title: Metadado definido no front matter
• date: Metadado definido no front matter
• markdown: Conteúdo principal do arquivo Markdown

Repare que estamos usando a biblioteca gray-matter para ler os metadados definidos no front matter de cada post.

Adicionando os posts à página inicial

Vamos importar a função getPosts do arquivo que acabamos de criar na página inicial, ou seja, no arquivo pages/index.js e fazer um loop para exibir links e títulos de cada um dos posts:

import Link from "next/link";
import getPosts from "../lib/posts";
const Blog = ({ posts }) => {
  return (
    <>
      <h1>Posts</h1>
      <ul>
        {posts.map(({ slug, title }) => (
          <li key={slug}>
            <Link href={`/${slug}`}>
              <a>{title}</a>
            </Link>
          </li>
        ))}
      </ul>
    </>
  );
};
export async function getStaticProps() {
  return {
    props: {
      posts: await getPosts(),
    },
  };
}
export default Blog;

Vamos ver no navegador como nosso blog está ficando:

Massa!

Criando as páginas dos posts com rotas dinâmicas

Ao tentar clicar no link do post Hello World que vemos da página acima, um erro 404 (página não encontrada) será mostrada. Isso é esperado, afinal, ainda não criamos essa página 🙃

Bora criá-la, então. Como queremos um mesmo template para os posts, mas com rotas dinâmicas (baseadas no nome de seus arquivos), vamos criar e nomear o arquivo dos posts com colchetes: pages/[slug].js.

Seu conteúdo pode ser algo mais ou menos assim:

import getPosts from "../lib/posts";
const Post = ({ title, date, markdown }) => (
  <article>
    <h1>{title}</h1>
    <time className="font-extralight tracking-wider text-gray-500">{date}</time>
    {markdown}
  </article>
);
export const getStaticPaths = async () => {
  const posts = await getPosts();
  return {
    paths: posts.map((post) => `/${post.slug}`),
    fallback: false,
  };
};
export const getStaticProps = async ({ params: { slug } }) => {
  const posts = await getPosts();
  const post = posts.find((post) => post.slug === slug);
  return { props: post };
};
export default Post;

Agora vamos verificar como ficou no navegador...

Ok, está ficando legal, mas ainda falta converter o Markdown.

Convertendo o Markdown para HTML

Vamos usar a bilioteca ReactMarkdown para fazer isso. Atualize o arquivo pages/[slug].js para:

+import ReactMarkdown from "react-markdown";
+
 import getPosts from "../lib/posts";
 const Post = ({ title, date, markdown }) => (
   <article>
     <h1>{title}</h1>
     <time className="font-extralight tracking-wider text-gray-500">{date}</time>
-    {markdown}
+    <ReactMarkdown>{markdown}</ReactMarkdown>
   </article>
 );

Vamos testar novamente:

Ah, bem melhor!

Adicionando um favicon

Para finalizar, substitua o favicon da pasta public/.

Se você não tiver um, pode usar esse:

Fique a vontade também para remover o arquivo public/vercel.svg, que atualmente não tem utilidade nenhuma.

Resultado final 🎉

Vídeo que originou esse post

Repositório no GitHub

O código do blog desenvolvido nesse tutorial está publicado integralmente no GitHub, caso você precise por qualquer motivo! 😉

O que achou?

Me conte nos comentários abaixo!

Nos dias 29 e 30 de julho acontecerá a RubyConf Brasil 2021 - Online. Serão dois dias para você imergir no mundo da tecnologia que vai muito além da linguagem de programação Ruby.

Estamos empenhados junto com a nossa parceira NewRiide.com em trazer as melhores oportunidades para você ingressar e evoluir no mundo da tecnologia e desenvolvimento de software.

A NewRiide apoia o evento e negociou com a Locaweb um desconto de 25% na aquisição dos ingressos para RubyConf, basta acessar o link abaixo para adquirir o seu ingresso já com desconto:

👉 INGRESSO COM 25% DESCONTO

Aproveite mais esta oportunidade para ingressar no mundo do desenvolvimento de software e ter contato com desenvolvedores de diversas empresas renomadas que estão fazendo a diferença no mercado de tecnologia!

Criei esse site/blog em 2009 usando Wordpress. Depois migrei para Enki mas acabei voltando para o Wordpress. Parece que foi ontem que refiz tudo do zero, mas na realidade foi em 2017, quando comecei a usar Jekyll para gerar um site estático pela primeira vez.

Por que mudar novamente?

Jekyll me serviu bem, mas desde o ano passado eu notei que precisava de algo ainda mais flexível e com melhor performance já que gerar o site (aka. processo de build) e também renderizar páginas em ambiente de desenvolvimento estava deixando a desejar. Aproveitei que estava estudando Next.js e decidi usá-lo no site novo para ganhar experiência na prática. A migração foi bastante lenta, pois eu não tinha pressa e queria experimentar combinações de bibliotecas e soluções diferentes, que vou detalhar mais na sessão "Stack" abaixo.

Processo

Em vez de reusar o mesmo repositório, criei um novinho em folha. Eis o primeiro commit, que aconteceu há mais de um ano:

commit 7fdcbe4
Author: Lucas Caton
Date:   Thu Jun 11 17:21:21 2020 +1000
    Initial commit from Create Next App

Depois de alguns meses, o site estava longe de estar finalizado, porém estava bom o suficiente. Como eu sempre sigo a idéia de que feito é melhor que perfeito, decidi colocar no ar, sem muito alarde. Só agora porém, meses depois, parei para escrever um post e contar essa história.

O quanto "pronto" eu esperei para colocar no ar?

Só nesse repositório novo, já foram 441 commits:

❯ git shortlog -sn
   441  Lucas Caton

Mas ainda tem muitas coisas para arrumar. Você provavelmente vai encontrar algumas partes meio feias, inacabadas ou até mesmo inexistes no site novo (não tem mais uma busca, por exemplo). Aos poucos, eu farei melhorias incrementais para re-adicionar o que falta e/ou corrigir o que precisa.

Valeu a pena?

Tudo saiu melhor que o planejado e talvez eu escreva posts separados no futuro para contar os vários motivos. De forma resumida, a flexibilidade e performance que o Next.js e o React têm, mudaram o jogo para mim. Falando nisso, deixa eu contar quais bibliotecas e ferramentas exatamente que o site novo está usando:

Stack

• React.js (https://reactjs.org/) & Next.js (https://nextjs.org/).
  • Aproveite para conhecer meu curso! 😉
• Posts em Markdown - um dos pré-requisitos que eu mesmo defini é que eu não queria mudar absolutamente nada nos arquivos dos posts. Até mesmo o front matter eu mantive o mesmo que usava com Jekyll. Só que agora são as bibliotecas react-markdown e gray-matter que convertem tudo.
• TailwindCSS (https://tailwindcss.com/) - eu tenho usado esse framework CSS na maioria dos meus projetos e continuo achando ele sensacional. Se você não conhece, vale a pena dar uma olhada no canal deles no YouTube. Veja mais detalhes na sessão "Layout próprio" abaixo.
• Styled components - https://styled-components.com/.
• TypeScript (https://www.typescriptlang.org/) & TypeScript Coverage Report (https://github.com/alexcanessa/typescript-coverage-report).
• React Highlight (https://react-highlight.neostack.com/) - suporte para syntax highlighting em aplicações React.
• Disqus (https://disqus.com/) - já usava antes e continuo usando esse serviço para permitir comentários nos posts.
• ES Lint (https://eslint.org/) & Prettier (https://prettier.io/) - para manter os estilos e qualidade do código.
• Jest - https://jestjs.io/.

Mudei do GitHub Pages para a Vercel

Migrei para a Vercel por 3 motivos:

• Melhor integração com o Next.js
• Deploys mais simples
• Plano gratuito bastante generoso

O que eu NÃO estou usando

• Biblioteca com componentes prontos, exemplo: Bootstrap, Bulma, etc.
• Pré-processador CSS, exemplo: SASS, SCSS, Slim, nem nenhum outro. Apenas Tailwind e CSS puro.

Layout próprio

Eu criei a UI de todas as páginas, menus, componentes, etc. Em todas as versões anteriores, eu usava templates prontos, mas resolvi eu mesmo criar um dessa vez. Ainda estou atualizando/melhorando várias partes que precisam de um pouco mais de amor :)

Feedback

Para concluir, eu adoraria saber o que você achou do site novo. Me conte nos comentários abaixo! 😉

Webinário apresentado em 30/01/2019.

Webinário apresentado em 06/07/2018.

Webinário apresentado em 20/12/2017.

Seguindo com a 2ª temporada do meu podcast, dessa vez o entrevistado foi o Cássio Marques, que é programador, amante de música, mora na Inglaterra e foi o meu mentor técnico, a pessoa que me apresentou boas práticas de programação e quem me mostrou o "caminho das pedras" de uma carreira de sucesso na área.

Assista a entrevista completa no YouTube:

Você também pode escutar a entrevista através do seu player de podcast preferido; é só buscar por Lucas Caton no app de podcast ou conferir o link direto nessa página.

Seguindo com a 2ª temporada do meu podcast, dessa vez o entrevistado foi Tiago Menegaz, que é programador Ruby, curte/manja de Docker e Kubernetes, morou e estudou na Austrália e atualmente trabalha para uma startup americana!

Assista a entrevista completa no YouTube:

Você também pode escutar a entrevista através do seu player de podcast preferido; é só buscar por Lucas Caton no app de podcast ou conferir o link direto nessa página.

Abaixo você encontra os comandos executados no vídeo:

Site do Homebrew: https://brew.sh/

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Site do ASDF: https://asdf-vm.com/

brew install asdf
echo -e "\n. $(brew --prefix asdf)/asdf.sh" >> ~/.zshrc
source ~/.zshrc
asdf --version

Site do Ruby: https://www.ruby-lang.org/pt/

asdf plugin-add ruby
asdf install ruby 3.4.2
asdf global ruby 3.4.2
ruby -v

Site do Node.js: https://nodejs.org/pt-br/

asdf plugin-add nodejs
asdf install nodejs 22.14.0
asdf global nodejs 22.14.0
node -v

Site do Rails: https://rubyonrails.org/

gem install rails
rails -v

Site do Yarn: https://yarnpkg.com/

npm install --global yarn
yarn -v

Criando um projeto Rails para garantir que tudo está funcionando:

rails new todo
cd todo
rails s

Abra o navegador e acesse a página localhost:3000.

Seguindo com a 2ª temporada do meu podcast, dessa vez o entrevistado foi Fabio Akita, um amigo de longa data e um profissional que admiro muito.

Assista a entrevista completa no YouTube:

Você também pode escutar a entrevista através do seu player de podcast preferido; é só buscar por Lucas Caton no app de podcast ou conferir o link direto nessa página.

Fala meus caros! 👋

No começo desse ano (também conhecido como "mês passado"), eu estreei a 2ª temporada do meu podcast, no qual estou entrevistando profissionais que trabalham com tecnologia (a maioria programadores) que eu admiro.

Toda quinta-feira tem um episódio novo, com insights de quem está no "campo de batalha", trabalhando na área.

Os 5 primeiros episódios já estão no ar e você pode escutar através do seu player de podcast preferido; é só buscar por Lucas Caton no app de podcast ou conferir o link direto nessa página.

Se preferir, você também pode assistir pelo YouTube:

Episódio 01 - WILL ROSA

CURIOSO, AUTODIDATA, COMPARTILHADOR DE CONTEÚDO E LEITOR DE MANUAIS

Episódio 02 - THIAGO ALESSIO

PROGRAMADOR (INCLUSIVE DE ATARI), SYSADMIN E QUASE ALEMÃO

Episódio 03 - VAL SILVA

ANALISTA DE SISTEMAS, GUITARRISTA, DOUTORANDO EM COMPUTAÇÃO E HUMILDÃO

Episódio 04 - FERNANDO SOUSA

EMPREENDEDOR, RANGER E DESENVOLVEDOR DESDE OS 10 ANOS

Episódio 05 - MAURICIO DE AMORIM

ESTAGIÁRIO AOS 36, CORREDOR, EMPATIA MAN, O CARA DOS BASTIDORES

E é só o começo, toda semana tem episódio novo! 😉

Abaixo você encontra os comandos executados no vídeo:

sudo apt update
sudo apt install build-essential git automake autoconf libreadline-dev libncurses-dev libssl-dev libyaml-dev libxslt-dev libffi-dev libtool unixodbc-dev unzip curl zlib1g-dev sqlite3 libsqlite3-dev

Site do ASDF: https://asdf-vm.com/

git clone https://github.com/asdf-vm/asdf.git ~/.asdf
cd ~/.asdf
git checkout "$(git describe --abbrev=0 --tags)"
echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.bashrc
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc
source ~/.bashrc
asdf --version

Site do Ruby: https://www.ruby-lang.org/pt/

asdf plugin-add ruby
asdf install ruby 3.4.2
asdf global ruby 3.4.2
ruby -v

Site do Node.js: https://nodejs.org/pt-br/

asdf plugin-add nodejs
asdf install nodejs 22.14.0
asdf global nodejs 22.14.0
node -v

Site do Rails: https://rubyonrails.org/

gem install rails
rails -v

Site do Yarn: https://yarnpkg.com/

npm install --global yarn
yarn -v

Criando um projeto Rails para garantir que tudo está funcionando:

rails new todo
cd todo
rails s

Abra o navegador e acesse a página localhost:3000.

Nesse vídeo, eu vou destrinchar a teoria por traz dos frameworks/componentes do Rails na prática, com exemplos e tudo mais! 😉

Entenda o que é e como funciona o Active Record, Action View, Action Controller, Active Support, Action Mailer, Action Mailbox, Action Text, Active Job, Active Storage, Action Cable, etc.

Com esses conceitos fica mais fácil compreender como as coisas se encaixam para explorar novas soluções para suas aplicações.

Se curtir, não deixe de se inscrever no canal! 😉

Abaixo você encontra os comandos executados no vídeo:

No PowerShell:

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

No terminal do Ubuntu (WSL):

sudo apt update
sudo apt install build-essential git automake autoconf libreadline-dev libncurses-dev libssl-dev libyaml-dev libxslt-dev libffi-dev libtool unixodbc-dev unzip curl zlib1g-dev sqlite3 libsqlite3-dev

git clone https://github.com/asdf-vm/asdf.git ~/.asdf
cd ~/.asdf
git checkout "$(git describe --abbrev=0 --tags)"
echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.bashrc
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc
source ~/.bashrc
asdf --version

asdf plugin-add ruby
asdf install ruby 3.4.2
asdf global ruby 3.4.2
ruby -v

asdf plugin-add nodejs
asdf install nodejs 22.14.0
asdf global nodejs 22.14.0
node -v

gem install rails
rails -v

npm install --global yarn
yarn -v

Criando um projeto Rails para garantir que tudo está funcionando:

rails new todo
cd todo
rails s

Abra o navegador e acesse a página localhost:3000.

Esta é uma das perguntas que mais recebo. Para criar um contexto e responder da melhor forma, gravei e publiquei um vídeo no meu canal do YouTube:

Se curtir, não deixe de se inscrever no canal! 😉

Aprenda o básico de JavaScript (JS) através do mais recente vídeo que publiquei no meu canal do YouTube:

Abaixo você encontra os arquivos criados/utilizados no vídeo:

index.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Introdução à JS</title>
    <link rel="stylesheet" href="css/style.css">
  </head>
  <body>
    <main>
      <nav>
        [Alterar tema](#" id="theme-toggle)
      </nav>
      <article>
        <h1>The Matrix</h1>
        <h2>Cast</h2>
        <ul class='cast'></ul>
        <p>
          The Matrix is a 1999 science fiction action film[3][4] written and directed by the Wachowskis.[a] It stars Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, Hugo Weaving, and Joe Pantoliano and is the first installment in the Matrix franchise. It depicts a dystopian future in which humanity is unknowingly trapped inside a simulated reality, the Matrix, created by intelligent machines to distract humans while using their bodies as an energy source.[5] When computer programmer Thomas Anderson, under the hacker alias "Neo", uncovers the truth, he "is drawn into a rebellion against the machines"[5] along with other people who have been freed from the Matrix.
        </p>
        <p>
          The Matrix is an example of the cyberpunk subgenre of science fiction.[6] The Wachowskis' approach to action scenes was influenced by Japanese animation[7] and martial arts films, and the film's use of fight choreographers and wire fu techniques from Hong Kong action cinema influenced subsequent Hollywood action film productions. The film is known for popularizing a visual effect known as "bullet time", where the heightened perception of certain characters is represented by allowing the action within a shot to progress in slow-motion while the camera appears to move through the scene at normal speed, allowing the sped-up movements of certain characters to be perceived normally. While some critics have praised the film for its handling of difficult subjects, others have said the deeper themes are largely overshadowed by its action scenes.
        </p>
      </article>
    </main>
    <script src="js/app.js"></script>
  </body>
</html>

css/style.css

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}
body {
  background-color: #f5f5f5;
}
main {
  max-width: 500px;
  min-height: 100vh;
  margin: auto;
  padding: 1rem 2rem;
  font-family: sans-serif;
  background-color: white;
  color: #333;
}
article h1 {
  margin: 1rem 0;
  font-size: 3rem;
}
article p {
  font-size: 1.4rem;
  margin: 2rem 0;
}
nav {
  display: flex;
  flex-direction: row-reverse;
}
#theme-toggle {
  text-decoration: none;
  padding: 0.25rem 0.5rem;
  border-radius: 5px;
  background-color: #eee;
  color: #333;
}
ul {
  margin: 1rem 0 0 3rem;
}
/* Dark theme */
body.dark {
  background-color: #222;
}
body.dark main {
  background-color: #444;
  color: #eee;
}
body.dark #theme-toggle {
  background-color: #777;
  color: #ddd;
}

js/app.js

document.querySelector('#theme-toggle').addEventListener('click', (event) => {
  event.preventDefault();
  toggleTheme();
});
function toggleTheme() {
  document.body.classList.toggle('dark');
}

const cast = [
  'Keanu Reeves',
  'Carrie-Anne Moss',
  'Laurence Fishburne',
  'Hugo Weaving'
];
const castList = document.querySelector('.cast');
cast.forEach(person => {
  const item = document.createElement("li");
  const personName = document.createTextNode(person);
  item.appendChild(personName);
  castList.appendChild(item);
  // P.S. Existem formas melhores de fazer ↑ isso,
  // usando um framework tipo React por exemplo :)
});

document.querySelector('main').innerHTML = '';
fetch('https://api.github.com/users/lucascaton/repos?per_page=100')
  .then(response => response.json())
  .then(repos => repos.forEach(repo => {
    let item = document.createElement("li");
    var repoName = document.createTextNode(repo.name);
    item.appendChild(repoName);
    document.querySelector('main').appendChild(item);
  }));

Escrevi abaixo alguns conselhos para te fazer pensar em como você quer levar sua vida profissional nesse ano que acabou de começar. Em vários trechos, eu "linkei" artigos, vídeos ou referências relevantes.

Se te incomodar o tom "tapa na cara" do post, fique tranquilo, não é nada pessoal. Mas é para te ajudar a acordar se você estiver precisando :)

1. Faça o seu perfil do GitHub ficar animal

Crie projetos e os deixe públicos. Contribua com projetos open-source, nem que seja só atualizando a documentação. Empresas gostam de perfis interessantes e atualmente isso conta mais que CV. Escrever sobre tecnologia também ajuda!

2. Defina o seu propósito maior

Reflita sua motivação para quer chegar onde você planeja chegar. E não deixe de ser consistente!

3. Pare de jogar ou assistir coisas inúteis

PS4, Netflix e Porta dos Fundos são ótimos, mas estão cagando para o seu futuro. A única pessoa que realmente se importa contigo é você mesmo.

4. Crie um projeto pessoal para ser o seu playground

Não pense em ganhar dinheiro com ele. Comece com algo básico se você for iniciante, mas saiba dar o próximo passo para não ficar parado no tempo. Teste tecnologias diferentes. Envolva back-end e front-end. Crie uma API e um app mobile (ou uma PWA) para consumi-la. Identifique no que você é bom e no que precisa melhorar!

5. Pare de reclamar que não tem tempo

O tempo é igual para todos. A diferença é a prioridade que damos para as coisas. Manter-se ocupado não é ser produtivo. Aprenda a dizer não! Libere sua agenda, em vez de lotar com coisas que não são importantes. Algo que também pode ajudar com isso é começar a trabalhar remotamente!

6. Faça entrevistas de emprego

Só assim você conseguirá o seu primeiro emprego na área de tecnologia. Corra atrás de trabalhar com o que você quer. Não espere uma empresa te convidar para trabalhar lá, isso não vai acontecer do nada. Você não é iniciante demais. Você não é velho demais. Você não é diferente de ninguém. Chega de desculpas!

O melhor dia para fazer isso é um ano atrás. O segundo melhor é hoje.

Depois que conseguir, dê o seu melhor!

7. Saia do Facebook

Não precisa deletar sua conta ou o app, só pare de abrir a cada 30 minutos, porque quase nada que está lá vai te levar para o seu próximo nível.

Dica: troque o tempo gasto lá por podcasts. Já conhece o meu?

8. Aprenda algo novo

Aprenda a colocar um servidor e o seu projeto no ar. Aprenda CSS Grid. Aprenda React. Aprenda GraphQL. Aprenda Rust. Aprenda Flutter.

Mas faça de forma consciente, escolha o que vai agregar ou te trazer benefícios no curto/médio prazo. É importante sair da sua zona de conforto, mas com os "pés no chão".

9. Você é a média das 5 pessoas que mais convive

Sendo assim, nada melhor que escolher bem os amigos que quer por perto. Não tenha medo de trocar seus amigos ou de começar uma vida nova. Daqui a alguns anos (ou em até menos tempo) você vai me agradecer.

10. Faça um projeto de graça antes de fazer seu primeiro freela

Mas sem desistir no meio, hein? Terminativa é tão importante quanto iniciativa.

11. Aprenda inglês

Esse talvez seja o item mais óbvio e se você não está estudando, já está ficando para trás. Você é programador e está codando em português? Você está fazendo errado. Simples assim. Tem sacadas que a gente demora para aprender, mas é melhor tarde do que nunca!

Excelente 2020 para você! 😉

• Documentação oficial do Dokku
• Dokku - Guia de instalação

Lista de todos os comandos utilizados no vídeo:

# Criar uma aplicação no Dokku
dokku apps:create bookaton
# Criar e "linkar" um banco de dados PostgreSQL
dokku plugin:install https://github.com/dokku/dokku-postgres.git postgres
dokku postgres:create bookaton_production # NOTA: você pode ignorar o sufixo `_production` se quiser
dokku postgres:link bookaton_production bookaton
dokku postgres:list
# Criar e "linkar" uma instância do Redis (Não rodei esses comandos no vídeo)
# dokku plugin:install https://github.com/dokku/dokku-redis.git redis
# dokku redis:create bookaton_production
# dokku redis:link bookaton_production bookaton
# dokku redis:list
# Definiar variáveis de ambiente
# (você pode passar várias de uma vez)
dokku config:set bookaton RAILS_MASTER_KEY=123456789
# Listar variáveis de ambiente
dokku config bookaton
# Adicionar buildpacks
dokku buildpacks:add bookaton https://github.com/heroku/heroku-buildpack-ruby.git
dokku buildpacks:add bookaton https://github.com/heroku/heroku-buildpack-nodejs.git
# dokku buildpacks:add bookaton \
#   https://github.com/heroku/heroku-buildpack-activestorage-preview.git
# Ver quais buildpacks foram adicionados
dokku buildpacks:list bookaton
# Associar nossa aplicação à um domínio
dokku domains:add bookaton bookaton.lucascaton.com.br
# Remover domínio que o Dokku adiciona por padrão
dokku domains:remove bookaton bookaton.dokku
# Ver todos os domínios
dokku domains:report bookaton

Na sua aplicação, não esqueça de criar os seguintes arquivos:

Procfile

web: bundle exec puma -C config/puma.rb
worker: bundle exec sidekiq -c 3
release: bin/rails db:migrate

DOKKU_SCALE

web=1
worker=1

Aí basta configurar o repositório remoto do Git (rode esse comando uma única vez):

git remote add dokku dokku@200.0.0.0:bookaton

E toda vez que você quiser fazer deploy, rode:

git push dokku

No servidor, vamos instalar o Let's Encrypt e criar nosso certificado SSL:

dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git
dokku config:set --no-restart bookaton DOKKU_LETSENCRYPT_EMAIL=fulano@exemplo.com
dokku letsencrypt:enable bookaton
# [Não mostrei isso no vídeo]
# Criar um cronjob para renovar o certificado a cada 2 meses
dokku letsencrypt:cron-job --add

Para rodar o console do Rails e/ou do PostgreSQL no servidor:

dokku run bookaton rails c
dokku run bookaton rails db

[Não mostrei isso no vídeo] Para acessar o container dentro do servidor:

dokku run bookaton sh

Por fim, para visualizar/acompanhar os logs, basta rodar:

dokku logs bookaton -t

Clientes do Dokku, para rodar os comandos diretamente da sua máquina em vez de ter que acessar o servidor:

http://dokku.viewdocs.io/dokku/community/clients/

• Site oficial do ASDF

Há um tempo atrás eu fiz uma pesquisa no meu canal do Telegram, perguntando que tipo de conteúdo queríam que eu produzisse. De longe, o que foi mais pedido foi JavaScript e específicamente React. De lá pra cá, eu venho estudando e também usando React, tanto em projetos pessoais como na empresa onde eu trabalho.

Por estes motivos, vou começar a produzir mais conteúdos sobre esse assunto! Eis abaixo o primeiro resultado dessa mudança: eu gravei um screencast mostrando como criar um jogo da velha usando React e React Hooks! 😃

Honestando falando, foi um dos vídeos mais divertidos que já fiz e que, ao mesmo tempo, também contém insights valiosos caso você queira trabalhar com essas tecnologias!

Abaixo você encontra o CSS utilizado no vídeo:

src/TicTacToe.css

:root {
  --O-color: #2196f3;
  --X-color: #f44336;
  --E-color: #777;
  --green: #4caf50;
}
* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}
body {
  display: grid;
  align-items: center;
  justify-content: center;
  font-family: sans-serif;
  height: 100vh;
  background-color: #eee;
}
.title {
  text-align: center;
  font-size: 3rem;
  color: #555;
  margin-bottom: 2rem;
}
.board {
  display: grid;
  grid-template-columns: repeat(3, 240px);
  grid-template-rows: repeat(3, 200px);
  gap: 1rem;
}
.board.game-over {
  opacity: 0.8;
}
.cell {
  display: grid;
  align-items: center;
  justify-content: center;
  background-color: white;
  border-radius: 5px;
  font-size: 3rem;
  font-weight: bold;
  color: #00000066;
  cursor: pointer;
}
.cell:not(.O):not(.X):hover {
  box-shadow:
    0 20px 25px -5px rgba(0, 0, 0, 0.1),
    0 10px 10px -5px rgba(0, 0, 0, 0.04);
}
.cell.O,
.cell.X,
.game-over .cell {
  cursor: not-allowed;
}
.cell.O {
  background-color: var(--O-color);
}
.cell.X {
  background-color: var(--X-color);
}
footer {
  text-align: center;
}
.winner-message {
  margin: 2rem;
}
.winner-message span.O {
  color: var(--O-color);
}
.winner-message span.X {
  color: var(--X-color);
}
.winner-message span.E {
  color: var(--E-color);
}
button {
  padding: 0.8rem 1.5rem;
  border: none;
  border-radius: 5px;
  box-shadow:
    0 1px 3px 0 rgba(0, 0, 0, 0.1),
    0 1px 2px 0 rgba(0, 0, 0, 0.06);
  background-color: var(--green);
  color: white;
  font-size: 1.2rem;
}

Me conte nos comentários o que achou do vídeo! 😃

CSS Grid é o sistema de layouts mais poderoso disponível para CSS.

Eu apresentei uma introdução ao assunto em uma LIVE no formato de tech-talk:

Arquivos demonstrados no vídeo acima:

index.html

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="stylesheet" href="style.css" />
  </head>
  <body>
    <main>
      <nav>
        <h3>Your Account</h3>
      </nav>
      <form class="sign-in-form">
        <h3>Sign in form</h3>
        <button>Sign in</button>
      </form>
      <article class="welcome-message">
        <h1>Welcome to Foobar</h1>
        <p>
          Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt
          ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
          ullamco laboris nisi ut aliquip ex ea commodo consequat.
        </p>
        <p>
          Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat
          nulla pariatur.
        </p>
      </article>
      <section class="market-sites">
        <h3>Other products</h3>
      </section>
      <footer>
        <ul>
          <li>Help Center</li>
          <li>About</li>
          <li>Privacy Policy</li>
        </ul>
      </footer>
    </main>
  </body>
</html>

style.css

* {
  margin: 0;
  padding: 1rem;
  border-radius: 5px;
}
body {
  font-family: sans-serif;
  background: whitesmoke;
  padding: 0;
}
main {
  max-width: 1000px;
  margin: 0 auto;
  padding: 0;
}
nav {
  background-color: black;
  color: white;
  grid-area: navbar;
}
.sign-in-form {
  background-color: white;
  color: #333;
  grid-area: sign-in-form;
}
.sign-in-form button {
  background-color: #85b54a;
  width: 100%;
  color: white;
  font-size: 1rem;
}
.welcome-message {
  grid-area: welcome;
}
.market-sites {
  background-color: #673ab7;
  color: white;
  grid-area: market-sites;
}
footer {
  border-top: 0.1rem solid #ccc;
  margin-top: 1rem;
  padding-top: 0;
  color: grey;
  text-align: center;
  grid-area: footer;
}
footer li {
  display: inline;
}
@media screen and (min-width: 700px) {
  main {
    display: grid;
    grid-template-columns: 1fr 1fr;
    grid-template-rows: 1fr auto auto 1fr;
    grid-gap: 10px;
    grid-template-areas:
      "navbar       navbar"
      "welcome      sign-in-form"
      "market-sites sign-in-form"
      "footer       footer";
  }
}

1º episódio da série "Programe Seu Futuro".

• Com Thiago Aléssio (aka. Xis)
• Co-host: Willian Molinari (aka. PotHix)

Há algumas semanas comecei a gravar lives de programação no meu canal do YouTube!

Todas as sextas-feiras às 20h

Se inscreva no meu canal do YouTube ou deixe o seu email no formulário desta página para ser lembrado sobre as próximas lives!

Te vejo lá!

Eu 2018, eu traduzi um guia chamado Developer Roadmap. Agora em 2019, fiz algo parecido, porém em vídeo, comentando cada um dos itens do guia:

Parte 1 (Introdução)

Parte 2 (Front-end)

Parte 3 (Back-end)

Parte 4 (Dev Ops)

Desde 2013, os desenvolvedores do Ruby mantém uma tradição de lançar uma nova versão da linguagem na época do Natal e nesse ano não foi diferente.

Como instalar/atualizar?

Antes de mais nada: sim, já é possível instalar e usar a nova versão!

Para instalar usando os gerenciadores mais populares:

RVM:

# Atualize o RVM:
$ rvm get stable
# Instale o Ruby 2.6:
$ rvm install 2.6.0

rbenv:

# Atualize a lista de versões do Ruby:
$ cd "$(rbenv root)"/plugins/ruby-build && git pull
# Instale o Ruby 2.6:
$ rbenv install 2.6.0

* * *

Vamos então dar uma olhada no que há de novo nessa nova versão!

Melhorias de performance

Essa versão tem algumas melhorias de performance, como:

• O método Proc#call está aproximadamente 1.4x mais rápido.
• Hashes de vida-útil curta consomem 7% menos memória.

Na RubyConf de 2015, Matz (criador do Ruby) anunciou o Ruby 3x3, que são os planos para fazer o Ruby 3.0 ficar 3x mais rápido. Essa versão provavelmente será lançada em 2020.

Uma das estratégias que viabilizará essa grande melhoria de performance é o JIT/MJIT, que está sendo incluída (como recurso experimental) na versão 2.6, conforme você confere na sessão abaixo:

JIT (Just-in-time)

Uma das funcionalidades mais notáveis da versão 2.6 do Ruby é que ela vem com uma implementação (experimental) de um compilador JIT (Just-in-time).

Segundo esse artigo do Guy Maliar (em uma tradução livre):

A idéia por trás de um compilador JIT é "inspencionar" o código em tempo de execução e tentar otimizar de forma mais inteligente o código atualmente em execução, que é o oposto do que acontece em um compilador AOT (Ahead Of Time compiler).

Essa é apenas a implementação inicial e ainda está um pouco instável.

Entretando, benchmarks iniciais mostram resultados muito bons. O emulador de NES "Optcarrot" rodou ~ 77% mais rápido, se comparado com o Ruby 2.5.3:

(Fonte) {: .text-right}

Outros benchmarks mostram resultados ainda mais significativos:

Bundler agora vem com o Ruby

Já faz um tempo que essa discussão começou e agora é oficial: a gem bundler vem por padrão com o Ruby!

Quem tiver curiosidade, esse é o Pull Request com tudo que foi alterado.

Essa mudança é especialmente bem-vinda pelo fato de ajudar iniciantes, já que elimina um passo na instalação do Ruby (e é com prazer que eu vou ter que regravar já regravei essa aula do meu curso 🙂).

O método #then

O método yield_self foi adicionado no Ruby 2.5. A novidade agora é que ele ganhou um alias: then.

Considere o seguinte exemplo de código de controller do Rails:

events = Event.upcoming
events = events.limit(params[:limit])          if params[:limit]
events = events.where(status: params[:status]) if params[:status]
events

Podemos reescrever o código acima usando yield_self ou then (já que o segundo é apenas um alias do primeiro):

Event.upcoming
  .yield_self { |events| params[:limit]  ? events.limit(params[:limit])          : events }
  .yield_self { |events| params[:status] ? events.where(status: params[:status]) : events }

Agora com then, que faz o código ficar um pouco mais legível:

Event.upcoming
  .then { |events| params[:limit]  ? events.limit(params[:limit])          : events }
  .then { |events| params[:status] ? events.where(status: params[:status]) : events }

Ranges infinitos

Agora podemos criar ranges sem especificar um valor final. Isso significa que podemos escrever códigos como:

array[1..]
# O código acima é identico à `array[1..-1]`

# Loop infinito que começa com índice 1
(1..).each { |index| ... }

array.zip(1..) { |elem, index| ... }
# O código acima é identico à `array.each.with_index(1) { }`

Novo método #filter para arrays (alias para o método #select)

Nós conhecemos bem o método select, mas em outras linguagens (como JavaScript, Java e PHP), ele é mais conhecido como filter. Se você, assim como eu, sempre quis que um alias fosse criado, esse momento chegou:

[:foo, :bar].filter { |x| x == :foo }
# => [:foo]

Métodos #union e #difference para arrays

Para quem lembra das aulas de matemática da escola ou para quem precisa trabalhar com união e diferença entre arrays, tenho uma boa notícia:

Dois métodos (#union e #difference) foram adicionados aos arrays.

Eis um exemplo:

[1, 1, 2, 2, 3, 3, 4, 5].difference([1, 2, 4])
# => [3, 3, 5]

['a', 'b', 'c'].union(['c', 'd', 'a'])
# => ['a', 'b', 'c', 'd']

['a'].union([['e', 'b'], ['a', 'c', 'b']])
# => ['a', 'e', 'b', 'c']

Veja também post oficial sobre o lançamento da versão 2.6.

Vou escrever sobre uma técnica relativamente simples para alcançar seus objetivos, seja conseguir um [novo] emprego, emagrecer, terminar um curso de programação, ou qualquer outra coisa.

Em 2012, eu fui com a minha noiva (atualmente esposa) visitar o meu pai e levamos um grande amigo meu. Na viagem de volta pra casa, viemos falando sobre casamento e comentamos que não tínhamos uma data para casar ainda. Afinal, por que a pressa para casar? Tanto eu quanto minha noiva estávamos tranquilos em relação à isso. Não é o tipo de situação na qual existe pressão por parte de um chefe, de um cliente, da família, etc.

Eram muitas coisas para planejar: documentação para o cartório, agendar o dia na igreja (além de preparar os enfeites), alugar o salão, comprar os comes e bebes da festa, fazer lista de convidados, escolher os padrinhos, planejar a lua de mel (que tem que coincidir com férias de trabalho) e muito mais - só que já casou sabe do que eu estou falando!

Sei que muitos casais enrolam justamente por isso :)

Nesse momento, ele nos deu um conselho caso a gente realmente quisesse casar: escolher uma data e não mudar por motivo algum. Essa seria a forma mais eficiente para conseguirmos preparar tudo. Ele ainda sugeriu 6 meses a contar daquele dia. Após um pouco de conversa, caiu a ficha de que ele tinha razão! Mesmo sabendo que era bastante coisa para fazer, 6 meses parecida um prazo razoável.

Começamos a ligar para nossa família e amigos mais chegados e perguntar se eles tinham compromisso naquela data. Depois de confirmar que todos poderiam, pedimos para que todos reservassem o dia 8 de dezembro de 2012 em seus calendários, pois iriamos nos casar! Nesse momento, não havia como fugir: teríamos que fazer o melhor possível durante aqueles 6 meses. No final deu tudo certo!

* * *

Venho utilizando essa técnica desde aquela época, para várias outras coisas da minha vida.

O mais importante é escolher uma data e mantê-la, principalmente quando somos perfeccionistas, pois naturalmente tendemos a enrolar o máximo que der. Isso vale para um casamento, para criar um blog, para projetos pessoais, para um trabalho de conclusão de faculdade/pós-graduação, enfim, para qualquer coisa!

Dependendo do seu foco e da sua disciplina, é capaz de você acabar desistindo de finalizar se você não tiver um prazo e não for avançando aos poucos.

Não basta ter a iniciativa é importante ter a "terminativa"!

Existe a chance, inclusive, de você criar inconscientemente uma desculpa para justificar o porquê você não chegou lá. Digamos que você queira começar a correr, mas no primeiro dia estava chovendo e você deixa para o dia seguinte. Aí no dia seguinte não vai porque não tinha o tênis apropriado. No terceiro, não vai porque a perna estava doendo um pouquinho. Tem até aquele ditado:

"Quem quer, arruma um jeito; quem não quer, arruma uma desculpa."

Inventar desculpas é uma das coisas mais eficiente que o ser humano é capaz; somos realmente muito bons nisso.

* * *

Suponhamos que você esteja criando um aplicativo/site ou ainda esteja abrindo uma empresa. Você obviamente vai precisar de um nome. Pode parecer uma tarefa simples, mas eu vejo pessoas demorando vários dias e muitas vezes até desistindo somente pelo fato de não terem conseguido o "nome ideal" (algo utópico, considerando que um nome é muito subjetivo).

A solução para esses casos é estabelecer um prazo e dar o melhor de si até tal prazo chegar. Faça uma lista de opções. Talvez você não goste de nenhum, mas vá anotando todos os que surgirem.

Quando a data chegar, escolha o melhor nome da lista e pronto!

Lembre-se que você fez o melhor que pôde, então não postergue essa decisão, mesmo que nenhum nome te agrade 100%. Mesmo que talvez você precise mudar no futuro, esse é o momento de seguir em frente com o que você conseguiu até agora.

Se você não fizer isso, você nunca vai entender que "feito é melhor que perfeito".

Quando estamos nos preparando para começar a programar um novo projeto, nem sempre é claro o que precisamos estudar primeiro.

É como preparar um bolo: tem que saber os ingredientes, a quantidade de cada coisa e também a ordem de preparo, ou seja, em que momento colocar cada item.

É sobre isso que eu falo nesse episódio, respondendo a dúvida enviada pelo Tharlles Té:

• Vídeo comentado nesse episódio: Como testar seu site ou app em diversos dispositivos.

• Se preferir, você também pode escutar esse episódio através do meu podcast.

• Ver outros episódios da série Café com Caton.

• Escreva sua opinião nos comentários abaixo, a discussão fica mais interessante com mais pessoas :)

Digamos que você esteja prestes a começar o desenvolvimento de um novo projeto. Enquanto que banco de dados como PostgreSQL e MySQL são escolhas tradicionais, quais são os casos que valem a pena considerar bancos NoSQL, como MongoDB?

É sobre isso que eu falo nesse episódio, respondendo a dúvida enviada pelo Ramakanta Dasa:

Escreva sua opinião nos comentários abaixo, a discussão fica mais interessante com mais pessoas! 🙂

Action Text é o mais novo framework do Rails e será adicionado oficialmente na versão 6.

Para entender as razões que levaram o Rails Core Team (e a equipe do Basecamp também, diga-se de passagem) a criá-lo e também aprender a utilizá-lo, assista ao vídeo abaixo:

• Action Text
• Trix (editor de texto rico JS criado pelo Basecamp)

Vídeos comentados no screencast acima:

• Aprenda Active Storage
• Live: o que já sabemos sobre o Rails 6

Comandos executados e arquivos alterados no vídeo:

Terminal

$ rails6 new action-text-demo --edge
$ cd action-text-demo
$ atom .

Gemfile

gem 'actiontext', github: 'rails/actiontext', require: 'action_text'
gem 'image_processing', '~> 1.2'

Terminal

$ rails action_text:install
$ rails db:migrate
$ rails g scaffold post title
$ rails db:migrate
$ rails s

config/routes.rb

root 'posts#index'

app/models/post.rb

class Post < ApplicationRecord
  has_rich_text :content
end

app/views/posts/_form.html.erb

<div class="field">
  <%= form.label :content %>
  <%= form.rich_text_area :content %>
</div>

app/controllers/posts_controller.rb

params.require(:post).permit(:title, :content)

app/views/posts/show.html.erb

<p><%= @post.content %></p>

Coloquem nos comentários abaixo o que vocês acharam da novidade e quem está ansioso pelo Rails 6! 😁

Busque por Lucas Caton no seu app de podcast favorito! 🙂

Ou clique aqui para acessar os links diretamente!

Existem situações nas quais não valem a pena desenvolver um software e nesse episódio eu vou falar sobre uma delas:

• Solução open-source (gem) de ecommerce feita em Ruby on Rails: Spree

• Plataforma de ecommerce (SAAS): Shopify

• Artigo "Desenvolvimento web em 2018"

• Assista o episódio anterior, no qual eu falo quais podcasts que eu escuto

Aqueles que leram e gostaram do meu artigo "Por que escutar Podcasts?", provavelmente também curtirão esse episódio da série "Café com Caton", no qual eu falo rapidamente sobre todos os podcasts que escuto atualmente (nacionais e gringos):

Assista o episódio anterior, no qual eu mostro como é meu estúdio e meu escritório.

O quarto episódio da série "Café com Caton" está no ar:

Artigo comentado no vídeo: Os desafios de trabalhar remotamente.

Assista o episódio anterior sobre Como construir uma carreira de referência.

O terceiro episódio da série "Café com Caton" está no ar:

Assista o episódio anterior sobre Como trabalhar com a linguagem que você ama.

O segundo episódio da série "Café com Caton" está no ar:

Assista o episódio anterior sobre Freelancer.

Olá meus caros!

O vídeo abaixo inaugura uma nova série chamada "Café com Caton". Seria impossível encontrar um nome mais clichê, eu sei! 😆

Espero que gostem:

Artigo comentado no vídeo: Os desafios de trabalhar remotamente.

Redescobri uma funcionalidade antiga, mas muito poderosa!

Já conhecia? Já usa? Comente abaixo :)

Olá meus caros!

Eu fui convidado pelo Fernando Sousa para gravar um podcast sobre refactoring. Esse é o primeiro episódio do podcast SouforceCast e ele já confirmou que vem mais por aí.

Escute também pelo:

• iTunes
• PocketCasts

Gravamos uma live analisando as alterações recentes no código-fonte com o objetivo de descobrir o que vem por aí no Rails 6:

Links comentados no vídeo:

• RailsConf 2018 - The Future of Rails 6
• Milestone "Rails 6"
• PR "Make Webpacker the default JavaScript compiler"

Abri meu coração e honestamente contei todos os meus planos:

Abaixo você encontrará um mini-curso que foi originalmente gravado para os alunos do meu curso). O objetivo é aprender o básico do Git (ferramenta) e do GitHub (plataforma).

Parte 1

Parte 2

Parte 3

Parte 4

Parte 5

Parte 6

Como instalar o Git

O processo de instalação do Git é simples, basta seguir as instruções do site oficial:

• Windows: git-scm.com/download/win
• Linux/Unix: git-scm.com/download/linux
• macOS (se você tiver Homebrew instalado): $ brew install git
• macOS (sem usar o Homebrew): git-scm.com/download/mac

Criar uma conta no GitHub:

https://github.com/join

Configurar seu nome de usuário no Git:

https://help.github.com/articles/setting-your-username-in-git/

Autenticar no GitHub:

https://help.github.com/articles/set-up-git/

Comandos usados nas videoaulas:

• git init
• git add README.md
• git status
• git commit -m "Create README.md"
• git log
• git diff README.md
• git revert [hash]
• git show
• git push
• git checkout -b nova_funcionalidade
• git branch
• git branch -a
• git checkout nova_funcionalidade
• git checkout master

Artigos relacionados:

• Como escrever mensagens de commits no Git
• Como eu migrei de chaves SSH para HTTPS no Git/GitHub (em inglês)

Você provavelmente conhece alguém que não consegue trabalhar na mesma empresa por mais de um ano. Eu conheço pessoas que, em menos tempo que isso, já estão doidas para procurar outro trabalho.

Comecei a trabalhar aos 16 anos, em 2004, como estagiário em uma secretaria da universidade onde eu estudava. Nessa época eu só programava na faculdade, por hobby e eventualmente fazendo um "freela" (trabalho freelance). Em 2007, comecei a finalmente trabalhar profissionalmente com programação, passando por várias empresas, grandes e pequenas.

Desde então, minha meta pessoal é não ficar menos que um ano trabalhando em uma empresa; meu tempo recorde foi 3 anos e meio. O fato é que não existe um tempo ideal para deixar o que já é certo para se aventurar em algo novo. São muitas variáveis em jogo e cada um sabe onde o calo aperta.

Se você ficar muito tempo na mesma empresa, pode ficar acomodado (a famigerada "zona de conforto"), pode se desapegar (às vezes inconscientemente) da sua carreira, deixar de aprender coisas novas e deixar de fazer novos colegas/amigos. Por outro lado, conquista estabilidade, autoridade, pode ser promovido e eventualmente tem um aumento de salário.

Já ficando pouco tempo em uma empresa, lhe dá a oportunidade de experimentar diferentes ambientes/culturas em diferentes companhias. Esta também poderia ser uma boa hora para negociar um salário melhor, caso você julgue justo. Mas também tem seus pontos negativos, por exemplo ganhar uma má reputação, ou mesmo não conseguir ter disciplina.

Trocar de empresa, ingenuamente, apenas para resolver um determinado problema, é negligenciar o fato de que a nova empresa terá problemas que a atual não tem.

Na minha perspectiva, a regra de ouro é: se você tem um problema, use bons argumentos para defender o que você acredita, mas também saiba ser humilde e admitir quando você estiver errado.

Mas o ponto principal desse artigo é: durante um emprego, você vai procurar dar o melhor de si e torcer para receber o melhor da empresa, certo? Abaixo você encontrará uma compilação de 3 atitudes que eu aprendi (e me policio para continuar tendo) para manter meu emprego atual de forma saudável.

1. Seja responsável

Esteja alinhado com os objetivos da empresa. Se você não concorda com o caminho que a empresa está seguindo, talvez fosse melhor nem ter começado lá.

Coisas pequenas contam: não se atrase para reuniões, mantenha pessoas atualizadas sobre problemas que estão acontecendo, não falte a toa com desculpas esfarrapadas, etc.

2. Seja amigável/respeitoso com colegas

“Todas as pessoas que você conhece estão enfrentando batalhas que você não sabe nada a respeito. Seja gentil. Sempre.”

Acho sensacional a frase acima (sem autor conhecido, pelo que eu pesquisei). Não julgue aquele colega que não está produtivo hoje, pois você não sabe se ele perdeu um ente querido, se ele está com dor ou problema de saúde, com problemas financeiros, ou tantas outras coisas possíveis. Seja empático; jamais desrespeite alguém.

Inevitavelmente, uma hora acontece algum desentendimento. Dependendo da gravidade, esfrie a cabeça, talvez seja melhor deixar pra tentar se entender mais tarde ou até no dia seguinte. Certos desentendimentos se resolvem simplesmente ao esperar a poeira baixar. Pode ser que nem era algo tão grave e no calor do momento você/ele/ela acabou exagerando.

3. Busque um emprego recompensador

Realisticamente falando, não adianta você fazer a sua parte e não ser recompensado. Esse provavelmente seria o cenário no qual você logo estaria procurando por outro emprego.

Busque um salário e uma posição justa para o momento presente de sua carreira. Peça feedback caso não receba, só assim você alinha suas expectativas com as da empresa. Seu trabalho deve ser saudável, em todos os aspectos, e nunca consumir toda sua energia física ou mental.

Trabalhar com o que você ama, faz com que você não gaste sua vida apenas trocando seu tempo/esforço pelo dinheiro no final do mês.

Tem como ser 100% feliz no seu emprego?

Mesmo que você encontre o trabalho perfeito, tudo sempre vai poder mudar. Colegas que você gosta pedem demissões, os diretores/gerentes mudam, seu salário aumenta menos do que o esperado, um novo funcionário é contratado e você não o suporta. Qualquer uma dessas mudanças contribuem para o desequilibro de um suposto emprego perfeito.

Empresa perfeita é utopia. Assim como você também não é um funcionário perfeito, nem nunca será.

Além disso, que graça teria uma vida sem desafios? 🙂

Algumas técnicas que uso até hoje para estudar inglês. Queria que alguém tivesse me ensinado isso 10 anos atrás! 🙂

Outros vídeos comentados no vídeo acima:

• 5 formas de aprender inglês de graça
• 8 motivos para programar em inglês

Há 3 dias, publiquei o primeiro vídeo desta série sobre Active Storage, o grande destaque do Rails 5.2; recomendo que você o veja antes de assistir este.

Nesse segundo vídeo, vou mostrar como configurar o Active Storage para:

• Fazer upload de arquivos para o AWS S3 (serviço de armazenamento de arquivos da Amazon);
• Usar o direct upload (envio de arquivos do navegador diretamente para o S3, sem passar pelo seu servidor);
• Fazer upload de vários arquivos de uma só vez.

• Assista a parte 1 dessa série
• Guia oficial do Active Storage

Arquivos alterados no vídeo:

config/storage.yml

# ...
amazon:
  service: S3
  access_key_id: xxxxxxxxxxxxxxxxxxxx
  secret_access_key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  region: xxxxxxxxxxxxxx
  bucket: xxxxxxx
# ...

config/environments/development.rb

# ...
config.active_storage.service = :amazon
# ...

app/assets/javascripts/application.js

// ...
//= require activestorage
// ...

app/models/post.rb

class Post < ApplicationRecord
  has_many_attached :images
end

app/controllers/posts_controller.rb

class PostsController < ApplicationController
  # ...
  def post_params
    params.require(:post).permit(:title, :body, images: [])
  end
end

app/views/posts/_form.html.erb

<!-- ... -->
<div class="field">
  <%= form.label :images %>
  <%= form.file_field :images, direct_upload: true, multiple: true %>
</div>
<!-- ... -->

app/views/posts/show.html.erb

<!-- ... -->
<% @post.images.each do |image| %>
  <%= image_tag image, style: 'width: 25%' %>
<% end %>
<!-- ... -->

app/assets/javascripts/direct_uploads.js

addEventListener("direct-upload:initialize", event => {
  const { target, detail } = event
  const { id, file } = detail
  target.insertAdjacentHTML("beforebegin", `
    <div id="direct-upload-${id}" class="direct-upload direct-upload--pending">
      <div id="direct-upload-progress-${id}" class="direct-upload__progress" style="width: 0%"></div>
      <span class="direct-upload__filename">${file.name}</span>
    </div>
  `)
})
addEventListener("direct-upload:start", event => {
  const { id } = event.detail
  const element = document.getElementById(`direct-upload-${id}`)
  element.classList.remove("direct-upload--pending")
})
addEventListener("direct-upload:progress", event => {
  const { id, progress } = event.detail
  const progressElement = document.getElementById(`direct-upload-progress-${id}`)
  progressElement.style.width = `${progress}%`
})
addEventListener("direct-upload:error", event => {
  event.preventDefault()
  const { id, error } = event.detail
  const element = document.getElementById(`direct-upload-${id}`)
  element.classList.add("direct-upload--error")
  element.setAttribute("title", error)
})
addEventListener("direct-upload:end", event => {
  const { id } = event.detail
  const element = document.getElementById(`direct-upload-${id}`)
  element.classList.add("direct-upload--complete")
})

app/assets/stylesheets/direct_uploads.css

.direct-upload {
  display: inline-block;
  position: relative;
  padding: 2px 4px;
  margin: 0 3px 3px 0;
  border: 1px solid rgba(0, 0, 0, 0.3);
  border-radius: 3px;
  font-size: 11px;
  line-height: 13px;
}
.direct-upload--pending {
  opacity: 0.6;
}
.direct-upload__progress {
  position: absolute;
  top: 0;
  left: 0;
  bottom: 0;
  opacity: 0.2;
  background: #0076ff;
  transition: width 120ms ease-out, opacity 60ms 60ms ease-in;
  transform: translate3d(0, 0, 0);
}
.direct-upload--complete .direct-upload__progress {
  opacity: 0.4;
}
.direct-upload--error {
  border-color: red;
}
input[type=file][data-direct-upload-url][disabled] {
  display: none;
}

Qualquer dúvida, mande nos comentários!

Há poucos dias, escrevi um artigo falando sobre as novidades do Rails 5.2, lançado recentemente.

Hoje gravei o primeiro vídeo de uma série demonstrando o funcionamento do Active Storage, o grande destaque do Rails 5.2:

Comandos executados no vídeo:

$ rails new active_storage_demo -d postgresql
$ cd active_storage_demo
$ atom .

$ rails generate scaffold post title body:text
$ rails db:create db:migrate

$ rails active_storage:install
$ rails db:migrate

$ rails s

Arquivos alterados no vídeo:

app/models/post.rb

class Post < ApplicationRecord
  has_one_attached :image
end

app/controllers/posts_controller.rb

class PostsController < ApplicationController
  # ...
  def post_params
    params.require(:post).permit(:title, :body, :image)
  end
end

app/views/posts/_form.html.erb

<%= form_with(model: post, local: true, multipart: true) do |form| %>
<!-- ... -->
<div class="field">
  <%= form.label :image %>
  <%= form.file_field :image %>
</div>
<!-- ... -->

app/views/posts/show.html.erb

<!-- ... -->
<%= image_tag @post.image %>
<!-- ... -->

A nova versão do Rails estava em beta (e rc¹) desde novembro do ano passado e agora está finalmente disponível para todos!

Foram quase 5000 commits (!) de 440 desenvolvedores, incluindo uma pequena contribuição deste que vos escreve.

Algumas novidades presentes nesta nova versão:

Active Storage

Sem dúvidas, o destaque da vez.

Desde quando foi lançado, o Ruby on Rails tem a premissa de ser um framework completo. O Active Storage foi adicionado ao Rails justamente para suprir uma funcionalidade a qual antes dependia de ferramentas de terceiros: upload de arquivos.

O framework traz suporte nativo aos serviços Amazon S3, Google Cloud Storage e Microsoft Azure Storage. A abordagem utilizada simplifica a tarefa e vem com recursos bacanas, como uploads direto para a nuvem (sem passar pelo seu servidor antes) e criação de thumbnails (miniaturas) de imagens, PDFs e até mesmo vídeos.

HTTP/2 Early Hints

Rails agora suporta uma das coisas mais legais do HTTP/2: poder instruir o servidor (como o Puma, que já suporta isso) para enviar antecipadamente arquivos JS e CSS. Isso se traduz em uma entrega mais rápida das páginas.

Boot 50% mais rápido

A gem Bootsnap reduz o tempo para subir um servidor em 50% e a partir do Rails 5.2, ela é adicionada por padrão em novos projetos. Você também pode usá-la em projetos usando versões antigas do Rails, basta adicioná-la ao seu Gemfile.

CSP (Content Security Policy)

Uma nova DSL² foi adicionada para configurar headers Content-Security-Policy, através da qual você poderá melhorar a segurança da sua aplicação.

Credentials

O arquivo de configuração secrets.yml foi criado no Rails 4.1 e transformado em um arquivo criptografado no Rails 5.1. Só que isso sempre foi meio confuso e alguns desenvolvedores não sabiam exatamente como (ou por qual motivo) usar, já que envvars³ resolviam o problema.

Para tentar resolver a confusão, agora foi criado o conceito de Credentials, descontinuando o suporte ao secret.yml (e sua versão criptografada).

Se isso resolverá mesmo o problema e cairá no gosto dos desenvolvedores, só o tempo dirá!

Suporte à gem Webpacker 3.0

Rails vem adotando soluções modernas para uso de JavaScript e manter uma boa integração com a gem Webpacker prova isso mais uma vez.

Redis Cache Store

Suporte nativo à cache usando Redis. Você encontra mais informações no pull request em que esta funcionalidade foi adicionada.

O que mais?

Obviamente, existe mais coisas que mudaram/evoluíram além dos destaques que listei acima. As notas de liberação contém algumas dessas mudanças menos relevantes, caso você esteja interessado.

Como atualizar?

Atualmente, atualizar um projeto para uma nova versão do Rails é uma tarefa relativamente tranquila (principalmente se comparada com as transições da versão 2 para a 3).

Eis o guia oficial para atualizar.

Rails 6?

Seguindo a tradição, essa será a última versão da série 5.*. O branch master do repositório do Rails já contém mudanças que só virão no Rails 6, o qual provavelmente veremos daqui a aproximadamente 1 ano e meio, se o histórico de lançamentos for similar aos que tivemos até hoje.

Desde o começo de 2017, eu venho trabalhando remotamente 100% do tempo. Atualmente isso é algo muito comum, não apenas em empresas de tecnologia. Quem mora em cidade grande e enfrenta trânsito ou corre risco de ser assaltado, sabe o quanto é vantajoso não precisar de sair de casa para trabalhar.

{: .img-description } Meu escritório atual (aka. home office)

As vantagens são muitas. Uma das que eu mais aprecio é poder ver cada progresso do meu filho (que está com 1 ano e meio). É uma forma de trocar o tempo gasto se locomovendo por tempo com sua família e/ou fazendo o que você gosta.

Outro ponto positivo é que a empresa nunca contratará alguém que more perto apenas por esse fato isolado; você trabalhará com as melhores pessoas que sua empresa encontrou sem ter a localização como fator limitante, como o tweet abaixo assertivamente ilustra:

[pic.twitter.com/DO3xDPBmIE](https://t.co/DO3xDPBmIE)

— Mark Dalgleish (@markdalgleish) [March 16, 2018](https://twitter.com/markdalgleish/status/974447526282539008?ref_src=twsrc%5Etfw)

Porém nem tudo são flores.

Desafios (e soluções)

Depois de 15 meses trabalhando em casa, identifiquei os desafios mais comuns e vou listá-los abaixo, junto com as soluções que encontrei. Caso eu tenha esquecido de algum, fique a vontade para mandar comentários no final deste artigo.

Comunicação

Existem várias ferramentas de chat como Slack e Rocket Chat (as quais podemos chamar de versões modernas do IRC), que ajudam a manter a equipe toda atualizada com o que está acontecendo na empresa, em projetos, etc.

Dizer no chat "bom dia" ou "vou ficar ausente por 15 minutos", não apenas mostra que você é educado, como também permite que todo mundo fique sabendo se você está ou não disponível. Também é útil ativar notificações para saber quando alguém precisa da sua atenção. Só cuidado para não deixá-las ligadas fora do horário de trabalho e virar um escravo.

Os bons e velhos Hangouts e Skype continuam excelentes para comunicação por voz/vídeo, incluindo compartilhamento de tela para demonstrar algum trabalho. Eu também gosto de gravar screencasts em formato GIF para compartilhar com o time.

Lugar privado para trabalhar

Quando eu me mudei para a casa onde moro hoje, procurei um lugar com um quarto extra, pois já estava trabalhando remotamente e sabia que seria importante.

Você até pode trabalhar da sala, cozinha ou do seu próprio quarto por um tempo (talvez pra fazer um teste e ver se trabalhar dessa forma funciona pra você?). Porém, se trabalhar remoto é algo que você planeja fazer por mais tempo, é importante ter um espaço privado para fazer reuniões, evitar distrações e se manter focado no trabalho (sem seu filho gritando do seu lado).

Disciplina

Chances são que a Netflix e o Playstation serão (discutivelmente) mais atrativos do que seu trabalho. Aqui a solução é ser maduro o suficiente pra entender que a empresa confia em você, portanto faça o que é esperado.

Top Traits of Successful Remote Workers
* Strong communicators 💬
* Motivated self-starters 💪
* Results-oriented 📈
* Collaborative 🙎🏽👨🏻‍💼
* Trustworthy 🤝
* Disciplined ✅
* Organized 🗂

— Doist (@doist) [26 de fevereiro de 2018](https://twitter.com/doist/status/968191855228850176?ref_src=twsrc%5Etfw)

Conexão boa/confiável com a internet

Isso provavelmente é essencial para a maioria das profissões. Apesar de eu nunca ter tido problemas com o meu provedor, eu sempre tenho uma conexão 4G de backup, caso algum problema aconteça.

Fuso-horário diferente

Trabalhar remoto significa que você (e seus colegas de trabalho) podem estar em qualquer parte do mundo. Se for o caso, nem todo mundo irá necessariamente trabalhar no mesmo horário. Consequentemente, é importante ter uma forma de deixar as pessoas saberem no que você está trabalhando e qual o status da sua tarefa atual. Ferramentas de gerenciamento de projetos como o KanbanFlow, Pivotal Tracker e Trello são ótimas para isso.

Você vê colegas/amigos menos frequentemente

Eu pensava que essa seria a pior parte. Mas o fato é que usando ferramentas de chat mencionadas acima, isso nunca foi um problema pra mim. Porém sair com amigos de vez em quando, mesmo que apenas para um café, ajuda a manter sua sanidade mental.

Ferramentas de trabalho

É importante ter um home office com tudo que você precisa para trabalhar: uma mesa/escrivaninha, uma cadeira e um notebook são essenciais (no meu caso; tudo depende do tipo de trabalho que você faz).

Outras coisas podem não ser essenciais, mas melhoram a qualidade do trabalho: ar condicionado, monitor externo, máquina de café e tudo que fizer a experiência de trabalhar de casa ser tão boa quanto a experiência de trabalhar em um escritório. Você não precisa comprar tudo de uma vez, principalmente se for sua primeira vez trabalhando de casa.

Saúde

Ao ficar em casa o dia todo, você pode desenvolver problemas de saúde. Evitar isso não é tão difícil:

• Faça exercícios (uma caminhada diária já é melhor que nada)
• Se alimente de forma saudável
• Tenha uma cadeira confortável
• Vá ao Google médico se notar que tem algo errado

Conclusão

Trabalhar de casa pode não ser pra todo mundo. Experimente alguns dias por semana primeiro, caso a empresa que você trabalhe permita isso.

Mas definitivamente vale a pena experimentar, as vantagens são muitas!

Resumo de como foi o evento através de stories do Instagram:

• Meu instagram: @lucascaton.com.br
• Site oficial do evento: www.rubyconf.org.au/2018
• Twitter oficial do evento: @rubyconf_au

Há um dito popular que diz: "números não mentem, mas mentirosos inventam números". O livro de 1954 de Darrell Huff "Como Mentir com Estatística" ensina truques simples para manipular a percepção das pessoas usando números. Em tempos de notícias falsas, a obra é um guia útil para identificar valores distorcidos. É uma das leituras favoritas de Bill Gates.

A estatística é importante para sintetizar de forma quantitativa o grande volume de dados produzido pelo mundo. Empresas de tecnologia medem tudo; o modelo de cobrança "pay as you go" adotado por provedores de serviço de computação em nuvem depende da coleta de métricas de uso de recursos de processamento, armazenamento e rede, por exemplo.

Se você está começando um projeto de tecnologia e precisa entender o ambiente onde ele está inserido para justificar certas escolhas, onde encontrar números confiáveis então?

Durante a faculdade, os professores sempre exigiam as fontes de informação em que baseavamos nossos trabalhos. Mesmo sendo um setor de mudanças rápidas, é possível obter pesquisas e relatórios relevantes para observar tendências baseadas em fatos na tecnologia.

"Technology Radar" da ThoughtWorks analisa técnicas, plataformas, ferramentas e linguagens & frameworks, indicando se vale a pena adotar ou não determinado item analisado.

O relatório "Internet Trends" da KPCB, umas das maiores firmas de capital de risco para tecnologia, oferece uma visão da adoção da Internet no mundo. Na apresentação de 2017, por exemplo, verifica-se que 68% dos usuários pesquisados reagem de forma positiva a anúncios em formato de vídeo que oferecem alguma recompensa (slide nº 26). Que tal usar essa estratégia no seu aplicativo?

As publicações do Cetic.br fornecem um panorâma da Internet no Brasil. A edição de 2016 da pesquisa TIC Domicílios destaca que mais de 40% dos usuários entrevistados acessam à Internet exclusivamente pelo celular. Tá aí uma boa razão para tornar seu site responsivo, não?

O portal "Think with Google" está cheio de dados e insights para marcas e agências. Em 2017, por exemplo, as buscas usando o termo "perto de mim" cresceram 75%, indicando que os usuários estão incorporando a geolocalização em seu comportamento de busca. Por que não enriquecer com metadados a página do seu negócio?

A série de estudos com executivos conduzida pela IBM e o site da consultoria McKinsey têm bastante conteúdo sobre gestão e estratégia para negócios digitais. A 19ª edição do estudo da IBM mostra que 34% das organizações pesquisadas estão investindo em inteligência artificial para resolver problemas complexos ou remodelar partes de seus negócios. Uma pesquisa da McKinsey revela que 80% das empresas consultadas planejam ter 10% ou mais de sua carga de trabalho rodando na nuvem pública ou dobrar seu uso da nuvem pública nos próximos 3 anos. Parece promissor estudar sobre IA e cloud computing, hein?

Por fim, um contraponto é necessário: "você não é o Google". O professor de ciência da computação Ozan Onay chama a atenção daqueles que seguem cegamente as práticas anunciadas por grandes empresas de tecnologia: a escala dos problemas enfrentados pelo Facebook, Amazon ou LinkedIn é bem maior que aquela dos problemas enfrentados pelas empresas onde trabalhamos. Por isso, entender o problema que precisamos resolver antes de usar uma solução de terceiro é crucial. "O que as estatísticas revelam é sugestivo, mas o que escondem é essencial".

Quais são as fontes de informação que você recomenda?

Gravei essa videoaula com o objetivo de ajudar quem quer aprender a criar uma página web do zero, sem ter conhecimentos prévios.

Clique aqui para ver a página que vamos criar.

É uma aula bem básica, porém com vários conceitos novos para quem está começando. Se você tiver qualquer dúvida, me mande através dos comentários, eu vou responder todos! :)

Arquivos criados no vídeo:

Você pode usar qualquer nome de arquivo que quiser, isso não interfere em nada. Apenas lembre-se de referenciar o nome dos arquivos corretamente no HTML ;)

index.html

<!DOCTYPE html>
<html lang='pt'>
  <head>
    <title>Super banda!</title>
    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato">
    <link rel="stylesheet" href="application.css">
  </head>
  <body>
    <main>
      <div class="logo">
        <img src="ruby.png" alt="Logo da banda">
      </div>
      <h1 class="band-name">Super banda!</h1>
      <h2 class="headline">A melhor banda do mundo</h2>
      <p>História da banda...  Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
      <hr>
      <div class="concerts">
        <h2>Shows</h2>
        <table>
          <thead>
            <tr>
              <th>Cidade</th>
              <th>Data</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td>São Paulo-SP</td>
              <td>01/10/2018</td>
            </tr>
            <tr>
              <td>Rio de Janeiro-RJ</td>
              <td>01/11/2018</td>
            </tr>
            <tr>
              <td>Belo Horizonte-MG</td>
              <td>01/12/2018</td>
            </tr>
            <tr>
              <td>Refice-PE</td>
              <td>01/01/2019</td>
            </tr>
          </tbody>
        </table>
      </div>
    </main>
  </body>
</html>

application.css

body {
  width: 95%;
  max-width: 800px;
  margin: auto;
  background: url(bg.jpg) center;
  font-family: 'Lato';
  line-height: 1.5;
  color: white;
}
main {
  background: #00000054;
  padding: 5px 40px;
  margin-top: 20px;
  border-radius: 10px;
}
.logo, .band-name, .headline {
  margin: 0;
  text-align: center;
}
.concerts {
  margin: 30px 0;
  text-align: center;
  width: 100%;
}
.concerts table {
  background: #cb3a3ab3;
  border-radius: 10px;
  padding: 10px;
  margin: 0 auto;
}

Imagens:

• bg.jpg
• ruby.png

Nesse vídeo, eu mostro como eu gravo screencasts (gravar a tela do meu computador), converto para o formato GIF, subo para a nuvem e compartilho a URL em menos de 30 segundos!

Ferramentas mostradas no vídeo:

• Droplr
• GIPHY Capture

Muitos alunos do meu curso me perguntam porque eu recomendo o PostgreSQL em vez do MySQL.

O PostgreSQL vem se provando cada vez mais uma solução melhor (não sou apenas eu quem está dizendo, boa parte da comunidade de desenvolvedores concorda com isso). Mas eu gostaria de listar aqui alguns dos motivos pelos quais eu particularmente prefiro ele.

1) Transações a nível de tabela

Transações são extremamente úteis para uma série de tarefas, como por exemplo executar queries perigosas (apagando registros por exemplo) diretamente no console do SGBD.

Ao programar um software, uma boa hora de usar transações é ao migrar o schema do seu banco, ou seja, criar, modificar, apagar tabelas, colunas, índices, etc.

O MySQL no entanto não oferece transações a nível de tabela. Por exemplo:

BEGIN;
CREATE TABLE `users` (`name` varchar(255));
ROLLBACK;

Ao rodar as queries acima, seria esperado que a tabela users fosse criada e então apagada, no entanto ela permanece.

Já no PostgreSQL:

BEGIN;
CREATE TABLE "users" ("name" character varying);
ROLLBACK;

Tudo funciona conforme o esperado e a tabela users é completamente removida.

2) Funcionalidades

• Full-text search - O suporte à busca full-text do PostgreSQL não é só melhor que a do MySQL como foi incluída muito tempo antes.
• UUID - Geração nativa de campos UUID é uma funcionalidade (até o momento) exclusiva do PostgreSQL, a qual pode inclusive ser usada como chave-primária. Mais informações na documentação oficial.

3) Encoding padrão

O tipo de codificação padrão do PostgreSQL é o UTF-8. Simples assim!

Já o padrão do MySQL é latin1, o qual simplesmente não é preparado para funcionar em qualquer canto do mundo (enquanto que o UTF-8 é) e também não aceita emojis. Além disso, você pode ter tabelas com diferentes encodings, o que na minha opinião é um tanto confuso.

4) Tipos de dados (colunas)

A maioria dos tipos de colunas são mais amigáveis e consistentes no PostgreSQL que no MySQL. Exemplo: um dado booleano é guardado como boolean no PostgreSQL e - por falta de algo mais apropriado - guardado como tinyint(1) no MySQL.

O tipo tinyint, a princípio, guarda um valor inteiro de 1 dígito. Para guardar um boleano nesse tipo de campo, usamos 1 ou 0, o que é popularmente conhecido como "gambiarra" :)

Outros exemplos bacanas de tipos do PostgreSQL são:

• jsonb - no qual você guarda dados em formato JSON de forma bastante flexível, com direito à indices GIN e tudo mais. Quem usava um banco de dados NoSQL só para ter dados sem schema definido, pode usar esse tipo de dado para potencialmente resolver esse problema.
• array - permite definir arrays multidimensionais de tamanhos variáveis.
• Além de enumerations, tipos geométricos, endereços de rede e vários outros.

5) Comunidade e licenças

Depois que o MySQL foi comprado pela Oracle, foi criado um fork do projeto, chamado MariaDB, o qual no começo se comprometia a ser compatível com o MySQL, porém totalmente livre em termos de licença. Infelizmente ele já não é 100% compatível com o MySQL, o que talvez seja um problema para algumas empresas ou desenvolvedores (ou não).

Já o PostgreSQL sempre foi open-source e apesar de ter uma licença própria, ela é muito parecida com as licenças BSD e MIT.

6) Preços

Muita gente não sabe, mas a versão completa do MySQL não é gratuita.

O PostgreSQL por sua vez oferece todas as suas funcionalidades pelo mesmo preço: zero!

Conclusão

Do jeito que eu listei as comparações aqui, pode parecer que o MySQL é o pior banco de dados do mundo, mas de fato ele está longe disso. O fato de ser tão popular e de tantas empresas usarem e apostarem nele provam isso.

Entretanto, pelos motivos citados acima, PostgreSQL é minha escolha pessoal. Deixe nos comentários abaixo se você concorda ou discorda, discussões (saudáveis) são sempre bem-vindas! 😉

Nesse vídeo eu vou mostrar como testar o comportamento do seu site ou web app em diferentes dispositivos, para que você possa garantir que o layout fique bom independentemente da resolução e tamanho da tela do dispositivo.

Essa técnica é conhecida como design responsívo e as ferramentas que você vai precisar para testar vão te surpreender :)

Todos os dias, milhares de pessoas começam a programar. Mas a decisão de qual caminho escolher, o que estudar, no que se especializar fica cada vez mais difícil, pois há cada vez mais opções.

Além disso, uma parte do mercado espera que você saiba o máximo de coisas possíveis (também conhecido como desenvolvedor "full stack"), enquanto que a outra parte prefere profissionais que se especializam em uma determinada área.

Seja como for, o roadmap abaixo (criado por Kamran Ahmed e traduzido/adaptado por mim) pode ajudar a filtrar o mar de tecnologias disponíveis para profissionais da área. Bons estudos! 😉

🚀 Introdução

🎨 Front-end

Novos frameworks não param de aparecer. Saber bem o básico de JavaScript e CSS ainda é mais importante que frameworks.

🎛 Back-end

Para o back-end, eu continuo recomendando a linguagem Ruby.

👷 DevOps

Docker (e containers em geral) estão cada vez mais relevantes.

Há alguns dias, escrevi um artigo explicando a diferença entre Terminal, IDE e Editor de Textos.

Basicamente, terminal é um programa que usamos para gerenciar recursos mais avançados do sistema. É geralmente uma tela preta, sem botões e sem elementos gráficos, a qual você interage digitando linhas de comandos.

Como você deve imaginar, existem vários comandos que já vem por padrão em cada sistema operacional. Esses comandos executam tarefas distintas e resolvem diferentes tipos de problemas, muitos dos quais são relevantes para programadores.

Entretanto, para quem está começando no mundo da programação, pode ser um pouco assustador ver a quantidade de comandos disponíveis. Na prática, essa quantidade é infinita, já que programas e pacotes instalados também podem disponibilizar comandos próprios para serem executados, também conhecidos como CLIs (Command-line interface, ou Interface de Linha de Comando).

Vou listar abaixo alguns comandos úteis (os mais básicos) que os sistemas operacionais já trazem por padrão, mas antes vamos entender como executá-los e o que podemos esperar após cada execução.

Como executar os comandos

O processo é bem simples: você digita algum comando e pressiona enter. O resultado do comando, na maioria das vezes, será exibido na tela. Nesse momento, várias coisas podem acontecer:

• O comando é executado corretamente e uma mensagem de sucesso aparece.
• O comando é executado corretamente porém nada é exibido (raro de acontecer).
• O comando é executado e um erro é exibido.
• O comando é executado, um erro acontece, porém nada é exibido na tela (muito raro de acontecer).

Case-sensitive

Lembre-se que os comandos são case-sensitive (sensíveis à caixa), ou seja, há diferença entre digitar um comando em maiúsculas e minúsculas. Na grande maioria das vezes, tudo deve ser digitado com minúsculas.

Comandos para Windows

O terminal no Windows é conhecido como "Prompt de Comando" (apesar de existirem outros como o PowerShell e o novo Windows Terminal).

Para abri-lo, clique no Menu Iniciar, digite cmd e pressione enter.

➡ date

Exibir a data atual.

C:\> date
A data atual é: Qui 23/10/2019

➡ time

Exibir a hora atual.

C:\> time
A hora atual é:  1:42:29.68

➡ echo %cd%

Exibir qual é o diretório atual.

C:\> echo %cd%
C:\

➡ dir

Exibir arquivos/diretórios do diretório atual.

C:\> dir
Volume in drive C has no label.
Volume Serial Number is 82C2-03F2
Directory of C:\
10/21/2019  09:34 PM    <DIR>          PerfLogs
10/22/2019  10:52 PM    <DIR>          Program Files
10/21/2019  11:08 PM    <DIR>          Program Files (x86)
10/21/2019  10:07 PM    <DIR>          samples
10/21/2019  09:45 PM    <DIR>          Scripts
10/21/2019  09:30 PM    <DIR>          Users
10/22/2019  10:50 PM    <DIR>          Windows
              0 File(s)              0 bytes
              7 Dir(s)  99,198,668,800 bytes free

➡ cd

Mudar o diretório atual.

C:\> cd Documentos
C:\Documentos>

Voltar para o diretório acima.

C:\Documentos> cd ..
C:\>

➡ mkdir

Criar uma pasta.

C:\> mkdir meus_projetos
C:\> dir
(...)
23/10/2019  07:34  <DIR>  meus_projetos

Criar pasta e subdiretórios (de uma só vez).

C:\> mkdir meus_projetos\repositorios\ruby
C:\> cd meus_projetos
C:\meus_projetos> cd repositorios
C:\meus_projetos\repositorios> cd ruby
C:\meus_projetos\repositorios\ruby>

➡ copy

Copiar (duplicar) um arquivo.

C:\Documentos> copy arquivo1.txt arquivo2.txt
        1 arquivo(s) copiado(s).

➡ move

Mover (ou renomear) um arquivo ou pasta.

C:/> move nome_antigo.txt nome_novo.txt
(O arquivo será renomeado)

C:/Documentos> move telefones.txt meus_projetos
(O arquivo será movido para a pasta `meus_projetos`)

➡ del

Deletar um arquivo.

C:/Documentos> del telefones.txt

➡ rmdir

Deletar uma pasta vazia.

C:/Documentos> rmdir meus_projetos

➡ rmdir /s

Deletar uma pasta que não esteja vazia.

C:/Documentos> rmdir /s meus_projetos

➡ type

Exibir o conteúdo de um arquivo.

C:/Documentos> type telefones.txt
(11) 1111-1111
(22) 2222-2222
(33) 3333-3333

➡ cls

Limpar o terminal.

C:\> cls

Comandos para macOS e Linux

Para abrir o terminal no macOS, abra a pasta de Aplicativos (Applications) e em seguida a pasta Utilitários (Utilities). Agora basta abrir o aplicativo Terminal.

Duas alternativas bastante interessantes (e populares entre programadores) são o iTerm2 (screenshot abaixo) e o Hyper.

Já para abrir o terminal no Ubuntu Linux, clique no ícone do Ubuntu no canto superior-esquerdo, digite terminal e selecione o aplicativo Terminal na lista de resultados que vai aparecer:

➡ date

Exibir a data e hora atuais.

$ date
# Wed 23 Oct 2019 07:36:36 AEST

➡ cal

Exibir um calendário.

$ cal
#     October 2019
# Su Mo Tu We Th Fr Sa
#        1  2  3  4  5
#  6  7  8  9 10 11 12
# 13 14 15 16 17 18 19
# 20 21 22 23 24 25 26
# 27 28 29 30 31

➡ uptime

Exibir há quanto tempo você não desliga/reinicia seu computador.

$ uptime
# 18:58:47 up 34 days, 9:20, 1 user, load average: 0.00, 0.01, 0.05

➡ pwd

Exibir qual é o diretório atual.

$ pwd
# /Users/usuario/Documents

➡ ls

Exibir arquivos/diretórios do diretório atual.

$ ls
# foto.png      telefones.txt

Exibir arquivos/diretórios do diretório atual em formato de lista.

$ ls -l
# -rw-r--r--@ 1 usuario  staff  4787  6 Mar 17:55 foto.png
# -rw-r--r--  1 usuario  staff  8186  6 Mar 17:54 telefones.txt

Exibir arquivos/diretórios do diretório atual incluindo arquivos ocultos.

$ ls -la
# drwx------+  7 usuario  staff   238  6 Mar 17:57 .
# drwxr-xr-x+ 80 usuario  staff  2720  6 Mar 17:57 ..
# -rw-r--r--   1 usuario  staff     0  6 Mar 17:56 .arquivo_oculto.txt
# -rw-r--r--@  1 usuario  staff  4787  6 Mar 17:55 foto.png
# -rw-r--r--   1 usuario  staff     0  6 Mar 17:54 telefones.txt

➡ cd

Mudar o diretório atual.

$ pwd
# /Users/usuario
$ cd Documents
$ pwd
# /Users/usuario/Documents

Voltar para o diretório acima.

$ pwd
# /Users/usuario/Documents
$ cd ..
$ pwd
# /Users/usuario

Voltar para o diretório do seu usuário (conhecido como pasta "home").

$ cd ~
$ pwd
# macOS: /Users/usuario
# Linux: /home/usuario

➡ mkdir

Criar uma pasta.

$ mkdir meus_projetos
$ ls
# meus_projetos

Criar pasta e subdiretórios.

$ mkdir -p meus_projetos/repositorios/ruby
$ ls
# meus_projetos
$ cd meus_projetos
$ ls
# repositorios
$ cd ruby
$ ls
# Diretório vazio

➡ cp

Copiar (duplicar) um arquivo.

cp arquivo1.txt arquivo2.txt

➡ mv

Mover (ou renomear) um arquivo ou pasta.

mv nome_antigo.txt nome_novo.txt
# O arquivo será renomeado

mv telefones.txt ~/Documents/
# O arquivo será movido para a pasta ~/Documents/

➡ rm

Deletar um arquivo.

rm telefones.txt

➡ rm -rf

Deletar uma pasta.

$ rm -rf meus_projetos

➡ touch

Criar um arquivo em branco (vazio).

$ touch emails.txt

➡ cat

Exibir o conteúdo de um arquivo.

$ cat telefones.txt
# (11) 1111-1111
# (22) 2222-2222
# (33) 3333-3333

➡ clear

Limpar o terminal (o atalho Ctrl+l também funciona na maioria dos terminais).

$ clear

Como conseguir ajuda com um determinado comando?

Digite o comando acompanhado de -h ou --help no final, ou ainda utilize o comando man <comando>. Exemplos:

$ rails -h

$ vim --help

$ man cat

Terminal

O que é?

É um programa disponível em todos os sistemas operacionais para gerenciamento de recursos mais avançados do sistema. É geralmente uma tela preta, sem botões e sem elementos gráficos, onde você utiliza apenas comandos para interagir.

Exemplo: iTerm2

Pode ser um pouco assustador ver a quantidade de comandos disponíveis, para quem está começando no mundo da programação, por isso escrevi um pequeno guia com uma lista de comandos.

Windows

No Windows, temos diferentes terminais, como o Prompt de Comando e o PowerShell.

Linux

No Linux, ele é chamado de Terminal mesmo.

macOS

No macOS, ele também é chamado de Terminal.

Apesar de o sistema trazer um terminal instalado, eu recomendo um outro terminal chamado iTerm2, mais poderoso, o qual pode ser baixado através do site iterm2.com.

IDE

O que é?

É um programa que não vem instalado por padrão e é utilizado para o desenvolvimento de softwares. É geralmente uma janela com muitos botões, muitos elementos gráficos e uma área para digitar os códigos.

Exemplo: Xcode, para programar apps para iOS (iPhone e iPad), macOS, watchOS e tvOS

Exemplos de IDEs:

• Xcode
• Android Studio
• Visual Studio
• IntelliJ IDEA
• Eclipse

Editor de Textos

O que é?

Para programar em algumas linguagens (Ruby por exemplo), não é necessário uma IDE, podemos utilizar apenas um editor de texto, que é mais simples e mais rápido.

Editores servem para editar textos e também códigos. Os editores que vem instalado por padrão (Bloco de Notas, por exemplo) são simples demais, portanto não são recomendados para desenvolver programas. No geral, eles são apenas uma janela com poucos botões (às vezes nenhum) e uma grande área para digitar os códigos.

Exemplo: Atom

Exemplos de editores de texto:

• VS Code
• Atom
• Sublime Text
• Vim, gVim e MacVim

Dia desses uma pessoa me perguntou algumas coisas sobre diploma/faculdade de computação e após responder percebi que poderia ser um tema interessante para um vídeo.

O resultado você vê no vídeo acima, espero que goste e não deixe de comentar sua opinião aqui em baixo :)

Nesse novo screencast, vou ensinar como adicionar uma interessante funcionalidade ao seu app: autenticação usando o Facebook.

Para ficar mais interessante, usei um projeto real: o Easy Bills. O projeto usa Ruby e Ruby on Rails e adicionalmente, eu incluí a gem omniauth-facebook.

Abaixo, você encontra os arquivos que eu criei ou alterei no vídeo:

Gemfile:

gem 'omniauth-facebook'

app/assets/images/social-sign-in/facebook.svg:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
   width="35px" height="35px" viewBox="0 0 300 300" enable-background="new 0 0 266.893 266.895"
   xml:space="preserve">
<path id="f" fill="#FFFFFF" d="M182.409,262.307v-99.803h33.499l5.016-38.895h-38.515V98.777c0-11.261,3.127-18.935,19.275-18.935
  l20.596-0.009V45.045c-3.562-0.474-15.788-1.533-30.012-1.533c-29.695,0-50.025,18.126-50.025,51.413v28.684h-33.585v38.895h33.585
  v99.803H182.409z"/>
</svg>

app/assets/stylesheets/authentication.sass (ou app/assets/stylesheets/application.sass):

@import 'modules/social-buttons'

app/assets/stylesheets/modules/social-buttons.sass:

// https://github.com/vagnervjs/social-signin-btns
$services: google #DD4B39, facebook #3B5998, twitter #00ACED, microsoft #e3b30d, github #2a2a2a, foursquare #95c330, instagram #906248, linkedin #0b5ea3, evernote #5ca629, dropbox #1b73d1
.btn-si
  background-position: 1em
  background-repeat: no-repeat
  background-size: 2em
  border-radius: .5em
  border: none
  color: #fff
  cursor: pointer
  font-size: 1em
  line-height: 1em
  padding: 0 2em 0 4em
  text-decoration: none
  transition: all .5s
@each $service in $services
  .btn-#{nth($service, 1)}
    background-color: #{nth($service, 2)}
    &, &:hover, &:active
      background-image: image-url("social-sign-in/#{nth($service, 1)}.svg")
      color: #fff
    &:hover
      background-color: lighten(nth($service, 2), 10%)
    &:active
      background-color: darken(nth($service, 2), 10%)
.btn-si-a
  padding: 15px 15px 15px 65px !important
  font-family: arial
.smaller .btn-si-a
  padding-left: 40px !important
  font-size: 12px

app/controllers/users/omniauth_callbacks_controller.rb:

module Users
  class OmniauthCallbacksController < Devise::OmniauthCallbacksController
    def facebook
      @user = User.from_omniauth(request.env['omniauth.auth'])
      if @user.persisted?
        sign_in_and_redirect @user, event: :authentication # Throws if @user is not activated
        set_flash_message(:notice, :success, kind: 'Facebook') if is_navigational_format?
      else
        session['devise.facebook_data'] = request.env['omniauth.auth']
        redirect_to new_user_registration_url
      end
    end
    def failure
      redirect_to new_user_session_path
    end
  end
end

app/models/concerns/omniauthenticable.rb:

module Omniauthenticable
  extend ActiveSupport::Concern
  included do
    def self.from_omniauth(auth)
      existing_user = User.find_by(email: auth['info']['email'])
      if existing_user
        existing_user.update!(provider: auth.provider, uid: auth.uid)
        existing_user
      else
        where(provider: auth.provider, uid: auth.uid).first_or_create do |user|
          user.email                 = auth.info.email
          user.password              = Devise.friendly_token[0, 20]
          user.password_confirmation = user.password
          user.name                  = auth.info.name
          user.photo                 = auth.info.image
          user.skip_confirmation!
        end
      end
    end
    def self.new_with_session(params, session)
      super.tap do |user|
        data = session['devise.facebook_data'] &&
          session['devise.facebook_data']['extra']['raw_info']
        user.email = data['email'] if data && user.email.blank?
      end
    end
  end
end

app/models/user.rb:

class User < ApplicationRecord
  include Omniauthenticable
  devise :omniauthable, omniauth_providers: %i[facebook]
  # etc
end

app/views/devise/sessions/new.html.haml:

%hr.m-t-25
.m-b-10 or
.fg-line.m-b-10
  = link_to 'Sign in with Facebook', user_facebook_omniauth_authorize_path,
    class: 'btn btn-si btn-si-a btn-facebook'

config/initializers/devise.rb:

config.omniauth :facebook, 'FACEBOOK_APP_ID', 'FACEBOOK_APP_SECRET'

config/routes.rb:

devise_for :users, controllers: {
  omniauth_callbacks: 'users/omniauth_callbacks',
  # etc
}

db/migrate/20171204023306_add_omniauth_to_users.rb:

class AddOmniauthToUsers < ActiveRecord::Migration[5.1]
  def change
    add_column :users, :provider, :string
    add_column :users, :uid,      :string
  end
end

Quem nunca passou por isso?!

Eis os motivos que me fizeram começar e os que até hoje me fazem continuar!

Artigo mencionado no vídeo: Refiz meu blog do zero

Como começar?

Uma das maneiras mais práticas de começar é usando o Wordpress. É uma plataforma gigante, de graça e tem muitos temas e plugins. Sem contar a comunidade que é gigante, então é muito fácil encontrar no Google soluções para qualquer problema que você eventualmente tenha.

Se você quiser algo um pouco mais avançado (gerando páginas que tem muitos benefícios), você pode usar o Jekyll ou o Hugo.

Se você nunca viu/escreveu mensagens de commits como estas acima, parabéns.

Apesar de a maioria dos desenvolvedores escrever boas mensagens, não podemos generalizar: sempre tem alguém para provar que a zueira não tem limites estragar a estatística.

Como escrever boas mensagens

Devemos escrever a mensagem no presente? No futuro? Em português? Em inglês? São infinitas as formas as quais uma mensagem de commit pode ser escrita.

Antes de mais nada, você deveria escrever as mensagens de commits em inglês. Eu escrevi um artigo com 8 motivos para programar em inglês, e os mesmos motivos se aplicam aqui.

O correto é escrever na forma imperativa. Ou seja, você precisa sempre estar apto a completar a seguinte frase:

If applied, this commit will your subject line here

Tradução livre: "Se aplicado, esse commit vai seu resumo aqui"

Exemplos:

Encontrei exemplos bacanas nesse artigo (em inglês) e vou listá-los abaixo:

• ✅ If applied, this commit will Refactor subsystem X for readability
• ✅ If applied, this commit will Update getting started documentation
• ✅ If applied, this commit will Remove deprecated methods
• ✅ If applied, this commit will Release version 1.0.0
• ✅ If applied, this commit will Merge pull request #123 from user/branch

Note como isso não fica legal escrevendo de forma não-imperativa:

• ❌ If applied, this commit will Fixed bug with Y
• ❌ If applied, this commit will Changing behavior of X
• ❌ If applied, this commit will More fixes for broken stuff
• ❌ If applied, this commit will Sweet new API methods

Nota: não é preciso adicionar um ponto no final da mensagem.

Resumo e corpo da mensagem do commit

Encontrei nesse artigo um modelo (em inglês) de mensagem para commits:

Capitalized, short (50 chars or less) summary
More detailed explanatory text, if necessary.  Wrap it to about 72
characters or so.  In some contexts, the first line is treated as the
subject of an email and the rest of the text as the body.  The blank
line separating the summary from the body is critical (unless you omit
the body entirely); tools like rebase can get confused if you run the
two together.
Write your commit message in the imperative: "Fix bug" and not "Fixed bug"
or "Fixes bug."  This convention matches up with commit messages generated
by commands like git merge and git revert.
Further paragraphs come after blank lines.
- Bullet points are okay, too
- Typically a hyphen or asterisk is used for the bullet, followed by a
  single space, with blank lines in between, but conventions vary here
- Use a hanging indent

Basicamente a primeira linha - conhecida como summary (resumo) - deve conter 50 ou menos caracteres, enquanto que as linhas seguintes - conhecidas como body (corpo) - pode conter quantas linhas forem necessárias, limitadas a 72 caracteres por linha.

No corpo, eu costumo incluir explicações detalhadas, links, listas e qualquer outra coisa relevante quando necessário.

Por que uma boa mensagem importa?

Alguns motivos:

• Caso um bug seja introduzido, uma boa mensagem de commit facilita a identificação de onde/quando isso aconteceu;
• Se você reverter um commit, a mensagem será Revert "mensagem original", deixando claro o que está sendo revertido;
• Boas mensagens se tornam útias ao exibir listas de commits através de comandos como git blame, git log, git shortlog, etc.

Para finalizar, a regra principal é o bom senso. Se você usar como desculpa que não teve 10 segundos pra pensar em uma boa mensagem, eu vou certamente duvidar :)

A versão 2.5.0-preview1 da linguagem Ruby acaba de ser liberada. Por não se tratar de uma versão estável, seu uso ainda não é recomendado.

Novas funcionalidades

Backtrace invertido

O backtrace (lista de métodos que foram executados antes de um erro acontecer) vai começar a ser exibida em ordem inversa. Usando o seguinte código como exemplo:

# Arquivo `teste.rb`
def a
  b
end
def b
  c
end
def c
  raise 'error'
end
a

Executando com Ruby 2.4:

$ ruby teste.rb
teste.rb:10:in `c': error (RuntimeError)
    from teste.rb:6:in `b'
    from teste.rb:2:in `a'
    from teste.rb:13:in `<main>'

Executando com Ruby 2.5:

Traceback (most recent call last):
    3: from teste.rb:13:in `<main>'
    2: from teste.rb:2:in `a'
    1: from teste.rb:6:in `b'

Rescue/else/ensure serão permitidos dentro de blocos do/end

Executando com Ruby 2.4:

Atualmente nós só conseguimos capturar exceptions dentro de métodos ou blocos begin/end, ou seja:

begin
  raise 'boom'
rescue Exception => e
  puts "Erro capturado: #{e.message}"
end

Saída: Erro capturado: boom.

def meu_metodo
  raise 'boom'
rescue Exception => e
  puts "Erro capturado: #{e.message}"
end
meu_metodo

Saída: Erro capturado: boom.

Porém o código abaixo não funciona:

[1, 2, 3].map do |i|
  raise 'boom'
rescue Exception => e
  puts "Erro capturado: #{e.message}"
end

syntax error, unexpected keyword_rescue, expecting keyword_end
rescue Exception => e

Executando com Ruby 2.5:

Na versão que está para ser lançada, isso é possível. A saída do código acima será:

Erro capturado: boom
Erro capturado: boom
Erro capturado: boom

Novo método yield_self

De acordo com a documentação oficial:

Yields self to the block and returns the result of the block.

Apesar de ser muito parecido com o método tap da classe Object (que é muito útil, diga-se de passagem), seus retornos são diferentes.

Enquanto que com o método tap você abre um bloco e no final o próprio objeto é retornado, com o yield_self, o resultado do bloco é retornado.

Exemplo:

objeto.tap { |obj| obj.save } # => objeto
# O método `save` foi chamado,
# mas `objeto` é que é retornado

objeto.yield_self { |obj| obj.save } # => true
# A última execução do bloco será retornada.
# Ou seja, se supormos que o método `save` retorna `true`,
# o retorno dessa linha toda será `true` também

Não consegui pensar em um caso prático pra usá-lo, mas com certeza teve uma razão para ter sido adicionado :)

Outras mudanças

A nova versão também trará outras novidades, como suporte ao Unicode versão 10, que inclui 56 emojis criados esse ano. Você pode ver uma lista completa com todas as novidades nesse documento.

Para instalar o Ruby 2.5 (apesar de ainda não recomendado por não ser uma versão estável) através do RVM, basta rodar:

rvm install 2.5.0-preview1

Happy hacking!

Começei esse blog usando WordPress. Alguns anos depois migrei para Enki (uma engine open-source baseada em Ruby on Rails), mas acabei voltando tudo como era antes depois de apenas 2 semanas e relatando o motivo nesse artigo. Tudo estava relativamente bem desde então; WordPress continua sendo sensacional na minha opinião.

Mas eu queria mudar algumas coisas e abandonar o WordPress é sempre um trade-off. A migração acabou dando mais trabalho do que eu previ, no entanto fiquei muito satisfeito com o resultado. Vou contar um pouco o que foi alterado e porquê:

Nova fase do blog/site

Talvez o motivo mais relevante para eu ter feito todas essas mudanças, é porque pretendo publicar mais conteúdo aqui. Alunos do meu curso me pedem explicações fora do contexto do curso e que eu acho que também seria interessante para quem já me segue aqui.

Páginas estáticas

A maior alteração foi começar usar uma ferramenta que gere arquivos estáticos. Isso significa que nesse exato momento você não está lendo um artigo gerado dinamicamente, são apenas arquivos HTML, CSS e JS pré-compilados (e recompilados quando eu escrevo um novo artigo ou altero um antigo).

Isso tem uma série de vantagens, sendo performance uma das mais importantes. Como o arquivo HTML já está gerado e pronto para ser lido, as páginas abrem muito rápido!

Eu considerei duas ferramentas para isso:

Jekyll vs Hugo

Como já fiz bastante coisa usando o Jekyll, essa seria a escolha mais óbvia. Porém, eu dei uma chance à uma outra ferramenta bastante similar chamada Hugo, principalmente por influência de dois amigos que o usam: Pothix e Diego Eis.

A instalação foi tranquila (apesar dele não vir com um tema padrão), mas acabei tendo alguns problemas e não quis perder mais tempo do que eu já tinha perdido com isso. No final das contas, eu não vi uma real vantagem em relação ao Jekyll: os procedimentos e resultados de ambos são muito parecidos (me avise nos comentários se eu estiver perdendo algo grandioso que eu não sei).

Acho que o Jekyll tem uma comunidade maior (e consequentemente um maior número de gems/plugins) enquanto que o Hugo é absurdamente mais rápido. Fiquei com o Jekyll e estou bastante satisfeito :)

Artigos em Markdown

Muitas pessoas que escrevem frequentemente gostam da sintaxe Markdown e não é a toa: é muito prático formatar texto e usar o editor de textos de sua preferência.

Utilizei o jekyll-import, ferramenta oficial do Jekyll para importar conteúdo de outros gerenciadores de blogs. Fiquei surpreso de quão bem tudo funcionou!

Agora, 90% dos posts estão devidamente migrados para MarkDown, mas a parte bacana é que códigos HTML podem ser inseridos em arquivos MarkDown sem nenhum efeito colateral: tudo funcionará conforme o esperado.

URL

Era hora de eu finalmente mudar a URL também; juntar o blog com outras coisas que eu publicava no domínio principal (www.lucascaton.com.br), o que possivelmente irá melhorar um pouco o SEO.

O subdomínio blog.lucascaton.com.br agora redireciona para o novo endereço www.lucascaton.com.br. O restante do endereço continua exatamente o mesmo, o que facilitou nos redirecionamentos que adicionei ao nginx.

Único repositório

Por causa da mudança da URL, acabei juntando os dois repositórios (blog e meu site) em um só, facilitando as alterações e deployments.

Faxina

Aproveitei para apagar muitos (35 para ser exato) artigos antigos que ou não fazem mais sentido ou não eram tão bons:

Se por qualquer motivo você precisar de um artigo antigo que foi deletado, me avise nos comentários.

Comentários

Utilizo o Disqus para gerenciamento dos comentários e como mudei o domínio, foi necessário uma migração. A boa notícia é que o site oferece uma ótima ferramenta para isso, apesar de ser um pouco confusa:

[@disqus](https://twitter.com/disqus?ref_src=twsrc%5Etfw) hi there. All comments from my website are no longer showing up, could you please shed some light?[https://t.co/O0AhxhnQcX](https://t.co/O0AhxhnQcX)

— Lucas Caton (@lucascaton) [3 October 2017](https://twitter.com/lucascaton/status/915353715783041024?ref_src=twsrc%5Etfw)

Por fim, resolvi o problema seguindo esses passos.

Hospedagem

Uma das vantagens de gerar arquivos 100% estáticos é a facilidade para hospedá-los. Seria bastante simples (e barato) armazená-los no S3, que é como eu faço no blog do Easy Bills. Mas o GitHub Pages é tão simples quanto e ainda é gratuito, o que me fez escolher essa opção.

No momento, os arquivos ainda estão no servidor antigo - no qual eu rodava o WordPress - por um simples motivo: analisar os logs e ver se eu esqueci algum redirect importante. Tudo devidamente migrado e rodando no GitHub Pages agora! \o/

SSL

Eu usava Let's Encrypt para gerar certificados SSL, mas como pretendo mover os arquivos para o GitHub Pages em breve, comecei a usar o Cloudflare, que também é ótimo!

Novo layout

É isso! Se tiver qualquer dúvida, me mande nos comentários :)

Google has recently announced a way to run the Chrome browser in a headless environment. If you're using Capybara gem, you can easily start using headless Chrome. Without further ado, let's do it:

1. Make sure you have one of the following Chrome versions:

• 57+ on Linux
• 59+ on macOS
• 60+ on Windows

2. Add (or update) the gem selenium-webdriver;

3. Make sure you're using ChromeDriver version 2.30 or higher. You can install it by running:

• brew install chromedriver on macOS;
• apt-get install chromium-chromedriver on Debian/Ubuntu Linux.

4. Add the following driver to your spec/support/capybara.rb, spec/spec_helper.rb, or spec/rails_helper.rb:

Capybara.javascript_driver = :selenium_chrome_headless

Or, if you need to use some custom options:

Capybara.register_driver :chrome do |app|
  Capybara::Selenium::Driver.new app, browser: :chrome,
    options: Selenium::WebDriver::Chrome::Options.new(args: %w[headless disable-gpu])
end
Capybara.javascript_driver = :chrome

Done, enjoy headless Chrome! ᕕ( ᐛ )ᕗ

You might get a warning like the following:

WARN Selenium [DEPRECATION] :args or :switches is deprecated. Use Selenium::WebDriver::Chrome::Options#add_argument instead.

Make sure you don't have another registered driver, I made this mistake myself and had an iphone driver, which was passing args in the old way and turned out to be the reason why I was getting the warning.

É com muito prazer que venho contar a vocês que finalmente publiquei meu Curso de Programação.

Caso você não me conheça, meu nome é Lucas, sou desenvolvedor desde 2004, fundador da startup Easy Bills, escrevo nesse blog desde 2009 e dei o meu melhor para criar um curso para quem quer aprender a programar começando do zero, através de videoaulas 100% online.

Com esse curso, você aprenderá a criar páginas web dinâmicas, criar aplicações onde o usuário precisa se autenticar (login e senha), enviar emails através da sua aplicação, criar layouts para páginas mesmo sem ter experiência em design, negociar a venda de projetos (incluindo preços), qual salário é justo para o seu nível e muito mais.

E você vai desenvolver dois aplicativos durante o curso, um gerenciador de tarefas e um clone do Instagram.

Visite a página do curso ou marque nos comentários abaixo aquele amigo que quer aprender programação :)

Abaixo você encontra um vídeo com mais detalhes sobre o curso:

Both Heroku and its CLI are great. However, there's no way to access multiple accounts via terminal out of the box. If you have a personal and a work account and need an easy way to switch between them, I have good news for you! :)

Heroku's team has created a plugin called heroku-accounts. You can find how to install and how to use in its project page on Github.

To make it even easier, I've added the following aliases to my ~/.zshrc (or ~/.bashrc):

# Heroku
alias hp='heroku accounts:set personal'
alias hw='heroku accounts:set work'

Happy hacking!

Acabei de ler o livro "Desconstruindo a Web: As tecnologias por trás de uma requisição", escrito pelo meu amigo PotHix (Willian Molinari).

Se você é programador ou está de alguma forma envolvido com aplicações web, servidores, redes ou simplesmente tem curiosidade de entender como a web funciona "por baixo dos panos", nos mínimos detalhes, você deveria ler esse livro.

Esse não é um daqueles livros chatos que você lê na faculdade. Para você ter uma idéia, o certificado HTTPS é explicado através de uma metáfora com o Senhor dos Anéis! Tem como ficar mais legal que isso? 😁

O único detalhe é que alguns capítulos se focam bastante na área de redes e como eu vejo isso no dia-a-dia, vou provavelmente acabar esquecendo vários conceitos explicados :)

Você encontra todos os detalhes do livro (inclusive como comprar) aqui:

https://desconstruindoaweb.com.br/

Você também pode ver a página do livro no GoodReads!

O PotHix também conta como foi o processo de escrita do livro, o que eu também achei muito interessante.

Tenho escutado muito mais podcasts que livros ultimamente, mas esse definitivamente me chamou a atenção e decidi comprar e ler. Resultado: valeu a pena, recomendo!

I was about to run a rake task which would make important changes in my database. My code was similar to this:

def migrate_active_accounts
  accounts = Account.active
  # Code to migrate accounts here...
end
def migrate_inactive_accounts
  accounts = Account.inactive
  # Code to migrate accounts here...
end

This migration was very critical. Thus, I decided to log everything to make sure it would run as expected. So I wrote a separate method to log what accounts were going to run by which method.

In order to do that, I'd need to know which method was calling my logger method.

I ended up finding the answer on StackOverflow (where else would I? ).

Solution

As usual, Ruby has a neat solution for it: Kernel module has a caller_locations method, which returns an array with the current execution stack. So all we need to do is to use caller_locations.first.label to get the first element from the stack and then get its label.

My final code was looking like the following:

def migrate_active_accounts
  accounts = Account.active
  log_migration_info(accounts)
  # Code to migrate accounts here...
end
def migrate_inactive_accounts
  accounts = Account.inactive
  log_migration_info(accounts)
  # Code to migrate accounts here...
end
private
def log_migration_info(accounts)
  caller_method = caller_locations.first.label
  Rails.logger.info "Running [MyClass##{caller_method}]
    for the following accounts: #{accounts.map(&:id).to_sentence}"
end

Ruby prior to 2.0

If you're using an old version of Ruby (even though you shouldn't), you'll need to use caller method along with a regular expression:

caller.first[/`(.*)'/, 1]

Happy hacking!

Last time I updated this blog's theme was in 2012! 😮

It was about time to have a fresh new look and there you have it! \o/

I can't remember the last time I needed to open/read log/development.log or log/test.log. These files usualy just consume disk space unnecessarily (some test.log files can easily reach more than 1 GB).

After talking to some other developers, all of them agreed they don't use it as well. So what I've been doing in my projects is adding the following code (note that it'll still display logs through the STDOUT though):

Rails 4+

config/environments/development.rb:

# Prevents from writing logs on `log/development.log`
logger           = ActiveSupport::Logger.new(STDOUT)
logger.formatter = config.log_formatter
config.logger    = ActiveSupport::TaggedLogging.new(logger)

config/environments/test.rb:

# Prevents from writing logs on `log/test.log`
config.log_level = :warn
logger           = ActiveSupport::Logger.new(STDOUT)
logger.formatter = config.log_formatter
config.logger    = ActiveSupport::TaggedLogging.new(logger)

Rails 3

config/environments/development.rb:

# Prevents from writing logs on `log/development.log`
logger        = ::Logger.new(STDOUT)
config.logger = ActiveSupport::TaggedLogging.new(logger)
# Replace `config.active_support.deprecation = :log` with:
config.active_support.deprecation = :stderr

config/environments/test.rb:

# Prevents from writing logs on `log/test.log`
config.log_level = :warn
logger           = ::Logger.new(STDOUT)
config.logger    = ActiveSupport::TaggedLogging.new(logger)

Ps.: I've sent a suggestion to rubyonrails-core mailing list to make it default from next Rails versions, let's see their thoughts.

TL; DR - Just use Puma.

Rails has changed its default server from Webrick to Puma in Rails 5!

It also supports Action Cable (one of the new features from Rails 5) and Basecamp said they're using Puma in production.

I was wondering if Puma has been in fact better than Unicorn so I've read some blog posts about it:

• Codeship's
• Heroku's
• EngineYard's

Basically, the answer is yes - it is a bit better, but don't wait for a huge improvement.

It'd be a good idea if you're either about to start a new project and migrating your current project to Rails 5 or newer.

Every now and then I need to write a script (rake task) to import a production database dump.

This is code I usually use:

require 'yaml'
namespace :db do
  desc 'Downloads and imports a production DB dump'
  task :import_production_dump do
    puts '➙ Generating production DB dump...'
    execute_on_server %(
      PGPASSWORD="`cat /var/www/project/current/config/database.yml | \
        grep password | awk '{ print $2 }'`" \
        pg_dump database_name -h custom_url.rds.amazonaws.com -U user_name \
        --column-inserts --no-owner --no-privileges > backup.sql
    )
    puts '➙ Downloading production DB dump...'
    system "scp #{server_user_and_host}:#{backup_file_name} ."
    puts '➙ Deleting production DB dump...'
    execute_on_server "rm #{backup_file_name}"
    puts '➙ Cleaning your local DB...'
    %w[drop create].each { |task| Rake::Task["db:#{task}"].invoke }
    puts '➙ Importing production DB dump...'
    system "bin/rails db development < #{backup_file_name} > /dev/null"
    puts '➙ Removing local dump...'
    system "rm #{backup_file_name}"
    puts '➙ Done!'
  end
  def execute_on_server(commands)
    system %(ssh -T #{server_user_and_host} << 'SSH'
      #{commands}
    SSH).split("\n").map(&:strip).join("\n")
  end
  def server_user_and_host
    'username@example.com'
  end
  def backup_file_name
    'backup.sql'
  end
end

Let me know in the comments if you have a better solution! Perhaps a small gem? :)

Muitas pessoas me perguntam como é o sotaque australiano.

A primeira coisa notável é que o inglês australiano segue a gramática britânica. Exemplo: escreve-se "colour" e "behaviour" em vez de "color" e "behavior".

O melhor jeito de demonstrar como é o sotaque australiano é através de vídeos, por isso selecionei alguns:

Versão australiana do programa de TV "Family Feud"

Pra finalizar: um vídeo do canal "De dentro para fora", que explica as vantagens e desvantagens de estudar inglês australiano:

I think we all agree it's a good practice to regenerate your SSH key from time to time. Not sure about you, but the first thing that comes to my mind when I think about that is: it'd take forever to replace my key in all servers I need to access, all online services that use my key, etc.

Overcoming my laziness, I decided at least to list those place it turned out it was a small list:

• Servers
• Github
• BitBucket

Although now it looks more reasonable, I was still lazy to do it. But then I noticed that Github recommends the use of HTTPS instead of SSH for Git repositories syncs:

What does one thing have to do with another? Well, by using HTTPS, you don't need to upload your SSH key to Github (check this out: mine isn't longer at Github).

BitBucket also supports it, which means I'd be able to regenerate my SSH key without having to upload it again to these services.

Servers

What's left? Servers! From now on, every time I realise it's time to regenerate my SSH key, all I need to update are the servers. I ended up making a list of servers that I'd need to update and found out in the end it wasn't a big list and it'd be way easier than I thought it would.

Let's face the truth: I had been using the same SSH key in the last 5 years or so and it'd be totally worth it to ensure my security as well as the security of the projects from the company I work for.

Becoming safer

There's more! This is the interesting part of this post: I've changed other things that made everything even safer:

• My new SSH key uses 4096 bits - recommended by Github - instead of the default (2048 bits).
• As I mentioned before, I've changed all my local repositories to use HTTPS instead of SSH (see how in the end of this post).
• I'm now using a personal access token rather than my Github password (you can create it here), along with two-factor authentication, which I was already using.
• Cool, but would I need to type this token every time? Nope. There's a nifty tool called ssh-agent that can save your token. If you're using macOS, it's even easier: Keychain can save and encrypt your token for you.
• My SSH key now has a passphrase, also saved encrypted on macOS's Keychain, which means I don't need to type it every time either.

HTTPS is faster!

According to some tests I made here, HTTPS is faster than SSH:

# SSH
$ time git clone git@github.com:rails/rails.git
# 24.28s user 9.56s system 49% cpu 1:08.20 total

# HTTPS
$ time git clone https://github.com/rails/rails.git
# 13.52s user 6.41s system 39% cpu 50.730 total

In order to use HTTPS in my Git repos, do I need to re-clone every project?

Nope. Just open .git/config file and replace:

url = git@github.com:username/repo.git

with:

url = https://github.com/username/repo.git

Conclusion

Regenerating your SSH key every now and then isn't as painful as you might think. I'd recommend doing it every 3 years or even less if you're paranoic or you work on something critic.

Freezing Strings feature improves apps performance by freezing Strings. So, Matz, Ruby's creator, decided to make all String literals frozen (immutable) by default in Ruby 3.0. Update: the Ruby team changed their mind and this didn't happen when Ruby 3.0 was released.

In order to have a transition path to this coming big change, it was decided to have a magic comment at the beginning of files, so you can use in Ruby 2.x. To do so, just add this comment in the first line of your files:

# frozen_string_literal: true
class YourClass
  # ...
end

Try adding it to your spec_helper or rails_helper file and let me know in the comments if your performance gets any better.

More info: Ruby issue #8976.

Sometimes we need to create a monkey patch for a gem or external lib. In these cases, it's good to force it to fail if the gem has been bumped up. Let's use Paperclip as an example:

if Paperclip::VERSION != '1.2.3'
  # If you see this message, please test removing this file
  # If it's still required, please bump up the version above
  fail 'Please remove me, Paperclip version has changed'
end

If the gem doesn't provide you the version through a method, you can solve it with:

if Bundler.load.specs.find { |gem| gem.name == 'paperclip' }.version.to_s != '1.2.3'
  # If you see this message, please test removing this file
  # If it's still required, please bump up the version above
  fail 'Please remove me, Paperclip version has changed'
end

Or even when you're waiting for a new Rails version, e.g.:

fail 'Remove this file' if Rails::VERSION::MAJOR >= 5

Faz tempo que penso em escrever sobre as ferramentas e estratégias que utilizo para backups. Ao escutar esse episódio do Tecnocast sobre o assunto, decidi que era hora de documentar o que eu faço.

Meus arquivos pessoais (pasta ~/)

A pasta do meu usuário possui 3 cópias extras:

1. Assino o plano familiar (U$ 12,50/mês) do CrashPlan, o qual realiza backup automatico e em tempo real do meu computador, da minha esposa e ainda do da minha mãe. Todos os dados ficam na nuvem e eu consigo recuperá-los a qualquer momento, a partir de qualquer lugar, de qualquer computador.

2. A segunda cópia extra dos meus arquivos ficam no meu TimeCapsule, que rodam diariamente de forma automática através do Time Machine.

3. Por fim, faço uma cópia mensal num HD externo (que é bem rápido graças à sua conexão USB 3) utilizando o rsync pra realizar um backup diferencial. O comando / parametros que utilizo para isso é:

rsync -a --progress \
  --delete --delete-excluded --exclude "*.DS_Store" \
  /Users/lucascaton/ /Volumes/Backups/lucascaton/

Importante: não esqueça do / no final de cada path do comando acima.

Arquivos importantes

Ficam dentro da pasta do Dropbox. Ou seja, uma cópia extra além do CrashPlan, Time Machine e HD externo mencionados acima.

Arquivos encriptografados

Se você utiliza OS X macOS, é fácil criar uma pasta protegida com senha (tecnicamente é uma imagem de disco, mas você pode encarar como se fosse uma pasta). Veja como fazer isso nesse artigo de suporte da Apple.

Nessa pasta, eu guardo:

• Códigos de recuperação de servicos com autenticação de 2 fatores;
• Screenshots dos QR codes de autenticação de 2 fatores. É extremamente útil se você precisar resetar seu celular, já que o Google Authenticator (e outras apps) não salvam esses dados na nuvem (por motivos de segurança);
• Chaves privadas SSH (pra acessar servidores);
• Algumas poucas senhas que prefiro manter nessa pasta do que em gerenciadores de senha como o 1Password, o qual eu uso para todo o resto (veja mais informações sobre o 1Password no tópico "Senhas" no final desse artigo.

Arquivos que não ficam no meu computador

Alguns arquivos eu não mantenho no meu computador por serem muitos grandes ou simplesmente por não fazer sentido tê-los comigo o tempo todo. Um exemplo são os vídeos do Reza a Lenda.

Eu os mantenho no Time Capsule e mensalmente faço um backup destes para o mesmo HD que mencionei no começo do artigo, também utilizando o rsync.

VPS

Faço backup das minhas VPSs através de scripts que realizam backups mensais (os quais rodam diretamente no servidor) e mandam esses arquivos para o meu computador (de novo através de um rsync).

Documentos (RG, CPF, passaporte, etc)

Tenho foto de todos os meus documentos e estes ficam em uma pasta específica dentro do meu Dropbox, a qual é sincronizada automaticamente com o meu celular (através do iTunes), tornando-se disponível no meu celular mesmo quando não há internet disponível.

Fotos

Não ficam na nuvem (por enquanto). Também não utilizo nenhum software para gerenciá-las, apenas pastas organizadas por datas. E não chega a ser um problema: consigo ser disciplinado e manter tudo organizado. Nunca deixo nada no celular, quando o conecto ao computador eu já copio as fotos pro lugar apropriado.

Apesar disso, o novo Google Photos parece um bom lugar pra mantê-las de forma segura.

Músicas

100% das minhas músicas estão no Spotify. Assino o plano premium, então elas também ficam disponíveis off-line no meu celular.

Emails e calendário

Versões web do Gmail e Google Calendar. Simples assim.

Senhas

Gerencio todas as minhas senhas através do 1Password, mas tem uma regra de ouro pra evitar problemas se a segurança do 1Password um dia falhar: a senha do meu Inbox / Gmail não está salva em lugar algum, está apenas na minha cabeça - assim eu consigo recuperar a senha de qualquer serviço caso necessário, utilizando o recurso "Esqueci minha senha", que a maioria dos serviços oferece.

Filmes e séries

Eu costumava alugar filmes e séries na locadora suéca (também conhecida como locadora do Paulo Coelho), mas comecei a fazer as contas: eu assisto uma média de 12 séries por ano, cada uma custa em média $25 por temporada no iTunes, ou seja, $25 por mês. Às vezes tem no Netflix e acabo gastando menos. Já alugar um filme recém-lancado em HD no iTunes custa em média $4. Moral da história: decidi parar completamente de fazer pirataria e comprar / alugar tudo da forma correta :)

Conclusão

Ok, eu sei que sou um pouco (muito?) paranóico, mas pelo menos nunca perdi nada

Me conte nos comentários abaixo como você faz seus backups e o que você achou desse post!

Vejo muitos brasileiros escrevendo código em português. Na faculdade até pode fazer um pouco de sentido por ser mais didático, mas vou apresentar alguns motivos pelos quais isso deve ser evitado no mundo real:

1. O motivo mais importante: inglês é o idioma internacional para código (e para documentações). Mais especificamente, o inglês americano é o padrão. Eu trabalho em uma empresa australiana e embora a Austrália siga a gramática britânica, o código que escrevemos segue a gramática americana (exemplo: "color" e não "colour").

2. Se você pretende um dia trabalhar fora do Brasil, potenciais empresas querendo te contratar vão querer ver seu código, mas não irão entender se estes estiverem em português. Então procure deixar seus repositórios no Github com código e documentação em inglês.

3. Os comandos e palavras-chave de linguagens em programação são em inglês, então mesmo que você queria escrever em português, vai acabar ficando inevitavelmente uma mistura.

4. Algumas linguagens e frameworks estão preparados para entender o inglês em termos de semântica. Exemplo: o Ruby on Rails sabe que a tabela no banco de dados para um determinado model deve ser sempre o nome do model no plural. Ou seja, ao ter um model Person, ele vai automaticamente procurar uma tabela people.

5. Contribuições para projetos open-source devem ser em inglês. Eu sinceramente não conheço um projeto open-source famoso que não esteja em inglês.

6. Muitas empresas no Brasil já escrevem códigos em inglês. Então se eventualmente você começar a trabalhar em um dessas empresas, você terá que se adaptar de qualquer forma.

7. Acentos, ç e caracteres especiais não funcionam bem em todas as linguagens (mesmo quando você usa UTF-8), fazendo que você tenha palavras escritas de forma incorreta se você as escrever em português. Exemplo: producao em vez de produção.

8. Você treina e melhora seu inglês, que é útil para outras coisas na vida, como filmes, seriados, games, etc! 🙂

Gravei também um vídeo (que faz parte do meu curso), comentando os items dessa lista:

Ao escutar o episódio “O impacto da internet no jornalismo” do Braincast, refleti sobre algo que escreverei nesse artigo. Se você não escutou ou não conhece o podcast, eu o recomendo fortemente.

Desde criança, sempre gostei muito de ir à bancas de jornais. Conforme você cresce, o interesse muda um pouco: você substitui os gibis da Turma da Mônica por revista de games e álbuns de Pokémon por revistas como Super interessante e Galileu. Eu gastava boa parta de minha mesada com isso e era recompensador.

De repente — em casa — tínhamos internet. E eu acreditei que era só uma questão de tempo até todo aquele excelente conteúdo das bancas chegar ao mundo online. Mas o fato é que isso até hoje isso não aconteceu por completo. Apesar de portais de notícias (incluindo BuzzFeed, Facebook, etc), onde a mídia digital substituiu com competência a mídia física, acho que foi um pouco diferente com conteúdos que não necessariamente tem urgência em serem publicados.

Lembro-me de capas da revista Super Interessante trazendo temas como Matrix (o filme) e viagem no tempo por exemplo, onde a leitura era completa ao ponto de satisfazer desde o leigo ao estudante das teorias da relatividade de Einstein.

E sinceramente não vejo isso acontecer da mesma maneira online até hoje. Essas revistas eram o meio-termo de quem queria algo mais rápido que um livro, porém não tão superficial quanto um artigo, já que incluíam várias páginas com fotos, infográficos, diagramas, etc.

O mundo online tem essa pressa toda — onde ninguém mais assiste um vídeo com mais de 5 minutos ou lê um artigo com mais de uma página. Preferem no entanto, ler dezenas de posts por minuto no Facebook. Não quero ser hipócrita — eu também faço isso. Também não quero pagar de velho, dizendo que “no meu tempo, tudo era melhor”. Mas eu realmente sinto falta de conteúdos mais profundos que os memes do Instagram e mais confiáveis que a Wikipedia.

E aqui eu chego na parte interessante desse post: talvez os podcasts tenham ocupado esse lugar. Eu atualmente escuto vários podcasts sobre os mais variados temas, como programação, design, tecnologia, publicidade, empreendedorismo, games, entre outros. Então se você — assim como eu — sente falta desse tipo de conteúdo no mundo digital, talvez você possa encontrá-los em podcasts :-)

Para finalizar, segue uma lista dos Podcasts que eu escuto atualmente:

Em português:

• Braincast
• Nerdcast
• MacMagazine no Ar
• Tecnocast
• 99 vidas
• Grok Podcast
• ZOFE — Zone of Front-Enders
• Hack ‘n’ Cast
• CBN — Max Gehringer
• English Experts

Em inglês:

• ATP — Accidental Tech Podcast
• HI — Hello Internet
• Security Now
• Debug
• Stuff You Should Know
• The English We Speak (BBC)

Cerca de 2 meses atrás, eu criei um novo canal no YouTube, com o propósito de mostrar e contar sobre coisas relacionadas à viagens, tecnologia, vídeo games, como é a vida na Austrália, inglês, entre outros assuntos.

O canal se chama "Reza a Lenda": youtube.com/RezaALenda

Já tem vários vídeos publicados, confere lá e me conta depois se gostou :)

My manager has shared an article with me called "Getting lost in translation in Brazil" from BBC News.

This was what I reply to him and I though it'd be nice to make it public:

That's a very interesting article, thanks for sharing. I agree with most of the points, although Brazil doesn't have as many immigrants as Australia (or other countries) so it's rare to see people speaking other languages than Portuguese.

If you are living on a country where you weren't born, you should be respectful. With the language, the culture, the people, everything actually.

My personal experience has been great: Australians haveare always nice to me. I try my best to do the same. Living in another country has been one of the most amazing experiences I've had in my life. Sometimes it's hard, but it's definitely rewarding.

Se você pensa que morar fora do Brasil é uma experiência fantástica através da qual você vai descobrir lugares lindos, conhecer pessoas diferentes, ficar imerso em culturas diferentes, ter a oportunidade de aprender um idioma novo, pagar menos por produtos e ganhar salários mais altos... você está certo! De fato vai se deparar com tudo isso! 🙂

No entanto, eu vou te contar um pouco sobre o que não é tão legal. Quando você muda de país, você pode não estar preparado para encontrar tantas coisas diferentes. E isso pode ser um pouco assustador e chocante. No começo, é bastante normal que você mal saiba pedir coisas básicas em um supermercado. Você mal vai saber escolher um prato ou pedir a conta em um restaurante.

O idioma pode ser o maior problema. Você vai se tocar que nunca se preocupou em aprender várias palavras no idioma do país, como utensílios domésticos por exemplo. Isso geralmente não é o tipo de coisa que você aprende em um curso de inglês, ao menos nos que eu frequentei.

Vai notar também que nem todas as regras gramaticais que fizeram questão que você aprendesse no curso de inglês são respeitadas. Você se sente uma criança de 3 anos, sabendo o que quer, mas nem sempre sabendo se expressar corretamente. E não é só em relação ao idioma, você estará longe de todos que conhecia e muitas vezes você deve se comportar diferente do que está acostumado.

Eu e minha esposa tivemos sorte de ter tipo meio que uma experiência preparatória: saímos do interior de São Paulo e moramos na capital por 3 anos antes de sair do país. Foi útil no sentido de saber como seria morar longe da família e amigos. Claro que lá foi diferente: é muito mais fácil fazer amigos novos, se comunicar, pouco tempo de viagem até nossa cidade natal, etc. Mas não deixou de ser uma preparação antes de vir morar fora.

Apesar de todas as vantagens que citei no começo, somados ao respeito que as pessoas têm por saberem que você é de fora... você começa uma vida nova totalmente fora da sua zona de conforto e isso pode ser bastante desafiador. Além disso, mesmo com a internet facilitando as coisas, nem sempre seus os amigos do Brasil estão disponíveis, a vida lá continua também e todo mundo tem problemas. Então ou você se adapta ou vai passar por momentos difíceis.

Não quero ser negativo, mas às vezes é preciso de um "banho de água fria" para não elevar tanto as expectativas e se desanimar quando chegar à um novo país!

A few days ago I was in CampJS, the best geek event I ever attended.

This is the official website (which is pretty cool by the way): https://campjs.com/.

Why it was the best in my opinion:

• It happened at an amazing place - close to the nature and changing the usual environment is renewable. I'd definitely recommend it!
• I had the chance to talk to a lot of other Javascript developers
• Awesome talks and workshops
• Good food and beers
• A live podcast was recorded in there

A friend of mine (@erikEcoologic) has written an awesome blog post about the event, so check it out! ;)

A special thanks to @brucestronge and to NetEngine for the tickets!

Video & photos

Uma vez escutei que não existem assuntos que não possam ser discutidos. O que existem são pessoas com as quais não se deve discutir. Apesar disso, resolvi tornar esse texto público, mesmo sendo sobre um assunto que potencialmente causa polêmica e que às vezes pode incomodar à alguns.

Eu fui criado e vivi boa parte da minha vida com minha avó, a qual é católica e bastante religiosa. Por isso, desde criança frequentei a igreja, reservando uma hora dos meus domingos para ir à missa com ela.

Lá pelos menos 14 anos, me desinteressei um pouco — acredito que isso deve acontecer com uma certa frequência na adolescência. Nunca fiquei muito tempo sem ir à uma missa, mas ao mesmo tempo nunca fui um fanático religioso, tampouco sei o tanto que gostaria sobre o assunto.

Não vou mentir, já houve uma época inclusive que eu não acreditava em mais nada, virei praticamente um ateu. Depois de muito tempo sem ter certeza do que acreditava, eu me dei conta de que eu acreditava sim em algo maior e voltei à ir à missa quase todos os domingos.

Domingo passado fui à missa com minha esposa. Fomos caminhando até a igreja e durante o caminho começamos a conversar sobre o que cada um acredita, o que “fé” significa pra cada um e outros assuntos relacionados. Durante a missa, comecei a refletir tudo isso e meio que finalmente me dei conta no que eu acredito. Tem coisas na vida que demoram um pouco para que tenhamos uma opinião formada e essa foi uma delas.

Você pode até discordar de algumas regras da igreja ou com o que os líderes religiosos falam, mas uma coisa é fato: as intenções e exemplos são na sua maioria coisas boas. Não vou entrar no assunto relacionado à dinheiro e charlatões, embora eles existam e não são poucos. O ponto é que os ensinamentos são sempre positivos, como perdão, pensar no próximo, etc.

Então finalmente formei minha opinião sobre o assunto: prefiro acreditar que existe sim um Deus. Além disso, ir à missa definitivamente me faz muito bem. Se eu estiver errado e não existir Deus nem nada, ainda assim está sendo válido, já que eu reservo esse momento na semana para ir repensar como ando levando minha vida, o que tenho feito de bom e no que eu posso melhorar como cidadão do mundo.

Conclusão: você não precisa usar a definição tradicional de Deus e de religião. Você pode simplesmente definir isso como uma forma de nos transformar em pessoas melhores.

Somos consumidores assíduos de conteúdo (offline e especialmente online). E a idéia desse post é listar o que eu tenho feito em troca disso e também incentivar aos que não fazem a considerar a idéia! :)

• Eu mantenho esse blog desde 2009 (mais de 5 anos já!) com posts sobre Ruby, Rails, Linux, macOS, mobile, etc. Eventualmente publico sobre assuntos off-topic também;
• Mantenho também um canal no YouTube com screencasts técnicos;
• No meu Github tem alguns projetos open-source, alguns bastante genéricos, como meus dotfiles e meus vimfiles ;
• Criei e mantenho alguns grupos de discussão, como Vim Users BR, Swift BR, Neo4k BR e Gxt (ExtGwt) [BR];
• Faço parte do staff que cuida dos eventos do GuruSP. Quando eu morava em São Paulo eu ajudava mais, agora ajudo apenas remotamente.
• Meu twitter é basicamente para discussões relacionadas à tecnologia;
• Para finalizar: faço sempre que possível palestras e apresentações (às vezes online) sobre ferramentas interessantes que tenho usado (infelizmente algumas foram feitas em empresas e não estão públicas).

Não ganho nada fazendo essas coisas, mas é recompensador!

Mandem seus 2 cents nos comentários!

Como muitas pessoas me perguntam como conseguir emprego aqui na Austrália, compilei uma lista com os principais sites de emprego australianos:

• https://www.linkedin.com/
• https://www.seek.com.au/
• https://au.indeed.com/
• https://au.jora.com/jobs
• https://www.gumtree.com.au/jobs
• https://www.workforceaustralia.gov.au/
• https://whoishiring.io/
• https://www.applynow.com.au/
• https://www.bluecollar.com.au/
• https://careerhub.com.au/
• https://www.careerone.com.au/
• https://www.workforceaustralia.gov.au/

Outros links relevantes:

• Site do departamento de imigração com todos os detalhes oficiais
• [Vídeo] Como consegui meu visto australiano
• Grupo no Facebook “Brasileiros que querem ir para a Austrália”
• Canal "Reza a Lenda" (YouTube)

Mais um screencast gravado; esse sobre assets e o Assets Pipeline do Rails:

Links comentados no vídeo:

• Rails Guides - Asset Pipeline
• Asset Pipeline para iniciantes by Fabio Akita

Assista outros screencasts do meu canal.

A friend of mine (who used to use Windows) has recently purchased a Mac and asked me how to use the command line on macOS. I thought I'd share here what I sent him:

• 99% of commands are identical to Linux ones, which is great as there are so many great material about it available on the Internet.
• Terminal.app from macOS is ok but far from ideal. I (and 90% of software engineers I know) use iTerm2. It's light (3mb), free, open-source, has a better UI than the native one and lots of useful features! Best terminal I've ever used.
• There's an awesome Command Line Cheat Sheet made by the Git-tower team, check it out!
• Finally, if you speak Portuguese, I've recorded a screencast explaining how to create scripts on both macOS and Linux (similar to BAT files on Windows):

Recentemente, uma pessoa me perguntou no Facebook:

Terminei meu 1º semestre de Ciência da Computação e por enquanto, tudo parece tranquilo. Mas não deixo de me preocupar quando a coisa ficar realmente "interessante".

Fico pensando naqueles códigos de tamanho imenso, na lógica maciça empregada nele. Será que não enche o saco? Resolver bugs, procurando linha por linha onde está o erro? Valeu Lucas!

Achei que valia a pena transformar minha resposta em um post:

Olá! Interessante sua pergunta. Me lembro que na época de faculdade eu fazia estas mesmas perguntas :)

Apesar de projetos / códigos crescerem, eu diria para você não se preocupar muito com isso agora. Existem ferramentas que te ajudarão a organizar tudo isso. Exemplos: testes automatizados, Git, bons editores de texto (ou IDEs), etc.

Se você quiser saber como será sua profissão futuramente, uma boa maneira é olhar os pull requests de projetos open-source e ver o que está sendo discutido lá. Aproveite e veja os códigos também, você vai ver que mesmo em um projeto grande, não existe bicho de 7 cabeças (ok, algumas raras vezes existe). A página de pull requests do Rails, por exemplo, é um bom lugar para ver isso:

Eu sou completamente apaixonado por essa área e não consigo me ver fazendo outra coisa. O bacana é que você pode trabalhar com muitas coisas diferentes, como desenvolvimento web (back-end ou front-end), desenvolvimento de jogos, desenvolvimento mobile (iOS/Android), robótica, IA, BI, entre outros - a lista é grande. É definitivamente uma área interessante para se trabalhar! :)

Claro que nem tudo são flores. Tem dia que enche o saco, tem dia que nada funciona e isso pode ser um pouco irritante. Mas nada que uma noite bem dormida e um bom café para renovar e partir para o código novamente.

Minha dica final é: siga pessoas da área. Mas não se limite somente à blogs, veja também o que bons programadores (brasileiros e gringos) estão falando nas redes sociais, leia bons livros, participe de eventos da comunidade (exemplo: GuruSP), seja curioso (pergunte sempre) e não se limite somente ao que a faculdade pode te oferecer.

Durante o período de faculdade você tem basicamente 3 fontes de aprendizado: sozinho (autodidata), através de colegas e através das aulas (professores). Todas são importantes, mas nunca siga seu caminho utilizando apenas as aulas. Ler bons livros, criar uma boa base de conhecimento na área e fazer boas amizades durante esse período é essencial. Além disso, colegas da faculdade são potenciais futuros colegas de emprego (podem te ajudar a conseguir um) ou ainda futuros sócios! :)

Versão em vídeo:

Nunca imaginei que esse vídeo chegaria a mais de 78.000 visualizações! 🙂

Por que estou escrevendo esse post?

Vários amigos tem me enviado dúvidas, então eu compilei as respostas em um único lugar, para ajudar outras pessoas que também tenham interesse.

Grupo no Facebook para saber mais

Eu criei um grupo no Facebook (já somos mais de 21 mil membros, dado atualizado em 2023) para que discussões sejam acessíveis a todos.

Já existe bastante conteúdo lá, vale a pena dar uma olhada: “Brasileiros que querem ir para a Austrália”, principalmente no post fixo.

Por que Austrália?

Quando conheci minha esposa, em 2010, descobrimos uma coisa em comum: uma vontade enorme de morar fora do Brasil, conhecer outras culturas, aprender outro idioma, vivenciar diferentes costumes e conhecer pessoas diferentes. Já no primeiro dia descobri que ela iria fazer um intercâmbio para os EUA.

Alguns anos mais tarde, alguns amigos estavam mudando pra fora do país e me motivaram a pesquisar mais sobre como tornar isso possível. No começo eu não tinha exatamente uma preferência, então comecei a fazer entrevistas em vários países: Alemanha, Canadá, Inglaterra, Austrália, entre outros. Eu estava em busca de um país onde a lingua nativa fosse o inglês, mas isso não era necessariamente um fator limitante caso surgisse uma oportunidade interessante.

O que aconteceu foi que eu participei de um longo processo seletivo em uma empresa australiana que durou mais de 2 meses. Durante esse período eu pesquisava muito sobre o país e me identificava muito. Decidi então que era pra cá que eu queria vir e meu foco se resumiu em uma palavra: “Austrália”. Infelizmente a empresa não me ofereceu um emprego. Isso aconteceu várias vezes (não somente na Austrália) e às vezes é bastante frustrante.

O LinkedIn foi fundamental nessa fase: através dele consegui várias entrevistas. Algumas poucas deram certo mas para trabalhar com algo que não era exatamente o que eu queria. Desisti. E comecei de novo. E desisti novamente. Esse ciclo se repetiu algumas vezes. Pensei em aceitar qualquer coisa. Pensei em vir como estudante e ver no que dava depois que chegasse aqui. Mas o ideal seria mesmo conseguir um emprego antes de vir.

Persisti então até que — pouco mais de um ano depois — deu certo! Serei eternamente grato pela ajuda que recebi do Ricardo Bernardeli, com o qual eu trabalho hoje. E a lição que tirei disso tudo é que não existe segredo: basta estudar bastante o idioma do país, se preparar bastante para executar o trabalho que será necessário e ter persistência, que é uma das coisas mais importantes. Lembre-se: mesmo que você esteja fazendo várias entrevistas e todas estejam dando errado, você só precisa que uma dê certo, apenas uma já é o suficiente. Persista até conseguir!

Vantagens de vir para a Austrália

1. Você não perde sua cidadania brasileira — ou seja, você pode ficar com as duas. Na Alemanha por exemplo, você perde a brasileira.
2. Dependentes podem trabalhar/estudar — Nos EUA ou Canadá por exemplo, eles não poderiam fazer isso nos primeiros anos.
3. Clima agradável — muito similar ao do Brasil.
4. Salários bons — a Austrália tem um dos melhores salários do mundo. Além disso, existe uma lei que determina o valor mínimo por ano para o salário de imigrantes.
5. Qualidade de vida — a Austrália tem o segundo melhor IDH do mundo.

Como é o processo de migração para a Austrália

Depois que você consegue um "sponsor", ou seja, uma empresa que te “patrocinará”, você precisa fazer algumas coisas, que podem variar um pouco de pessoa pra pessoa. No meu caso, resumidamente, foi:

• Traduzir uma série de documentos — precisa ser realizado por um tradutor autorizado pela imigração australiana e depois enviar estes documentos para a imigração. Tudo é feito online;
• Tirar o passaporte — caso você não tenha ainda. Se estiver perto da data de vencimento, você precisará tirar outro;
• Fazer alguns exames médicos — em clínicas autorizadas pela imigração;
• Se vacinar contra febre amarela — isso é importante, você pode ser deportado assim que chegar aqui se não tiver o comprovante de que se vacinou;
• Pagar a taxa de imigração — essa taxa muda de tempo em tempo, no momento é algo em torno de A$ 1000,00.
• Fazer o exame IELTS — para provar proficiência em inglês — a nota mínima que você precisa tirar é **4.5 **em cada uma das modalidades do exame: listening, reading, writing e speaking;
• Dinheiro — a passagem e a acomodação inicial não são muito baratas. Na verdade, o custo de vida na Austrália é alto. Mas isso é compensado pelos salários, considerados um dos melhores do mundo.
• Se livrar das coisas que você tem no Brasil — eu me casei 6 meses antes de vir e tinha ganhado vários presentes de casamento, mas precisei de me livrar de quase tudo, infelizmente;
• [Opcional] Solicitar a PID — ou seja, a “Permissão Internacional para Dirigir”. Você solicita isso no Detran (o valor varia de estado para estado — em SP custa cerca de R$ 230 e no RJ custa cerca de R$ 107) e poderá dirigir aqui enquanto sua atual habilitação brasileira for válida.

Esse processo todo demora entre 1 e 4 meses para ser aprovado (3 meses na média).

Dependentes

Eu vim com minha esposa e ela recebeu automaticamente o visto de dependente, mas para isso precisa ser casado no civil e traduzir a certidão de casamento. Certidão de união estável também conta, mas é ligeiramente mais burocratico. Ela tem os mesmos direitos que eu tenho aqui: trabalhar em tempo integral e estudar ou fazer faculdade. Se tivéssemos filhos, eles receberiam o visto de dependente também.

Quando o visto é alterado (para o visto permanente ou cidadania — por exemplo), os vistos dos dependentes são atualizados também.

A única coisa que não temos direito por enquanto é o Medicare (sistema de saúde pública) e votar nas eleições. De resto, acho que podemos tudo.

Como conseguir o visto permanente?

O blog Brazil Austrália tem publicado artigos sobre quais são as carreiras em demanda e como reconhecer sua profissão para residência na Austrália. Isso significa que você pode conseguir diretamente um visto de residência, ou seja, mesmo sem ter conseguido o visto de trabalho antes.

O blog também conta com vários outros artigos interessantes sobre salários, sobre o país e sobre a qualidade de vida daqui.

No meu caso...

O visto que eu tenho é o 457 (Work visa) e ele tem validade de 4 anos, podendo ser renovado por mais 4 até quando você ou a empresa quiserem. Porém, depois de 2 anos, a empresa que te contratou pode solicitar para a imigração que mudem o seu visto para o "visto permanente". Isso te desvincula da empresa e você poderá mudar de emprego se quiser. Ou ainda ficar desempregado sem ter que voltar pro Brasil (antes disso você seria deportado depois de 90 dias sem estar trabalhando). Se a empresa não quiser te ajudar nessa parte, você pode ainda esperar completar 4 anos aqui e solicitar esse novo visto de qualquer forma.

E a cidadania?

Depois de 4 anos morando na Austrália (e desde que o último seja com o visto permanente) você consegue a cidadania… nesse ponto você tem 100% dos mesmos direitos que um australiano. Mais informações: https://immi.homeaffairs.gov.au/citizenship/become-a-citizen/permanent-resident.

* * *

Basicamente é isso. Se tiverem alguma dúvida é só mandar!

Você pode não saber (ou esquecer às vezes), mas o Linux está muito presente na sua vida. Mesmo que você não o use diretamente como sistema operacional principal, mais da metade dos sites que você acessa está rodando em plataforma Linux. Isso inclui empresas gigantes como Google, Facebook, Twitter, Soundcloud, Amazon, Spotify, etc - a lista é muito, mas muito longa.

A maioria dos filmes que você assiste utilizam Linux para renderizar cenas extremamente complexas que às vezes levam semanas ou mesmo meses para serem renderizados.

O sistema móvel Android também é um Linux também caso você não saiba. E o seu roteador e a sua SmartTV provavelmente rodam Linux também!

Embora atualmente meu computador principal rode macOS, eu estou em contato com vários servidores que rodam Linux os quais acesso frequentemente.

Além disso, utilizei Linux como S.O. principal de 2007 à 2011, através das distros Ubuntu e OpenSUSE (além de outras que utilizei por pouco tempo, como Slackware e Debian).

Na última semana várias coisas me chamaram a atenção no mundo Linux e esse é o motivo desse post:

1. O último episódio do podcast do Hack 'n' Cast (v0.3) foi uma introdução ao Linux e foi muito bom, vale a pena escutar: http://mindbending.org/pt/hack-n-cast-v03-introducao-ao-gnulinux.

2. Um amigo que é programador disse que nunca (palavra forte!) usaria Linux porque nem criar um script similar ao batch do "Janelas" ele conseguia. Bom, pensando que isso pudesse ser útil para mais pessoas, gravei um screencast ensinando como criar scripts no Linux e no OS X macOS: http://youtu.be/W84Ok6XGnow.

3. Assisti à uma ótima palestra chamada "Linux Sucks": http://youtu.be/5pOxlazS3zs.

4. Lembrei e reli o excelente ponto de vista do @Pothix sobre porque ele deixou o macOS e voltou a usar Linux: https://pothix.com/mac-linux/.

5. Para finalizar (e descontraír), há um tempo atrás eu ganhei de um amigo que trabalha na RedHat um chapél vermelho (red hat, rá!), o qual foi parar na cabeca do Tux que eu tenho na minha estante, vide fotos abaixo. Ficou bem bacana! :)

Bom, essa não é a primeira vez que eu escrevo sobre Linux e também não será a última.

Linux é muito mais importante do que as pessoas pensam. Pense 2 vezes antes de subestimar o sistema do pinguim! :)

Não me lembro onde encontrei esse texto. Mas gostei muito! :-)

Saudade é provavelmente a expressão mais significativa e típica da alma brasileira, uma combinação de anseios e desejo, misturado com nostalgia e melancolia. Saudade é o desejo por algo ou alguém que está longe ou é inatingível. Os brasileiros têm saudades quando vivem no exterior e sentem falta do lar, quando estão separados de seus entes queridos, ou quando lembram dos bons e velhos tempos. Mas saudade não é apenas uma resposta emocional a uma situação ou memória. É um estado de espírito no qual os brasileiros procuram prosperar.

English version

Saudade is probably the most significant and typical expression of the Brazilian soul, a combination of longing and desire, mixed with nostalgia and melancholy. Saudade is the desire for something or someone who is far away or is unattainable. Brazilians have saudades when they live abroad and get homesick, when they are separated from a loved one, or when they recall good old times. But saudade is not merely an emotional response to a situation or memory. It is a state of mind that Brazilians seek and thrive on.

I've been worked on a small open-source project. I'm talking about ruby_wiki, a simple wiki built with Ruby on Rails.

If you're interested, feel free to fork and contribute to the project.

Do you have a legacy app still running on Rails 2?

There are several reasons to migrate your application to a newer version of Rails: improving security, using a better syntax, taking advantage of new features, and ensuring compatibility with most current gems, which typically require Rails 3 or higher. However, this process can be challenging, especially for large projects. It's worth noting that many projects are still running on Rails 2 today (in 2014).

But there's one important thing you can (and should) do! I'm talking about using the newest Ruby version. Yes, I'm serious. When I wrote this post, the latest Ruby version was 2.1.1, and it's not too difficult to get it working smoothly with Rails 2.

Obviously, it's better if you have good test coverage.

That said, let's break it down into a few steps:

Replacements

• Gemfile

Rails 2 apps don't use Bundler by default. If you're not already using Bundler to manage your gems, you should check this guide to set it up.

## There's no way to know for sure if future Ruby versions will work,
## but so far the current one does:
ruby "2.1.1"
## The same for the `rake` gem:
rake "10.1.1"
## You might need the `iconv` gem:
gem "iconv"

• Rakefile

## Replace:
## require "rake/rdoctask"
## with:
require "rake/task"

• config.ru

## Replace:
## require "config/environment"
## with:
require File.dirname(__FILE__) + "/config/environment"

• FasterCSV ➙ CSV

Replace all FasterCSV constants with CSV. Also, include require "csv" to relevant files (or include the require to your config/environment.rb file).

Inclusions

• config/environment.rb

## Include this before the `Rails::Initializer.run` line:
if RUBY_VERSION >= "2.0.0"
  module Gem
    def self.source_index
      sources
    end
    def self.cache
      sources
    end
    SourceIndex = Specification
    class SourceList
      # If you want vendor gems, this is where to start writing code.
      def search(*args); []; end
      def each(&block); end
      include Enumerable
    end
  end
end

• config/initializers/paperclip.rb

## The patches below are needed when using an old version of PaperClip + Ruby 2.x
## https://github.com/thoughtbot/paperclip/issues/262
## https://github.com/thoughtbot/paperclip/commit/1bcfc14388d0651c5fc70ab9ca3511144c698903
module Paperclip
  class Tempfile < ::Tempfile
    def make_tmpname(basename, n)
      extension = File.extname(basename)
      sprintf("%s,%d,%d%s", File.basename(basename, extension), $$, n.to_i, extension)
    end
  end
end
module IOStream
  def to_tempfile
    name = respond_to?(:original_filename) ? original_filename : (respond_to?(:path) ? path : "stream")
    tempfile = Tempfile.new(["stream", File.extname(name)])
    tempfile.binmode
    self.stream_to(tempfile)
  end
end

New files

• config/initializers/ruby2.rb

## This is a very important monkey patch to make Rails 2.3.18 to work with Ruby 2+
## If you're thinking to remove it, really, don't, unless you know what you're doing.
if Rails::VERSION::MAJOR == 2 && RUBY_VERSION >= "2.0.0"
  module ActiveRecord
    module Associations
      class AssociationProxy
        def send(method, *args)
          if proxy_respond_to?(method, true)
            super
          else
            load_target
            @target.send(method, *args)
          end
        end
      end
    end
  end
end

• config/initializers/rails_generators.rb

It'll prevent Rails migration generator from stop working, otherwise you'll receive the following error message:

undefined local variable or method `vars' for # Rails::Generator::Commands::Create

(Thanks to Mr. S and jnwheeler44 for helping me to fix this one)

## This is a very important monkey patch to make Rails 2.3.18 to work with Ruby 2+
## If you're thinking to remove it, really, don't, unless you know what you're doing.
if Rails::VERSION::MAJOR == 2 && RUBY_VERSION >= "2.0.0"
  require "rails_generator"
  require "rails_generator/scripts/generate"
  Rails::Generator::Commands::Create.class_eval do
    def template(relative_source, relative_destination, template_options = {})
      file(relative_source, relative_destination, template_options) do |file|
        # Evaluate any assignments in a temporary, throwaway binding
        vars = template_options[:assigns] || {}
        b = template_options[:binding] || binding
        # this no longer works, eval throws "undefined local variable or method `vars'"
        # vars.each { |k, v| eval "#{k} = vars[:#{k}] || vars['#{k}']", b }
        vars.each { |k, v| b.local_variable_set(:"#{k}", v) }
        # Render the source file with the temporary binding
        ERB.new(file.read, nil, "-").result(b)
      end
    end
  end
end

RSpec

• Make sure you're using the last compatible version with Rails 2.3.18:

gem "rspec", "1.3.2"
gem "rspec-rails", "1.3.4"

• Remove the file script/spec

• Remove the following lines from the lib/tasks/rspec.rake file:

gem "test-unit", "1.2.3" if RUBY_VERSION.to_f >= 1.9
rspec_gem_dir = nil
Dir["#{Rails.root}/vendor/gems/*"].each do |subdir|
  rspec_gem_dir = subdir if subdir.gsub("#{Rails.root}/vendor/gems/","") =~ /^(\w+-)?rspec-(\d+)/ && File.exist?("#{subdir}/lib/spec/rake/spectask.rb")
end
rspec_plugin_dir = File.expand_path(File.dirname(__FILE__) + "/../../vendor/plugins/rspec")
if rspec_gem_dir && (test ?d, rspec_plugin_dir)
  raise "\n#{'*'*50}\nYou have rspec installed in both vendor/gems and vendor/plugins\nPlease pick one and dispose of the other.\n#{'*'*50}\n\n"
end
if rspec_gem_dir
  $LOAD_PATH.unshift("#{rspec_gem_dir}/lib")
elsif File.exist?(rspec_plugin_dir)
  $LOAD_PATH.unshift("#{rspec_plugin_dir}/lib")
end

Ruby syntax

• Ruby syntax has changed a bit, especially from 1.8.x to 1.9.x.

# Replace:
when "foo": bar
# with:
when "foo" then bar

The behaviour for protected methods in new Ruby versions is a little bit different. See more in this post.

# In some cases, you might need to replace:
respond_to?(:foobar)
# with:
respond_to?(:foobar, true)

# Replace:
order: [:day, :month, :year]
# with:
order:
  - :year
  - :month
  - :day

Ruby changes

• The default encoding for Ruby 2.0 (or higher) is UTF-8

Remove all the code similar to:

# encoding: utf-8

Or:

$KCODE = "UTF-8"

Update on July 27th, 2014

Check out the insightful comments below by Gabriel Sobrinho, Kyle Ries, and Greg. They offer valuable insights!

Conclusion

Different project might have different issues, but I hope this little guide helps you to use new Ruby versions on your legacy Rails applications!

Acabei de escrever um comentário em um post chamado "E se você pudesse mudar de país?" (o qual recomendo muito a leitura):

Sensacional seu artigo, Paula!

Estou morando na Austrália com minha esposa há 5 meses e estamos adorando. É realmente uma experiência incrível, a qual recomendo a todos, mesmo que seja apenas por alguns poucos anos.

Idioma, leis, costumes e pessoas diferentes podem assustar um pouco até os menos conservadores, mas raramente se torna um problema real. E algumas lendas como “gringos não são receptivos e amigáveis como os brasileiros” são rapidamente desmentidas.

Claro que ficar longe da família e dos amigos — como você disse — não é fácil, mas nada que não seja resolvido fazendo (ou recebendo) uma visita de vez em quando.

Sucesso e felicidades para vocês!

E a resposta dela:

Obrigada, Lucas! Realmente ouvi muitas histórias sobre a hostilidade holandesa, vim pra cá morrendo de medo… e todos que encontrei foram muito acolhedores e simpáticos, inclusive dispostos a ajudar quando necessário. Boa sorte pra você e sua família na Austrália, deve ser incrível morar aí! *-*

Em agosto desse ano, eu escrevi sobre como estava sendo minha experiência com o Android. Quatro meses depois, voltei a usar iOS. Vamos aos fatos: eu pretendia ficar mais um tempo com ele, mas o derrubei e a tela parou de funcionar completamente. Como eu já estava bastante ansioso pra voltar a usar o iOS/iPhone, aproveitei a oportunidade e comprei um iPhone 5s.

Mas o Android estava tão ruim assim?

Não. Antes de mais nada, vou ser sincero:

Android é sim um excelente sistema!

Conforme escrevi nesse post, eu tinha um Samsung S4 e o Android estava me atendendo perfeitamente bem no começo, mas depois de um tempo comecei a ter alguns problemas com a ROM original (da Samsung): lentidão, o fato de eu não poder atualizar, etc. Essa imagem que mostra bem claramente o problema das atualizações do Android:

Antes que o Jonas me xingue, algo que deve ficar claro: não devemos resumir a experiência de usar Android somente se baseando na experiência de usar um Samsung. Mas o fato é que o Samsung S4 é um dos aparelhos mais utilizados atualmente, por isso achei que eu não fosse ter esse tipo de problema.

Resolvi então colocar uma versão pura do Android (vale ressaltar que essa ROM não era oficial). Ficou bom no começo, mas depois de um tempo, ficou pior: as apps davam crash toda hora e o sistema como um todo ficou lento. Tentei voltar para a ROM da Samsung (ou até alguma outra - exemplo: Cyanogenmod), mas era tanta gambiarra que desisti.

O que eu ganhei voltando para o iOS/iPhone?

• Podcasts - uma app decente para o que mais faço com o meu celular: escutar podcasts. Não encontrei nenhuma app (free ou pago) que me atendesse 100% no Android. E isso o Podcasts da Apple faz muitíssimo bem. A propósito, aproveite para conhecer o meu podcast;
• iOS 7 - o novo sistema está muito estável e muito bonito. O que mais eu posso querer? 🙌
• Gerenciamento de arquivos - Não tenho mais que me preocupar em que diretório os arquivos estão (e não saber se estou desperdiçando espaço);
• Find my friends - as opções do Android não eram muito boas (Testei o "Life360" e alguns outros);
• Calandários perfeitamente sincronizados - Várias items do meu calendário estavam no iCloud. Agora calendários do iCloud, do Google e do Facebook estão perfeitamente sincronizados;
• Sensação de controle do que está realmente acontecendo no aparelho - Em vários momentos você tem a noção de perder esse controle no Android;
• Fluidez - Somando o processador A7 (64 bits 🤩) e a boa integração entre hardware e software, a fluidez / estabilidade do sistema como um todo ficam fantásticas;
• Camera com suporte à 120fps (slow motion) - simplesmente sensacional;
• Earpods - os novos fones são ótimos;
• Touch ID - Sem muito o que falar, é sensacional também.

Uma coisa interessante e que antes era exclusivo do Android é o relatório de consumo da banda 4G separado por app, o qual agora está disponível também no iOS 7.

O que eu perdi deixando o Android

• Notificações - O LED, os mini-ícones perto do relógio e a sincronia perfeita com as apps - tudo isso somados fazem as notificações do Android serem melhores que as do iOS;
• Relatório de consumo da bateria - Isso simplesmenete não existe no iOS;
• Instalar apps via web - sinto falta disso, funciona muito bem no Android;
• Teclado swipe - fiquei mal acostumado com esse teclado também. Mais um ponto pro Android.

Conclusão

Das principais opções atuais, iOS/iPhone é o que me atende melhor.

"Random hacks of kindness" - ou simplesmente "RHOK" - que pode ser traduzido como "Hacks aleatórios de bondade" é um evento (aka. "hackathon") sem fins lucrativos que acontece no mundo inteiro, onde profissionais de tecnologia ajudam a criar projetos e solucionar problemas de organizações que trabalham para um mundo melhor.

Quem participa não recebe nada por isso, é uma contribuição voluntária, como forma de boa ação.

Esse ano estou participando do evento de Brisbane (Austrália) e estamos ajudando a QueenslandKids, uma organização que ajuda crianças carentes e especiais.

Para saber mais sobre o evento: rhokbrisbane.org.

Fotos:

"Movember" — conhecido como "Novembro azul" no Brasil — é uma campanha realizada todo mês de novembro para a conscientização sobre a importância da prevenção e do diagnóstico precoce do câncer de próstata e outras doenças masculinas.

Para participar da campanha, você pode fazer duas coisas:

1. Deixar o bigode crescer;
2. Fazer doações para uma instituição.

Aqui na Austrália é uma tradição forte! Muita gente está usando um bigodão! :)

E esse é o time que eu estou participando (pessoal da empresa): http://moteam.co/netengine!

Você pode ler mais a respeito na Wikipedia.

Gostaria de começar esse post dizendo que vou tentar ser o mais imparcial possível, não sendo fanboy de nenhuma empresa / aparelho / sistema operacional.

Eu não vou comparar somente os sistemas operacionais, mas sim a experiência do hardware com software, ou seja, a integração com o aparelho também.

Motivação

Eu parei de usar Windows quando o Vista foi lançado. Essa versão tinha muitos problemas e eu resolvi dar uma chance ao pinguim (aka. Linux), principalmente pelo fato de nunca ter usado ele full-time antes. Muitas coisas eram diferentes (hoje em dia essa diferença é menor), tive que aprender coisas novas e largar velhos costumes para trás. Mas depois de algum tempo, notei que valeu muito a pena e que eu não voltaria atrás. Alguns anos mais tarde, mudei novamente para o OS X macOS (o qual continuo usando até hoje) e vejo que essa experiência de ter usado os 3 sistemas diferentes só me trouxe benefícios.

Eu expliquei tudo isso para demonstrar que essa motivação foi basicamente a mesma com os sistemas operacionais móveis. Depois de quase 3 anos usando iOS e perto da versão 7 ser lançada, decidi que era hora de experimentar um outro mundo. E como eu nunca tinha usado Android full-time antes (apenas havia brincado com aparelhos de amigos), então era hora de mudar.

Hora de mudar

Decidi então comprar um Samsung Galaxy S4.

Procurei pela versão com o Android puro (aka. "Google Play Edition"), mas como ela ainda não estava a venda aqui, comprei a versão com a rom da Samsung mas pouco tempo depois desisti e segui esse tutorial para instalar a rom pura do Google. A vantagem é que o sistema fica mais fluído (mais rápido, dá menos "travadas") e não vem com vários aplicativos inúteis que a Samsung e a operadora do celular te obrigam a ter (uma vez que você não pode apagá-los).

O que eu gostei

1. Notificações + LED + atalhos rápidos

Vou começar com algo que eu uso muito em ambos os sistemas: notificações. Conheço pessoas que simplesmente não se importam muito com elas, mas esse definitivamente não é o meu caso. Esse é um ponto forte no Android: as notificações são muito boas. No iOS você pensa que isso funciona bem até ver como isso funciona no Android, principalmente porque as notificações e as aplicações são bem sincronizadas.

Para cada item você pode ter alguns botões de funções rápidas (exemplo: ao receber um email, você pode clicar nos botões "responder" ou "arquivar") ou ainda pode ver mais detalhes sobre aquele item específico, tocando e deslizando o dedo para baixo naquele item. Outro exemplo legal é quando você tira um screenshot e recebe uma notificação, na qual você pode apenas tocar para já abrir a nova imagem.

Uma diferença muito boa são os ícones na barra superior, com um resumo das notificações:

Outra coisa bem bacana é o "Pulse notification light". Acredito que nem todo aparelho tenha isso, mas o S4 tem e faz muita diferença. Ao chegar uma nova notificação, ao invés de a tela ligar e mostrar o que chegou, você pode configurar seu aparelho para ele simplesmente piscar o LED. O mais legal é que você pode configurar o LED pra ficar de uma cor para cada tipo de notificação: chamada perdida, SMS, Email, Hangouts, Facebook, Twitter, WhatsApp, etc.

Algo bem últil e que agora o iOS 7 também tem (embora falte um atalho para o "Settings") são os atalhos rápidos, que ficam na área de notificações:

2. Tela grande (5") Full HD

Segundo a Apple, a vantagem de um aparelho um pouco menor é poder tocar todos os cantos da tela com a mesma mão que segura o aparelho. Sim, isso faz sentido, mas a vantagem de ter uma tela grande (5 polegadas) e com boa qualidade é ainda maior. E a adaptação é relativamente rápida.

3. Teclado swipe

Assunto polêmico: há quem ame, há que nem ligue. Apesar de eu não achar ele tão mais rápido assim, é mais prático e confortável digitar apenas deslizando o dedo. Mesmo você errando algumas letras, ele tem um algorítimo inteligente e corrige. Gostei muito!

4. Lookout

Uma app que faz toda a diferença: Lookout. Ele tem vários recursos: localizar seu celular (similar ao "Find my iPhone"), se alguém errar 3 vezes a senha de desbloqueio, ele tira uma foto da pessoa e manda no seu email (ele também faz isso quando sua bateria está quase acabando, só que usa o GPS pra saber sua localização e te manda essa informação também), faz backup de contatos, fotos, etc, é anti-virus. Ah, e sim, é free.

5. Botões "menu" e "voltar"

Antes eu achava besteira, mas usando diariamente você nota que os botões "menu" e "voltar" são bem práticos (principalmente o último). No S4 eles ficam melhor ainda, porque são dois sensores capacitivos, não botões físicos. E eles ficam apagados até que você toque neles, o que deixa o design do aparelho mais clean.

6. Customização, flexibilidade e liberdade

O Android é extremamente personalizável (às vezes mais do que deveria). Pra começar, a possibilidade de instalar launchers diferentes é sensacional. Launcher basicamente é a tela inicial do seu aparelho, o gerenciador de widgets, temas, etc. Estou usando o Apex e gostando muito.

É sempre bom poder customizar, embora minha tela inicial seja bem parecida com a default:

Você também pode instalar gerenciadores de torrents, emuladores, terminal com acesso root (esse dá um pouco de trabalho, mas dá pra fazer), entre outras coisas. Isso é liberdade!

7. Relatório de uso da bateria

No Android você pode configurar para receber notificações quando a bateria estiver totalmente carregada ou quando estiver acabando. Você também pode facilmente ver o que está consumindo mais bateria:

8. Relatório de uso do 3G / 4G

É possível ver quanto cada app está gastando na sua rede de dados 3G ou 4G. Essa funcionalidade é bastante flexível, permitindo configurar um limite de uso, configurar uma notificação quando você estiver perto de atingir limite, configurar em que dia a sua operadora vai recomeçar a contagem de uso e até mesmo ver quanto cada app gasta em "foreground" e em "background", ou seja, quanto cada app usou enquanto você estava com ela aberta e quanto ela gastou enquanto ela estava fechada (usando "pull notifications", por exemplo), respectivamente.

9. Instalar apps remotamente

Você pode entrar no site do Google play (aka. App Store do Google) usando seu computador, buscar e escolher o aplicativo que quer instalar, selecionar o device no qual você quer instalar o app (no caso de você ter mais de um), clicar em "Instalar" e pronto. Depois de 3 segundos, o device começa a baixar e instalar a app sozinho. Muito útil.

Depois, no device:

10. Google Now

Ok, o Google mantém uma versão do Google Now pro iOS, mas é diferente. Digo isso porque no Android o Google Now é mais integrado e no geral funciona melhor.

11. Quantidade de apps gratuitas

Até hoje, todas as apps que eu instalei foram gratuitas. Não vejo problema nenhum em pagar por apps, mas ao contrário do iOS, a maioria das apps não custam nada.

12. SD card

Não é algo imprescindivel, mas é interessante. Principalmente porque você configurar coisas como: todas as fotos e vídeo que você tirar podem ir automaticamente para o cartão SD e não para o armazenamento interno do aparelho.

13. Câmera

As duas câmeras (frontal e traseira) do S4 são muito boas. E o software nativo do Android também é bem bacana, contando com algumas opções avançadas na hora de tirar foto e modos interessantes, como fotos 360º e panorâmicas.

14. Sistema inteligente

De vez em quando eu ainda me surpreendo com o Android. No geral, o sistema é muito inteligente e facilita algumas coisas. Um exemplo disso é: eu configurei meu device para subir todas as fotos que eu tiro automaticamente para minha conta do Dropbox. Mas quando ele nota que sua bateria está baixa, ele para de de fazer essas coisas para evitar que sua bateria acabe de vez.

15. Alguns detalhes interessantes

Para finalizar a lista de coisas que eu gostei, o Android é mais detalhista que o iOS:

• Você pode configurar apps padrões: Chrome é meu navegador padrão, Gmail é meu cliente de email padrão e VLC é meu player de vídeo padrão, etc;
• Exibição de detalhes de arquivos: extensão, tamanho, resolução de fotos, duração de vídeos, etc;
• Exibição de quanto de memória cada app está usando de ram;
• Exibição de quanto de memória cada app está usando de cache;
• Gráfico de armazenamento interno / SD card: que tipo de arquivos está gastando mais espaço no seu device;
• Etc.

O que eu não gostei

1. Fluidez

Apesar de ter um hardware supostamente superior, o S4 perde no fator "fluidez" para o iPhone. Todas as animações, efeitos e o tempo de resposta dos iPhones são melhores na maioria dos casos. O pior de tudo é o rotação da tela: você vira o device e várias vezes a tela não vira junto. Aí você chacoalha um pouco e a tela vira. Isso chega a ser irritante às vezes.

2. Fones

Os fones que vem com o S4 são horríveis. Claro que isso é apenas a minha opnião. Acabei comprando um fone da Sony. A desvantagem é que você perde os controles de volume e play / pause que existem no fone que acompanha o S4. Pensei em comprar um da Apple, mas já os testei e tais controles também não funcionam.

3. Podcasts

Escutar podcasts no smartphone é uma das coisas que mais faço diariamente. Testei os 3 aplicativos mais famosos de podcasts no Android e nenhum é grande coisa. O único que é razoavelmente usável é o Podcast Addict. Ele tem dois problemas: o primeiro - não tão grave - é que ele oferece muitas opções e você tem que ver uma lista gigante de configurações para deixar do jeito que você gosta (convention over configuration - deveria ser o contrário). O segundo problema é pior: quando você está escutando um episódio, o áudio começa a falhar e às vezes para do nada. Isso é bem frequente, infelizmente.

4. Google Play - uma loja muito liberal

A Apple é burocrática e demora um pouco para autorizar a entrada de apps na sua loja. Mas isso tem o lado bom: raramente entram apps realmente ruins. Já na Google Play, tem muita porcaria, incluindo malwares. No geral não chega a ser um problema, mas você deve ser cuidadoso.

5. Updates

Como falei no começo do post, instalei uma rom com o Android puro e não estou usando a que a Samsung manda de fábrica. Isso significa que eu não posso simplesmente instalar as atualizações do Google quando elas saem. Pra ser sincero, eu não sei nem quando vou poder (não pesquisei como isso funciona). Mesmo se eu estivesse usando a rom da Samsung, ela demora (às vezes muito) pra liberar o update, como por exemplo agora que o Android 4.3 já foi lançado há mais de um mês e ainda não está disponível para quem usa a rom que já vem no device.

6. Apps no geral são mais feias e com UX mal pensadas

Notem que estou generalizando. Já considerando as apps que eu mais uso, isso não chega a incomodar.

Coisas que não estão nas listas acima

Coisas que eu não comentei nas duas listas acima foi - ou porque são similares ao iOS / iPhone - ou não fazem diferença para mim.

Mitos

Alguns mitos sobre ambos os sistemas:

O Android não se integra tão bem com o Mac quanto o iPhone

Ok, essa integração pode não ser tão boa quando comparado com o iPhone, principalmente pelo fato de não ter iCloud, mas isso definitivamente foi um problema pequeno. Para tudo tem uma boa alternativa (sendo que maioria eu já usava). Nesse artigo, tem uma sessão chamada "Apple Lock-in?" que explica o que ele usa pra melhorar essa integração.

No Android, as apps fecham sozinhas frequentemente (crash)

Ouvi muita gente falando isso antes de eu começar a usar. Definitivamente não é verdade, é bem raro acontecer.

No iPhone / iOS você não tem liberdade

Ok, agora no Android você tem, inclusive tem acesso root ao sistema (que por baixo dos panos é um Linux). Grande coisa! O que você vai fazer agora? Basicamente nada demais :)

Uma câmera com 90 megapixels é melhor que uma que tem 85

Obviamente é um mito. A câmera do novo iPhone 5S continua com os mesmos 8 megapixels do iPhone 5 mas é bem superior! E eu não acho que ela fica devendo pra nenhum smartphone que tenha 13 ou 20. Sério!

Conclusão

Já estou usando Android há pouco mais de um mês, o que foi suficiente para notar as vantagens e desvantagens. Gostei muito do iOS 7 (minha esposa tem um iPhone 5 e eu uso ele de vez em quando), mas por enquanto não pretendo voltar a usar iOS / iPhone; estou satisfeito com o meu Android.

Nesse post, eu basicamente listei o que gostei mais e menos em relação ao sistema operacional da Apple e no final das contas, ambos tem excelentes ecosistemas: conjunto de ferramentas, loja de aplicativos e design.

Então fica a dica: não tenha medo de experimentar o que você ainda não usou :)

Atualização

Em dezembro de 2013, eu acabei voltando a usar iOS/iPhone e também escrevi um post explicando o motivo:

"Por que eu voltei a usar iOS/iPhone".

Estou iniciando uma novíssima fase em minha vida. Acabei de me mudar para Brisbane, Austrália!

Vim com minha esposa Aline, que topou o desafio de viver em um país maravilhoso, mas que fala inglês, com uma cultura ligeiramente diferente, sem conhecer nada nem ninguém.

Eu escrevi um post agradecendo àqueles que nos ajudaram e também algumas fotos daqui.

Além disso, conforme prometido ao @cassiuspacheco, escrevi um post mais completo, contando como foi o meu processo de imigração: clique aqui para ler.

Finalmente chegou a hora: eu e Aline (minha esposa) estamos nos mudando para a Austrália. Embarcaremos amanhã à noite. Mas antes de viajar, eu gostaria de agradecer à algumas pessoas:

Primeiramente à Aline, minha esposa e companheira, por sempre me apoiar, por me fazer tão feliz e por topar mudar para o outro lado do mundo;

Ao Vitor Pellegrino e ao Xis (Thiago Aléssio), por servirem como exemplo e me motivarem a correr atrás desse meu sonho;

Ao Ricardo Bernardeli e à Raissa Mantovani, pelas dicas de como conseguir um emprego fora, pela ajuda com a burocracia do visto e por todo amparo que estão nos dando nesse novíssimo mundo;

À minha família e à família da Aline, por todo apoio, mesmo sabendo que ficaremos mais longe;

Aos amigos e colegas de trabalho, pelo apoio nessa decisão e por serem pessoas tão especiais para mim, mesmo quando distantes.

Entrei na brincadeira e desenhei minha vida:

O Rails 4 acabou de ser lançado e tem várias novidades bacanas! Aprenda o que mudou, o que são Strong Parameters, turbolinks, etags, requests com streaming e outras coisas interessantes.

Apresentei um webinar sobre as novidades do Rails 4. A apresentação foi gravada e está disponível no site da Eventials.

Seguem os slides:

Às vezes precisamos contabilizar qual a frequência de objetos em um array usando Ruby.

Por exemplo, um array ["dog", "dog", "cat"] tem dois elementos "dog" e um "cat". Para transformar isso em um hash com os totais, existem as seguintes alternativas, dependendo da versão do Ruby que você esteja utilizando:

Ruby 2.7 ou superior

["dog", "dog", "cat"].tally
# => { "dog" => 2, "cat" => 1 }

Ruby 2.2 até 2.6

words = ["dog", "dog", "cat"]
Hash[words.group_by(&:itself).map { |word, words| [word, words.size] }]
# => { "dog" => 2, "cat" => 1 }

Ruby 2.1 ou mais antigo

Hash[words.group_by { |w| w }.map { |word, words| [word, words.size] }]
# => { "dog" => 2, "cat" => 1 }

Se você achou isso útil, deixe um comentário abaixo me contanto! 😉

No ano passado, eu comecei a gravar alguns vídeos pra ajudar quem gostaria de começar a programar com Ruby on Rails. Por enquanto são 3 screencasts apenas, mas já é o suficiente pra quem gostaria de começar.

Mandem feedback, com sugestões, críticas ou até mesmo dúvidas.

Espero que tenham gostado :)

Ontem participei do 15º Encontro Locaweb em Curitiba-PR. O evento foi interessante e bem organizado e não estou dizendo isso só porque trabalho aqui :)

Assisti as seguintes palestras:

• Fábio Ricotta - "Usando SEO para alavancar suas visitas e negócios"
• Diego Eis - "Guia de Sobrevivência"
• Murilo Gun - "O segredo do fracasso"
• Silvio Meira - "Empreendedorismo Digital"
• Luli Radfahrer - "Internet das coisas, computação em nuvem e tendências 2013"

Todas foram boas, mas as apresentações do Ricotta, do Eis e do Luli me surpreenderam, foram muito boas mesmo!

Tiramos essa foto aí na hora do almoço, no Jardim Botânico. Da esquerda pra direita: Ítalo Oliveira, Diego Eis, eu, Bruno Batalha e Marcos Oliveira:

Que venha o 16º encontro! :)

Esse é o segundo screencast que eu faço para o blog e novamente é sobre Vim (assista ao primeiro aqui).

Esse ficou bem mais curto (tem apenas 5 minutos) e vai direto ao ponto. Espero que gostem!

Links relevantes:

• vim-abolish
• Meus vimfiles

Por favor, mandem feedback sobre o que acharam!

Eu gosto muito de escutar podcasts. Escuto muitos, sobre variados temas, alguns em português, outros em inglês, alguns sobre áreas totalmente diferentes da que eu trabalho, alguns nostálgicos, alguns pra melhorar meu inglês e por aí vai.

Sempre que encontro com alguém que também gosta/escuta, rola as perguntas sobre qual cada um escuta, sobre o que se trata, quais amigos em comum escutam, qual o nível de qualidade, entre outras dúvidas.

Foi aí que surgiu a idéia de criar o site MyPodcasts.info, um site onde você pode cadastrar tudo isso e no final ter uma URL publica para passar para os interessados nos podcasts que você escuta.

Há 2 meses atrás eu o coloquei no ar e logo em seguida o liberei como open-source: github.com/lucascaton/mypodcasts.info. Então, sintam-se a vontade para usar o site e contribuir com ele.

Seguem alguns screenshots:

Ah sim! O site é responsivo:

Atualização em Fev/2014:

O site mypodcasts.info chegou ao fim, apesar de eu ainda ter planos de reativá-lo um dia. No momento, infelizmente não tenho tempo pra mantê-lo.

Ele sempre foi e continuará sendo open-source. Encontre o código-fonte em github.com/lucascaton/mypodcasts.info. Se tiver interesse em manter o projeto, envie um comentário no final desse post.

Obrigado a todos que usaram o site e mandaram feedbacks.

I've just found this amazing Ruby script!

In order to run it yourself, just create a Ruby file called a.rb with the following content:

v=0000;eval$s=%q~d=%!^Lcf<LK8,                  _@7gj*LJ=c5nM)Tp1g0%Xv.,S[<>YoP
4ZojjV)O>qIH1/n[|2yE[>:ieC       "%.#%  :::##"       97N-A&Kj_K_><wS5rtWk@*a+Y5
yH?b[F^e7C/56j|pmRe+:)B     "##%      ::##########"     O98(Zh)'Iof*nm.,$C5Nyt=
PPu01Avw^<IiQ=5$'D-y?    "##:         ###############"    g6`YT+qLw9k^ch|K'),tc
6ygIL8xI#LNz3v}T=4W    "#            #.   .####:#######"    lL27FZ0ij)7TQCI)P7u
}RT5-iJbbG5P-DHB<.   "              ##### # :############"   R,YvZ_rnv6ky-G+4U'
$*are@b4U351Q-ug5   "              #######################"   00x8RR%`Om7VDp4M5
PFixrPvl&<p[]1IJ   "              ############:####  %#####"   EGgDt8Lm#;bc4zS^
y]0`_PstfUxOC(q   "              .#############:##%   .##  ."   /,}.YOIFj(k&q_V
zcaAi?]^lCVYp!;  " %%            .################.     #.   "  ;s="v=%04o;ev"%
(;v=(v-($*+[45,  ":####:          :##############%       :   "  ])[n=0].to_i;)%
360)+"al$s=%q#{  "%######.              #########            "  ;;"%c"%126+$s<<
126}";d.gsub!(/  "##########.           #######%             "  |\s|".*"/,"");;
require"zlib"||  "###########           :######.             "  ;d=d.unpack"C*"
d.map{|c|n=(n||  ":#########:           .######: .           "  )*90+(c-2)%91};
e=["%x"%n].pack   " :#######%           :###### #:          "   &&"H*";e=Zlib::
Inflate.inflate(   "  ######%           .####% ::          "   &&e).unpack("b*"
)[0];22.times{|y|   "  ####%             %###             "   ;w=(Math.sqrt(1-(
(y*2.0-21)/22)**(;   " .###:             .#%             "   ;2))*23).floor;(w*
2-1).times{|x|u=(e+    " %##                           "    )[y*z=360,z]*2;u=u[
90*x/w+v+90,90/w];s[(    " #.                        "    ;y*80)+120-w+x]=(""<<
32<<".:%#")[4*u.count((     " .                   "     ;"0"))/u.size]}};;puts\
s+";_ The Qlobe#{" "*18+ (       "#  :#######"       ;"Copyright(C).Yusuke End\
oh, 2010")}";exit~;_ The Qlobe                  Copyright(C).Yusuke Endoh, 2010

Then, run the following line on your terminal:

while true; do clear; ruby a.rb | tee b.rb; sleep 0.2; mv -f b.rb a.rb; done

Via Hatena

É comum na maioria das consultorias brasileiras de software, principalmente as que contratam funcionários através de regime PJ, solicitarem o relatório de horas trabalhadas mês a mês. Como esse era o meu caso no ano passado, eu criei um pequeno sistema para facilitar esse controle.

Eu havia criando essa funcionalidade dentro do próprio código do meu site, mas como várias pessoas gostaram e me pediram o código, eu o extraí para um projeto a parte e o liberei como open-source:

https://github.com/lucascaton/time_clock

Screenshots

Sinta-se à vontade para usar, melhorar e divulgar.

I've found the following text here and thought it'd be nice to share it with you. Hope you enjoy it as much as I did :)

Hello, I am a compiler.

I just scanned thousands of lines of code while you were reading this sentence. I browsed through millions of possibilities of optimizing a single line of yours using hundreds of different optimization techniques based on a vast amount of academic research that you would spend years getting at. I won't feel any embarrassment, not even a slight ick, when I convert a three-line loop to thousands of instructions just to make it faster. I have no shame to go to great lengths of optimization or to do the dirtiest tricks. And if you don't want me to, maybe for a day or two, I'll behave and do it the way you like. I can transform the methods I'm using whenever you want, without even changing a single line of your code. I can even show you how your code would look in assembly, on different processor architectures and different operating systems and in different assembly conventions if you'd like. Yes, all in seconds. Because, you know, I can; and you know, you can't.

P.S. Oh, by the way you weren't using half of the code you wrote. I did you a favor and threw it away.

You know when you open a file on Vim and after making changes and trying to save the file, Vim tells you that you need root permission to do so?

This is what most people do to solve it:

• Copy the content of the file to my clipboard
• Close Vim
• Re-open it with sudo
• Paste it and try to save it again

Well, turns out there's an easier way to achieve the same thing:

:w !sudo tee %

Thanks to my friend Diogo Lisboa for teaching me this!

When I have a very simple Rails app, I avoid adding Capistrano or any other complex tool to deploy it.

Instead, I use a simple shell script, which access the server via SHH and do what needs to be done:

#! /bin/bash
# script/deploy.sh
TAG=deployed_at_$(date +"%F_%H-%M")
git tag -m '' -a $TAG
git push --tags
ssh user@your_domain.com << 'SSH'
  cd /var/rails_apps/my_app
  rm -rf public/assets
  git pull
  bundle install --without development test
  bundle exec rake db:migrate db:seed assets:clean assets:precompile
  touch tmp/restart.txt
  git describe > public/version
SSH

After that, a tag will be created in the git repository. Now, you know exactly the date and time when it was deployed.

Also, you can find out which version (tag from git) is in production by accessing the URL http://your_domain.com/version.

Update from March 8, 2013:

I've created another script which accepts a -q (quick) flag:

#! /bin/bash
# script/deploy.sh
create_tag(){
  TAG=deployed_at_$(date +"%F_%H-%M")
  git tag -m '' -a $TAG
  git push --tags
}
quick_deploy(){
  echo 'Starting quick deploy...'
  create_tag
  ssh yourserver.com << 'SSH'
    cd /var/rails_apps/app_name
    git pull
    bundle install --without development test
    touch tmp/restart.txt
    git describe > public/version
SSH
}
complete_deploy(){
  echo 'Starting complete deploy...'
  create_tag
  ssh yourserver.com << 'SSH'
    cd /var/rails_apps/app_name
    rm -rf public/assets
    git pull
    bundle install --without development test
    bundle exec rake db:migrate db:seed assets:clean assets:precompile
    touch tmp/restart.txt
    git describe > public/version
SSH
}
if [ $1 ]; then
  if [ "$1" == '-q' ] || [ "$1" == '--quick' ]; then
    quick_deploy
  else
    echo -e 'Usage: script/deploy [OPTIONS]\n\nOptions:\n-q --quick: Deploy without running migrations nor re-precompiling assets.\n'
  fi
else
  complete_deploy
fi

No dia 19/01/2013 aconteceu o Start on Rails em São Paulo-SP.

É um evento que deu aquele ponta pé inicial para o pessoal que está interessado em começar a trabalhar / estudar Ruby on Rails, parecido parecido com o Rails Girls que rolou ano passado. E eu participei como coach novamente! \o/

There are several ways to split windows in Vim.

This one is now my favorite:

Existem alguns casos em que você precisa modificar um array (aumentá-lo por exemplo) repetindo os valores presentes no array original.

Uma forma bem interessante de fazer isso é convertendo tal array para um objeto Enumerator. Para isso, existe o método Enumerator#cycle. Imagine o seguinte array:

array = [1, 3, 5, 7]

Ao rodar o método cycle, veja o que acontece:

array.cycle # => #<Enumerator: [1, 3, 5, 7]:cycle>

Podemos agora usar o método Enumerator#take e modificar o array original como quisermos. Por exemplo, vamos dobrar o seu tamanho:

array.cycle.take(8) # => [1, 3, 5, 7, 1, 3, 5, 7]

Foi criado um array do tamanho especificado no parametro do método take.

Isso é útil - por exemplo - em casos similares à esse código da gem boleto_bancario. Em algoritmos de IA também é bastante comum precisar desse tipo de modificação em arrays.

Depois de quase um ano trabalhando na Codeminer 42, posso dizer que tive o prazer de trabalhar com equipes sensacionais, com as quais aprendi muitas coisas, sendo recompensado ao ver a realização de bons trabalhos e também fazendo grandes amigos. Obrigado Codeminer 42!

Começo hoje uma nova fase da minha vida, trabalhando na Locaweb! E como eu já conheço a equipe, o ambiente de trabalho e os projetos, me sinto honrado de estar começando nessa empresa, onde pretendo dar o meu melhor, como sempre tentei fazer. Obrigado a todos pela ótima recepção!

I've just updated my blog with a fresh, cleaner theme. I hope y'all like it! 🙂

Here's a screenshot for posterity:

Nos dias 7 e 8 de setembro, aconteceu o evento "Rails Girls" aqui em São Paulo.

O evento é uma iniciativa para fazer com que mais mulheres se interessem pela área de desenvolvimento de software. O evento é gratuito e acontece em vários lugares do mundo. Aqui no Brasil já aconteceu em Porto Alegre e agora em São Paulo (realizado na Locaweb).

Nos dois dias do evento, foram apresentadas algumas lighting talks muito boas (a maioria apresentadas por mulheres) e um curso básico de programação para web, usando Ruby on Rails.

Durante o mini-curso, foi mostrado às alunas uma visão geral sobre desenvolvimento web (HTML, CSS, javascript), MVC e banco de dados. Elas tiveram que criar um projeto real, começando do zero e terminando com a aplicação rodando no Heroku, apresentando o que fizeram para todos no final.

Eu participei como coach e valeu muito a pena. Foi sensacional ver os projetos finalizados!

Segue o link do evento e algumas fotos:

• http://railsgirls.com/saopaulo
• http://www.flickr.com/photos/64572237@N00/sets/72157631520431773/

When I started using Elasticsearch in my Rails applications, I had a problem creating separate indexes for the automated tests.

The problem was that there was no way to create more than one database in Elasticsearch. You can create different indexes, but no different databases.

Even creating indexes with different names won't solve the problem: it's necessary to configure our Rails models in order to work with a different index name when the tests are running.

I'm using both tire and RSpec gems. In this post, I'll explain how to separate indexes for development and test environments.

First of all, I've included the code below in file config/initializers/tire.rb:

if Rails.env.test?
  prefix = "#{Rails.application.class.parent_name.downcase}_#{Rails.env.to_s.downcase}_"
  Tire::Model::Search.index_prefix(prefix)
end

And I've manually set the index name in the model (assuming there is a Movie model):

index_name "#{Tire::Model::Search.index_prefix}movies"

Done! With that, the index name will be movies in development environment and appname_test_movies in test environment.

Deleting test indexes

In order to delete the test indexes after the suite has finished running, just add the following code to file spec/integration_helper.rb (or similar):

RSpec.configure do |config|
  config.after(:all, type: :request) { delete_movie_index }
end

And create a custom macro, which will delete the indexes:

def delete_movie_index
  Movie.index.delete
end

Demo app

I created a small application to demonstrate the technique explained in this post:

https://github.com/lucascaton/elasticsearch_app_example

I hope it helps!

Ontem apresentei uma tech talk na Codeminer42 sobre Elastic Search. Alguns dias depois, fiz a mesma apresentação no GuruSP e essa foi filmada pelo grande Agaelebe):

Slides

Fotos da Tech Talk (Codeminer42):

Fotos do 25º encontro do Guru-SP

Obrigado ao Jonas e à minha noiva Aline pelas fotos! :)

Pair programming is a technique where two developers work together on the same task. One is the "driver", typing and interacting with the code, while the other is the "navigator", reviewing the code and suggesting improvements. This method can significantly improve code quality and encourage learning.

When working remotely, keeping both developers on the same page can be challenging. However, tmux - a terminal multiplexer - makes this easier by allowing multiple users to share a session, even across different locations.

I'll explore how to set up tmux for pair programming, which involves two steps:

• Both users accessing the same server or system
• The server setup (for the driver) and the client setup (for the navigator)

Server setup

First, the "driver" needs to set up the tmux session. This requires access to a shared system or server where both developers can connect. On the server, run the following commands:

# -2` flag ensures that tmux uses 256-color support
# `-S` specifies a UNIX socket, so others can connect to this session
tmux -2 -S /tmp/pair new-session -s PairProgramming
# Ensure the correct permissions for other users to connect:
chmod 777 /tmp/pair

This command creates a new tmux session called PairProgramming but you can call it whatever you'd like.

Client setup

On the client (the "navigator"), run this command to attach to the tmux session:

tmux -2 -S /tmp/pair attach-session -t PairProgramming

The navigator will now be able to see the same terminal session as the driver. Both users can interact with the session in real-time.

Alternatives to consider

If you're working in different environments or need more advanced features (like a graphical interface or more robust collaborative tools), consider using other solutions such as VS Code's Live Share feature or cloud-based IDEs.

My friend @pellegrino gave me an awesome tip: replace Selenium with Poltergeist. For those who don't know, Poltergeist is a PhantomJS driver for Capybara. I've done it in a few projects and it works very well!

In order to do it, include the gem to your Gemfile:

gem "poltergeist"

Update your Capybara configuration:

Capybara.configure do |config|
  # config.javascript_driver = :selenium
  config.javascript_driver = :poltergeist
end

Run the specs!

If you are testing some confirm() JavaScript method and you have a code similar to page.driver.browser.switch_to.alert.accept, you'll get this error:

undefined method `switch_to`

While I was trying to fix it, I found out that Poltergeist always returns true from window.confirm. There's no way (at the moment) to make it return false, but at least it won't prevent your test from passing: all I had to do was to remove that particular line and it solved the issue.

This is the results from the first project I've migrated:

• Before: Finished in 1 minute 35.45 seconds
• After: Finished in 41.03 seconds

Hope you find it helpful as I did!

Não costumo escrever posts "off-topic" no meu blog, mas esse assunto mereceu um.

Eu estava há um tempo procurando um curso de inglês que me possuísse um horário flexível. Atualmente, existem vários cursos on-line que resolvem este problema. A OpenEnglish - uma empresa da Venezuela que chegou há poucos meses no Brasil - aparentemente cumpria bem essa tarefa. Resolvi experimentar!

Fiz minha matrícula ontem e de cara fiquei decepcionado, enfrentando 3 problemas complicados, os quais me fizeram desacreditar do curso na mesma hora. A matrícula foi absurdamente simples: em menos de 5 minutos eles me explicaram tudo, passei meus dados, incluindo cartão de crédito, do qual foi devidamente cobrado e a transação aprovada.

Antes da atendente desligar, ela me informou que um consultor pessoal iria entrar em contato no mesmo dia para me explicar algumas coisas. Eu podia optar a forma que ele entraria em contato: telefone ou e-mail. Escolhi telefone e fiquei aguardando. Recebi uns 4 e-mails, dois deles contendo praticamente a mesma informação, o que foi meio confuso. E aí veio o primeiro problema:

O consultor não ligou! Pois é. Depois que eles cobram parece que deixam você de lado. Como estava muito ocupado durante o dia todo, não me esquentei muito com isso, uma vez que achei que não fosse precisar dele. Pensei: "Amanhã eu eu mesmo ligo lá pra procurar o tal consultor".

Mas como eu queria começar ontem mesmo o curso, tentei entrar no site e o segundo problema apareceu: eu não consegui completar o cadastro inicial. No formulário inicial, quando eu clicava no botão de submit, meu telefone não era considerado válido. Simplemente aparecia o erro: "Phone number is required". O mais bizarro é que pra entrar nesse formulário, eu clicava em um link que eles haviam me mandado por e-mail, e o campo de telefone já vinha preenchido. Testei dois browsers: 'Google Chrome' e o 'Mozilla Firefox'. Fail nos dois navegadores :(

Como cada aula começa em hora inteira (21h00, 22h00, etc) e eu pretendia fazer a aula das 23h00, acabei perdendo esta primeira aula. Inadmissível perder a aula por um motivo idiota desses, não?! :(

Pra tentar resolver isso, tentei ligar no suporte, mas aí a coisa ficou pior. Ligando lá, essas eram as opções da URA:

• [1] Venda de cursos
• [2] Atendimento ao cliente
• [3] Consultor pessoal
• [4] Departamento de cobrança
• [5] Suporte técnico
• [6] Outras informações

Selecionando as opções 2, 5 ou 6, escutava uma gravação exatamente assim: "Nosso horário de atendimento é de segunda à sábado, das 10h da manhã às 12h da noite".

Primeiro erro que me incomodou: 12h da noite? WTF? Mas o pior problema mesmo é que eram 23h, ou seja, deveria ter alguém lá pra me atender. Selecionei a opção 3, mas a URA solicita um código de 3 dígitos do consultor pessoal.

Como NENHUM consultor ainda havia entrado em contato, eu não possuia o tal código. Selecionei a opção 4 pra ver no que dava. Escutei uma música de espera com informações em espanhol (WTF?) por alguns minutos e notei que não estava sendo transferido pra lugar algum.

Por último, tentei ainda selecionar a opção 1, que é a de vendas, mas a gravação dizia que essa opção só está disponível até às 21h. Tive que esperar até o dia seguinte (hoje) pelas soluções. Mas me sinto mais que na obrigação de comentar como eles me surpreenderam!

Hoje de manhã minha consultora pessoal ligou e explicou que o prazo de ligação do consultor é de 24 horas e não no mesmo dia que eu fiz a matrícula. Ela foi super atenciosa, pediu pra eu abrir o site e me mostrou cada ferramenta disponível lá, tirando todas as minhas dúvidas. Explicou que o formulário inicial realmente estava com problema, mas que já haviam resolvido.

E sobre o horário do suporte, ela disse que era até às 21h e que a URA provavelmente seria atualizada em breve com o novo horário de atendimento.

Fiquei super satisfeito. Eles conseguiram melhorar a péssima imagem que criei deles ontem!

Às 22h, resolvi tentar uma "Live Session", que são aulas ao vivo, com professores nativos, os quais não falam português se você estiver no nível intermediário ou superior.

O sistema deles é de fato muito bom, são conferências em audio, com slides interativos, onde os professores vão fazendo anotações nos slides em tempo real.

Além disso, cada aula tem no máximo 5 alunos, o que considero excelente. O sistema usado para a conferência, durante os 50 minutos de aula, funcionou perfeitamente.

Vale citar que tanto o sistema quanto o site funcionam em qualquer Sistema Operacional (Windows, Linux e OS X macOS) e em qualquer browser.

No final de cada aula, existe uma lista de apostilas, artigos, vídeos, podcasts, entre outras atividades relacionadas à esta aula específica. Então o professor recomenda as atividades mais adequadas para cada aluno, de acordo com a dificuldade que ele teve durante a aula.

Sensacional, estou bastante satisfeito. E seria injusto eu não contar essa história depois de reclamar tanto ontem :)

Dotfiles are configuration files that live in your home directory (~/), usually prefixed with a dot (making them hidden by default). They control how your shell, editor, Git, and countless other tools behave.

Over the years, I've built up a collection of mine into a single, open-source repository. It covers everything from shell customization and Git configuration to editor settings, language version management, custom scripts, and more. The specific tools evolve over time, but the goal stays the same: have a reproducible, portable development environment that I can set up on any machine with a single command.

The repository is open source - feel free to browse it, fork it, or cherry-pick anything useful for your own setup:

github.com/lucascaton/dotfiles

Keeping dotfiles in version control has been one of the best decisions I've made as a developer. It means I never lose a configuration tweak, I can experiment freely knowing I can always roll back, and spinning up a new machine goes from hours of setup to minutes.

I've created a regular expression to match YouTube URLs. As YouTube URLs start with https://youtube.com and https://youtu.be, the following regex solves the problem:

/^(?:https?:\/\/)?(?:www\.)?youtu(?:\.be|be\.com)\/(?:watch\?v=)?([\w-]{10,})/

This regex will match:

• http://youtube.com/watch?v=1234567890
• https://youtube.com/watch?v=1234567890
• http://www.youtube.com/watch?v=1234567890
• http://www.youtube.com/watch?v=12345-67890
• https://www.youtube.com/watch?v=1234567890
• http://youtu.be/1234567890
• https://youtu.be/1234567890
• http://www.youtu.be/1234567890
• https://www.youtu.be/1234567890
• http://www.youtube.com/watch?v=1234567890&feature=context&context=G2de15aaFAAAAAAAAAAA
• www.youtube.com/watch?v=1234567890
• youtube.com/watch?v=1234567890
• youtu.be/1234567890

But it won't match:

• youtube.com
• youtube.com/
• youtube.com/watch
• youtube.com/watch/
• youtu.be
• youtu.be/

Próximo de completar um ano que me mudei pra São Paulo, recebi um convite que acabou mudando as coisas mais uma vez. Passei quase um ano trabalhando na Bio Ritmo, onde tive uma experiência única de trabalhar com toda a equipe de tecnologia, onde fiz grandes amigos e onde aprendi muito.

Há mais ou menos um mês, recebi um convite para trabalhar em um tipo de empresa que até então eu não havia trabalhado: uma empresa de consultoria. Foi um convite que acompanhou uma decisão bastante difícil. Mas eu acreditava que era hora de mudar algumas coisas. E foi assim que eu comecei a trabalhar na Codeminer 42.

Hoje completa uma semana que comecei a trabalhar lá. E acredito ter tomado a decisão correta. Os desafios são grandes, os projetos são bacanas, o ambiente é descontraído e a equipe é muito boa e unida. Uma ótima forma de você aprender bastante é trabalhando com pessoas melhores que você e lá estou tendo esta oportunidade.

Uma coisa interessante é que em uma consultoria você trabalha em vários projetos (não necessariamente em paralelo) e isso permite que você use diferentes ferramentas e aprenda qual a melhor para cada tipo de problema ("there is no silver bullet"). Ou ainda, testar diferentes ferramentas para uma mesma solução.

Um obrigado especial ao Rinaldi Fonseca, que me convidou para trabalhar com esse ótimo time!

Hora de seguir em frente nessa nova empreitada!

Tive o prazer de participar em janeiro de um Coding-Dojo com o pessoal da empresa Lambda3, organizada pelo grande Rafael Rosa Fu!

Embora exista mais de uma forma de fazer, acho que o jeito que fizemos funcionou muito bem. Vou explicar como fizemos:

Seleção de problemas

O organizador seleciona 3~5 problemas de alguma lista de problemas de programação (como o Ruby Quiz, por exemplo). Quando começar o Dojo, ele apresenta um resumo dos problemas e faz uma votação para escolher um problema.

Foco!

Apenas um computador é necessário, isso ajuda a manter todos focados no problema. A pessoa mais próxima do computador começa sendo o "piloto", escrevendo o código inicial. A pessoa à esquerda do "piloto" será o "co-piloto" e sua função é ajudar o "piloto".

Troca de posições

A cada 7 minutos (ou algum outro tempo pré-determinado que for adequado), todos trocam de lugar: a pessoa à esquerda do "co-piloto" se torna o novo "co-piloto", o "co-piloto" agora começa a "pilotar" (programar) e o atual "piloto" entra no final da fila. Isso se repete até o final do Dojo.

TDD / BDD

Todo o desenvolvimento é orientado à testes, avançando através de baby steps. Quando testes estiverem falhando ("fase vermelha"), ninguém pode comentar nem sugerir nada, exceto o "co-piloto". Obviamente, quando os testes estiverem passando ("fase verde") todos podem comentar e sugerir implementações e refatorações.

Retrospectiva

No final, é interessante fazer uma retrospectiva, onde todos os desenvolvedores escrevem em post-its verdes coisas boas que aconteceram durante o Dojo e coisas ruins em post-its vermelhos.

O organizador recolhe os post-its e os cola num quadro, separado por tipo/cor. Depois de ler em voz alta todos os post-its, é interessante reservar uma área "Discussões" no quadro, para anotar discussões que ocorrerem durante e no final do Dojo.

Isso tudo é importante para não repetir os erros do Dojo atual no próximo e deixar claro o que foi acertado.

Referências

Segue um link dos slides do Serge Rehen sobre Coding-Dojo: http://www.slideshare.net/serge_rehem/coding-dojo-em-5-minutos.

Ontem aconteceu mais um encontro do evento "Café com Java", organizado pelo Eduardo Bregaida, que foi inclusive quem me convidou para palestrar :)

Eu falei sobre as vantagens de usar Ruby on Rails em comparação com o Java:

Um obrigado especial à minha namorada Aline, por filmar minha apresentação! :)

Slides

Fotos

Depois de 4 meses que criamos o [self SP] (grupos de usuários de Objective C), conseguimos realizar o seu primeiro encontro oficial, graças ao @fer_bass (que organizou quase tudo), à PoisonLabs (que patrocinou o CoffeBreak), à Caelum (que liberou o auditório para o evento) e ao Hugo Borges (que gravou o evento).

Obrigado a todos os palestrantes e aos participantes, foi realmente muito bacana!

Palestras

"OpenGL com GLKit" (xissburg)

"CoreGraphics Performance" (Glenn Marcus)

"Conhecendo e entendo o ARC" (Ferbass)

"Testes automatizados para sua aplicação iOS" (Ricardo Valeriano)

"Funcionalidades dinamicas do Objective-C" (Diego Chohfi)

Procurando uma forma de acelerar o comando rake routes, encontrei uma gem interessante: routes.

Ela cria um cache da saída do comando e renova o conteúdo automaticamente quando você atualiza o arquivo config/routes.rb.

Não é necessário incluir a gem no Gemfile do projeto, basta incluir o diretório oculto /.routes no .gitignore.

Como sempre, rode gem install routes para instalar e apenas routes para vê-lo em ação.

• Permitir mais de uma assinatura para e-mails (atualmente só é possível criar uma única assinatura);
• Tranferência de fotos e vídeos via bluetooth (qualquer celular atualmente faz isso);
• Permitir a inclusão de imagens ou vídeos dentro do app Mail (atualmente você precisa abrir a foto ou vídeo e selecionar a opção que manda por e-mail);
• Acessar de forma mais prática algumas configurações, como por exemplo ativar/desativar o 3G.

Finalmente terminei o primeiro screencast do meu site. Espero que gostem! :)

Por favor, mandem feedback do que acharam!

Comando sort - ordenar linhas

Algo que todo mundo que usa o editor Vim provavelmente conhece é o comando sort. Ele ordena alfabeticamente as linhas de seu texto/código.

Você também pode selecionar algumas linhas e ordenar apenas essas. Para isso, pressione shift + v para entrar no modo de seleção por linha, depois rode :'<,'>sort.

Comando sort u - ordenar linhas excluindo as repeditas

Algo que também uso muito é o parâmetro u, que permite ordenar as linhas, mas excluindo as repetidas:

Antes:

Lucas
Lucas
Lucas
Caton
Caton

Depois de rodar o comando :sort u:

Caton
Lucas

Comando sort /regex/ - ordenar linhas utilizando alguma coluna

E hoje aprendi mais uma coisa realmente interessante ao ordenar um arquivo: como ordenar um texto usando alguma coluna:

Imagine o seguinte texto:

36993 vim 26M
39140 ssh 10M
34551 bash 17M

Nosso objetivo é ordenar pela terceira coluna. Para isto, basta rodar o comando sort passando uma expressão regular como parâmetro, a qual representará o que será ignorado pelo vim até começar a ordenação, ou seja, a partir da coluna que a expressão regular não "casar" mais, ele começará a ordenar. Sendo assim:

:sort /.\+\s.\+\s/

Essa expressão regular casa com qualquer caracter em qualquer quantidade + um espaço + qualquer caracter em qualquer quantidade + um espaço, conforme representado pela parte destacada abaixo:

36993 vim 26M
39140 ssh 10M
34551 bash 17M

O conteúdo depois disso será a chave para a ordenação.

Resultado:

39140 ssh 10M
34551 bash 17M
36993 vim 26M

Se quiséssemos ainda ordenar pela segunda coluna:

sort /\d\{5\}\s/

Bom, é isso! Qualquer dúvida, postem nos comentários!

E se quiserem aprender mais sobre expressões regulares, confira essa minha apresentação sobre o assunto! :)

Vou listar as ferramentas que uso diariamente pra me organizar e proteger meus dados.

Confesso que eu já perdi dados importantes no passado (com quem nunca aconteceu?) e isso acabou me deixando neurótico com backups.

Agenda de contatos

Pra começar, como minha agenda de contatos não ficava na nuvem e já perdi ela quando trocava / perdia celular, acabei usando por muito tempo uma agenda de papel. Eu sei, é muito estranho, mas eu me sentia seguro. De um tempo pra cá, a substituí pela agenda de contatos da Apple (presente no OS X macOS e no meu iPod Touch), sincronizados pelo iCloud (e backup lá também). òbvio que armazenar essas informações eletrônicamente é infinitamente mais vantajoso. Guardo fotos dos contatos, vários e-mails, telefones, usuário do twitter, endereço, etc.

Agenda de compromissos

Assim como minha agenda de contatos, eu também usei por muitos anos uma agenda de papel. Mas finalmente me desapeguei e não comprei uma agenda 2012. Substitui esta por dois softwares, os quais estão me atendendo muito bem:

iCal: Onde anoto todas os compromissos, os importantes com avisos sonoros e avisos por e-mail, também sincronizados entre o Mac e o iPod Touch via iCloud; e Wunderlist: que é um software para listar as coisas que você precisa fazer em determinado dia, no estilo "TO-DO list". Ele possui versão web, versão pra macOS e versão para iOS. Outra coisa que me fez gostar ainda mais é a possibilidade de editar / criar tudo offline no iPod Touch (já que eu não tenho 3G) e sincronizar tudo depois, quando estiver numa rede wi-fi.

Algumas tarefas ainda estão no Google Calendar (como aniversários e tarefas recorrentes, ambos com avisos por e-mail). Estou migrando estas aos poucos para o iCal.

Leitor de feeds RSS

Uso o Google Reader desde 2005 e funciona perfeitamente bem, nunca tive nenhum tipo de problema com ele. Atualmente tenho 175 subscriptions e leio aproximadamente 70% dos items de lá (dependendo se o título me interessar ou não). Uso bastante o recurso "starred" para selecionar os item que quero ler depois, quando não posso ler no momento. Uso bastante o recurso de envio de post por e-mail, pra comparilhar com quem possa interesar.

Bookmarks

Depois de muito tempo usando o Delicious, o abandonei e comecei a usar o Google bookmarks. Uso uma extension do Google Chrome pra adicionar item lá e uso com frequência pra me lembrar de páginas que já visitei e eram úteis em potencial.

Anotações em geral

Em 90% dos casos, uso o Evernote, software para o macOS e iOS. Nos outros 10%, uso papel e caneta apenas, o que às vezes é insubstituível.

Armazenamento de senhas

Utilizo o LastPass, que possui uma extension pra todos os browsers atuais e em geral funciona bem. Uma vez tive um problema com ele, mas o pessoal do LastPass entrou em contato comigo em poucos minutos pra resolver meu problema (e olha que eu uso a versão free!).

Repositório de projetos

Meus projetos open-source ficam no Github, o qual tem ótimos recursos e boa usabilidade. Já meus projetos fechados ficam no Codebase, o qual gosto bastante, uma vez que além de servir como repositório git, também consigo gerenciar o projeto de forma integrada, criando tickets, milestones, atribuindo tarefas para usuários, configurando prioridades, etc.

Controle de contas ($)

Até hoje não achei um software que me atendesse 100%, o que me obriga até hoje a usar uma planílha salva no Google Docs.

Easy Bills \o/

Redes sociais

Uso Facebook, Google+ e Twitter, mas não me comprometo a ler tudo que aparece por lá. O que mais uso, sem dúvidas, é o Twitter, e como a maior parte das pessoas que eu sigo são programadores, uso com o objetivo de me atualizar, descobrir e compartilhar coisas relacionadas à desenvolvimento de software.

Lembretes rápidos

Não tem como fugir. Vez ou outra, mando um e-mail pra mim mesmo com alguma tarefa rápida pra lembrar depois. A propósito, uso o Gmail desde 2004 e organizo com os labels e filtros que o serviço oferece, além da Priority Inbox (Caixa de entraga prioritária).

Backups

Como eu já falei, sou meio neurótico com backups:

• Faço um backup dirário de todo conteúdo do meu Mac em um HD externo. Como trabalho com o Mac, levando ele diáriamente para o escritório, fiz seguro deste também!
• A cada 6 meses faço um backup das coisas mais importantes em DVDs (uso aproximadamente 6 discos) e pra eu não esquecer, o Google Calendar me manda um e-mail semestral avisando: Você precisa fazer um backup semestral em DVDs :).

Mensalmente, faço backups dos seguintes items:

• Subscribes do Google Reader
• Address Book da Apple (além de já ter um backup no iCloud)
• LastPass
• iCal (além de também já ter um backup no iCloud)

Compartilhem o que vocês usam também!

Aproximadamente 5 meses depois da minha primeira apresentação no Bio Labs, realizei recentemente outra, sobre Expressões Regulares.

Nessa tech talk, eu falei sobre alguns mitos relacionados à Expressões Regulares, ensinei o básico de como ler e escrever regex, para que servem os metacaracteres, onde posso usar, em que caso pode me ser útil, etc.

Dessa vez foi filmado, embora a qualidade não tenha ficado muito boa (a iluminação fica ruim às vezes). Segue o vídeo da apresentação e os slides:

Me mandem feedback comentando o que acharam!

O evento foi sensacional. Além de ótimas palestras (nacionais e internacionais), rolou um stand-up com Danilo Gentili e um reencontro muito bacana com vários amigos da comunidade Ruby!

Mais uma vez parabéns ao Fábio Akita e um obrigado especial à Bio Ritmo por apoiar os desenvolvedores, não apenas nos liberando nos dois dias do evento como também bancando nossa inscrição :)

E que venha a RubyConfBR 2012!

Essa dica é pra quem usa PostgreSQL e quer editar suas queries dentro de algum editor de texto sem sair do console do banco de dados. Isso é especialmente útil quando você precisa rodar uma query complexa diretamente no console.

Primeiramente, verique qual é o seu editor de textos configurado na variável de ambiente EDITOR:

$ echo $EDITOR
# vim

No meu caso, meu editor padrão é o Vim. Se você não tiver nenhum editor configurado, basta inclur a seguinte linha no seu arquivo ~/bash_profile:

export EDITOR=vim

Depois, abra o console do PostgreSQL (psql) e digite \e para que você possa digitar as queries SQL de forma mais confiante e organizada no seu editor preferido:

$ psql
# psql (9.0.4)
# Type "help" for help.
database_name=# \e

Estava lendo esse post do Rafael Sachetto, quando encontrei dois comandos que não conhecia: pushd e popd.

Fui pesquisar o que era e descobri dois substitutos para o comando cd (quem diria?!). Ao ir usando o comando pushd <directory>, ele vai montando uma pilha (aka. estrutura de dados do tipo pilha) com todos os diretórios pelos quais vocês vai "passando".

Depois, à medida que você digita o comando popd, ele vai retornando a todos os diretórios, usando essa pilha como guia.

Seria algo como um cd - (que volta ao diretório anterior), só que sem limites para retorno.

Por exemplo:

cd ~
$ pwd # ~
$ pushd Pictures
$ pwd # ~/Pictures
$ pushd PSD
$ pwd # ~/Pictures/PSD
$ popd
$ pwd # ~/Pictures
$ popd
$ pwd # ~

Se quiser ver todos os diretórios da pilha, use o comando dirs.

Depois de ler essa matéria do Meio Bit, fiquei indignado. Além de copiar a Apple (mais uma vez), a Micro$oft ainda se diz melhor só porque não irá cobrar comissão nos apps vendidas na loja dela.

A Apple cobra um valor que julgo justo, um valor pelo trabalho que ela faz pensando no desenvolvedor e principalmente no usuário final, tanto para apps para o OS X macOS como pro iOS:

• Verificação geral do software (se existe memory leaks, se a performance está legal, se o design está adequado, etc.);
• Se a app não causa danos à sua máquina ou ao seu dispositivo;
• Libera os servidores para você armazenar seu app lá (evitando que você gaste com hosting);
• Divulga seu app (reduzingo seus custos com divulgação);
• Disponibiliza uma interface pra você gerenciar suas vendas.

Além disso:

Custo do XCode: US$ 0,00. Documentação online (muito boa): US$ 0,00. Screencasts oficiais (muito bons também): US$ 0,00. Agora, quanto custa mesmo o Visual Studio? O Windows Server? MSSQL Server? Então não me venham falar que desenvolver para a Apple é caro.

A menos que você não pague por todas as licenças que a M$ cobra, porque daí a história é outra...

Depois de alguns dias conversando com o Ferbass e com o Tales Pinheiro, finalmente tiramos a idéia do papel e criamos o [self SP];, um grupo de usuários da linguagem Objective C, tanto para desenvolvimento para a plataforma iOS quanto para a plataforma OS X macOS.

O objetivo do grupo é agrupar informações relevantes, facilitar o encontro dos usuários e incentivar discussões (saudáveis) sobre o assunto.

http://selfsp.org/

Participe do grupo e nos ajude a divulgar!

A quick tip for those who use Vim: if you need to remove several lines that match a regular expression, you can achieve that by running:

:g /pattern/d

Let's say you want to remove the commented lines from the following file:

# This is a comment
def foo
end
# This is another comment
def bar
end

Run :g /^#.*/d, and your code will become:

def foo
end
def bar
end

Simple, right? :)

No começo do mês, aconteceu o 16º encontro do Grupo de Usuários Ruby de SP (aka. Guru SP).

Como o Agaelebe (Hugo Borges) não ia poder participar, me oferecei para filmar as apresentações. Segue o primeiro vídeo que gravei/editei, da palestra do Cássio Marques):

Outros vídeos, slides e links interessantes do evento estão no site oficial do grupo.

I've created a gem called code2pdf, which is a simple and open-source tool to convert your codebase to a PDF file. It might be especially useful in case you need to register you software.

In order to install it, just run:

gem install code2pdf

Then, open a terminal and run:

code2pdf [project path] [blacklist file]

The blacklist file is optional and must be a YML file, similar to the following:

:directories:
  - .git
  - log
  - public/system
  - spec
  - tmp
  - vendor
:files:
  - .DS_Store
  - .gitignore
  - database.yml
  - favicon.ico

You can find more information (including a PDF output example in the repository:

github.com/lucascaton/code2pdf

Please, let me know in the comments if you like it :)

Hoje tive a honra de realizar a primeira apresentação do Bio Labs, que é uma série de apresentações (tech talks) que faremos na empresa onde eu trabalho, Bio Ritmo.

Eis os slides da minha apresentação:

Acabei de chegar da palestra "Building Chrome Apps with HTML5" com Boris Smus (que aconteceu na Caelum). O cara é desenvovedor front-end do Google e fã de open source.

Você pode baixar aqui os slides da palestra. Ele explicou coisas interessante, como por exemplo fazer uma tag input apta à reconhecer sua voz:

<input type="text" x-webkit-speech />

Entre várias outras coisas, vale a pena conferir os slides e também o blog do cara: http://smus.com/.

Pra fechar com chave de outro, ganhei uma camiseta nos brindes no final da palestra :)

Uso RVM (Ruby Version Manager) desde que este foi lançado e pretendo continuar utilizando, dada a facilidade para utilizar diferentes implementações/versões do Ruby em uma mesma máquina.

Algo muito interessante que ele traz são os gemsets, ferramenta para separar suas gems em contextos, geralmente um para cada projeto.

Isso fazia total sentido antes do Rails chegar em sua versão 3, quando Bundler foi incluído por padrão para realizar o gerenciamento das gems.

Ou seja, na teoria apenas projetos rodando Rails 2 teriam o problema de versões diferentes das gems. Porém na prática, é possível usar o Bundler em projetos Rails 2, tornando os gemsets meio inúteis.

Juntei todas as minhas gems no gemset global, que já vem criado por default e há 2 meses tenho usado desta forma, onde tudo tem funcionado perfeitamente.

O único detalhe, é que se você tiver duas ou mais versões de alguma gem que inclui um executável (rspec por exemplo) você precisa chamá-lo da seguinte maneira:

bundle exec rspec

Dessa forma, o Bundler sabe qual dos executáveis usar, baseado no seu arquivo Gemfile. Para facilitar, eu criei alguns aliases:

alias rails='bundle exec rails'
alias rake='bundle exec rake'
alias rspec='bundle exec rspec'

Como vocês estão fazendo? Alguma sugestão ou crítica?

Vimfiles are configuration files for the Vim editor. It includes the editor preferences, theme (color scheme), fonts, plugins, custom functions, and more.

I've finally created my own from scrach, which you can find here:

github.com/lucascaton/vimfiles

Quando rodamos algum script em sistemas Unix, existem 3 tipos de mensagens de entrada e saída:

• STDIN - Standard in (código 0)
• STDOUT - Standard out (código 1)
• STDERR - Standard error (código 2)

Se você precisar salvar um log contendo não só as mensagens da saída padrão, mas também as mensagens de erro, use o sufixo 2>&1:

ls -lR / > /tmp/file.log 2>&1

O que estamos fazendo aí é pegando tudo que é da saída 2 (STDERR) e jogando pra saída 1 (STDOUT), fazendo com que o log contenha tudo :)

Esse blog foi criado em 2009 e estava hospedado na Locaweb, onde toda a configuração para aplicações PHP já estava pronta: Apache, o PHP própriamente dito e MySQL (infelizmente WordPress não suporta PostgreSQL). Tudo funcionava muito bem.

Pouco mais de um ano depois, mudei de hospedagem, agora uso um servidor da WebbyNode, o qual tem sido excelente. Porém, sempre uso um server-deploy semi-pronto, ou seja, que já vem com algumas ferramentas do mundo Ruby.

Como queria continuar com o WordPress, tive que instalar o PHP na mão. Até aí sem problemas: Nginx + PHP + WordPress + MySQL foi moleza. Lembro que quando migrei de servidor tive problemas FastCGI, mas acabei resolvendo.

Meus problemas reais começaram quando fiz um novo server-deploy, repeti os passos e notei que o blog estava muito lento e que havia algo errado. Pesquisei sobre isso e descobri que o meu server não estava usando FastCGI, essencial para aplicações que rodam em PHP. Passei um tempão tentando fazer isso funcionar, sem sucesso.

Foi aí que decidi usar o Enki, um blog manager open-source feito em Rails. Gostei muito dele assim que comecei a usar. Logo de cara fiz um fork e fiz algumas modificações pra me atender melhor.

Mas ainda haviam algumas coisas que realmente não estavam me agradando. Primeiro que migrar todos os posts, páginas, comentários e imagens não seria nada fácil. Depois, as páginas não estavam cacheadas (até onde eu vi), as views eram escritas em ERB (e eu gostaria de migrar para HAML) e tinha bastante coisa que eu teria que mudar. Além disso, não haviam muito themes, como no WordPress.

Por fim, depois de 2 semanas, decidi que ficaria com o WordPress mesmo. Meu amigo Dude me ajudou a configurar o FastGCI (usando php-fpm) e voltei o blog pro bom e velho WordPress.

Embora o código dele torne difícil algumas moficações, acho que não vou mudar ele por um bom tempo. E confesso que fiquei feliz de ter voltado :)

Fugindo um pouco de assuntos técnicos, vou postar um resumo sobre algumas coisas que ando ouvindo e lendo sobre empreendedorismo:

Podcasts

Grok Podcast - Rework

Carlos Brando e Rafael Rosa comentam o interessantíssimo livro "Rework", da empresa 37 signals. Vale muito a pena ouvir, fantástico!

• Parte 1
• Parte 2
• Parte 3

Nerdcast - Expresso Empreendedor

Pessoal do Jovem Nerd com muitas dicas bacanas, humor e convidados experientes.

• Parte 1
• Parte 2

GuanaCast - Como criar sua Empresa

Não costumo escutar esse podcast, mas como o assunto me interessou, acabei ouvindo. Guanabara conversa com o pessoal do Sebrae e discutem sobre Startups, incubadoras, sociedades, entre outras coisas.

• Parte única

Livros

• Desenvolvimento de produtos sem enrolação
• Getting Real (Caindo na Real (versão em português) (37 Signals)
• Rework (37 Signals)
• "Pai rico pai pobre" (Robert Kiyosaki e Sharon Lechter)
• "Os segredos dos campeões" (Roberto Shinyashiki)

Próximos livros

• ZTD - Zen To Done (Leo Babauta)
• Startup (Jessica Livingston)

O Anderson Casimiro e o Augusto Pascutti criaram um meme sobre ambientes de trabalho. As regras são simples:

• Escreva sobre seu ambiente de trabalho - fale sobre qualquer ponto que quiser;
• Indique de 3 à 5 pessoas para que possivelmente façam um artigo sobre seu ambiente.

Fui convidado pelo Bruno Codeman para montar minha lista!

1. OS: Ubuntu 10.10

Atualmente, a mais popular distriuição Linux. Como é baseada no Debian, herdou o apt pra gereciar os pacotes. Todo o meu hardware funciona bem e raramente o sistema fica lento ou trava. Ultimamente tem ficado até mais bonito...

2. IDE/Editor: Vim

Rápido, flexível, snippets, atalhos produtivos e ainda conta com excelentes plugins. Desenvolvo em Ruby e Ruby on Rails utilizando somente ele e sempre dá conta do recado.

3. Browser: Google Chrome

Há um ano, eu comecei a experimentar o browser do Google e este substituiu o meu querido Firefox. Com todas as extensions disponíveis hoje, quase não preciso de outro browser, embora exporadiamente use o Firefox pra usar os add-ons WebDeveloper e Firebug.

4. Versionamento: Git

Git ganhou meu respeito. O utilizo há 1 ano e meio e definitivamente me atendeu melhor que o SVN. Não dá pau e é muito eficiente. É atualmente um dos softwares que mais me orgulho de usar.

5. Linguagem de programação: Ruby

Já desenvolvi em PHP, Delphi, Java e até brinquei um pouco com .Net e Python. Mas nada, nada me faz mais feliz que programar em Ruby. A sintaxe é limpa, o suporte à metaprogramação é ótimo, desenvolver usando BDD é muito fácil e a comunidade é fantástica.

6. Banco de Dados: PostgreSQL

Usei MySQL por muito tempo e era ok. Mas ano passado tive que começar a trabalhar em alguns projetos que usavam PostgreSQL e seu poder me convenceu e se tornou meu database padrão.

Indicação de 5 amigos pra continuar o meme:

• Dude
• Vitor Laubé
• Thiago Aléssio
• Jésus Lopes
• Eder Costa

O comando mv serve básicamente pra duas coisas: mover arquivos de um diretório pra outro e renomear arquivos.

Algo interessante que aprendi com o Dude foi como mover apenas alguns tipos de arquivos. Exemplo: se eu precisar mover todos os arquivos com extensão .txt e .doc para um diretório chamado docs, bastaria fazer:

mv /home/caton/{*.txt,*.doc} /home/caton/docs

Enjoy! :)

Aconteceu hoje o evento Agile Vale 2010, no ITA, em São José dos Campos-SP. O evento foi muito bom e também muito bem organizado. No total, foram mais de 440 participantes, sem contar palestrantes, patrocinadores e a equipe que organizou o evento, que a propósito estão de parabéns.

No total foram 11 palestras, 2 dinâmicas e uma mesa redonda com os palestrantes. Como não haveria tempo para todas as palestras, a solução infelizmente foram apresentações paralelas. Somente a primeira palestra e a mesa redonda não tiveram nada em paralelo, então eu não pude assistir 5 palestras de um total de 11 (as quais pretendo assistir em vídeo depois). As dinâmicas também aconteceram paralelamente às palestras, então não participei de nenhuma das duas.

Ah! O evento ficou devendo uma conexão wireless, embora isso fosse quase impossível levando em consideração a quantidade de participantes.

Palestras

"Você sabe o que é Agile? Eu também não!" - Fabiano Milani (AdaptIdeas)

Foram apresentados conceitos básicos de metodologias ágeis. A palestra foi interessante, porém focada em quem nunca aplicou ou estudou metodologias ágeis.

"O que é Kanban e porque se importar com ele." - Rodrigo Yoshima (Aspercom)

No começo achei os conceitos meio confusos e eu não conseguia entender o objetivo principal do Kanban. Mas no decorrer da apresentação, Yoshima conseguiu demonstrar os benefícios do Kanban e a palestra realmente valeu a pena. Muito boa!

"Construindo uma cultura de aprendizagem." - Luiz Faias e André Faria (Bluesoft)

A palestra levanta questões como: "Quanto você está se dedicando pra ser um profissional melhor?", "Você participa de projetos open-source?", "Participa de eventos?", "Lê bons livros?", entre outras. Resumindo, foram dicas de boas práticas para melhorar profissionalmente.

"A linha de montagem de SW representada como cartões na parede." - Paulo Caroli (ThoughtWorks Brasil)

A palestra falou sobre como cartões na parede tornam conceitos básicos de Kanban, Scrum, Lean e XP visíveis a todo time.

"Entenda Software de Forma Correta" - Fábio Akita (GoNow)

A palestra do Akita - como sempre - foi ótima. Ele falou sobre a evolução de softwares, sobre softwares que mesmo sem documentação e sem controle podem ser bem sucedidos, como é o caso de vários projetos open-source; ele citou o Linux como exemplo. Me fez enchergar software como um conjunto de idéias, como um meme e repetiu várias vezes pra deixar claro: "não existe bala de prata", já que determinada ferramenta / framework pode funcionar muito bem em um projeto mas raramente funcionará em todos.

"O problema é seu, a solução também" - Cecília Fernandes (Caelum)

Pra mim, foi a melhor palestra do evento. Cecília mandou muito bem e através de uma forma muito simples e eficiente, soube explicar porque e como customizar determinada metodologia ágil de forma que ela se torne a "SUA" metodologia. Explicou porque evitar o uso do famoso "Scrum de caixinha", ou seja, Scrum (ou qualquer outra metodologia) como ferramenta fechada e não como framework.

Mesa redonda

A mesa redonda foi muito boa. As discussões se basearam em dois (polemicos) temas: "Se eu estou usando Scrum, mas não uso TDD / BDD, isto está correto?" e "Como deve ser a transformação de um líder de projeto quando se muda de uma metodologia tradicional para uma ágil".

Pra finalizar

Novamente: a equipe que organizou está de parabéns, tanto pela iniciativa quando pela organização. Espero que a edição 2011 seja ainda melhor :)

ActionMailer module has been reconstructed in Rails 3 and mailers have their own subdirectory (app/mailers) since then.

This blog post will demostrate how to test them in Rails using RSpec. Assuming that we have a mailer like the following:

class Notifier < ActionMailer::Base
  default from: 'noreply@company.com'
  def instructions(user)
    @name = user.name
    @confirmation_url = confirmation_url(user)
    mail to: user.email, subject: 'Instructions'
  end
end

To send an email through a method from User model:

class User
  def send_instructions
    Notifier.instructions(self).deliver_now
  end
end

Before testing it, make sure the config/environments/test.rb file has the following configuration:

Rails.application.configure do
  config.action_mailer.delivery_method = :test
end

It ensures that emails won't be sent, but instead be stored on ActionMailer::Base.deliveries array.

So, in order to create the tests:

# spec/models/user_spec.rb
RSpec.describe User, type: :model do
  subject { create :user }
  it 'sends an email' do
    expect { subject.send_instructions }
      .to change { ActionMailer::Base.deliveries.count }.by(1)
  end
end

# spec/mailers/notifier_spec.rb
RSpec.describe Notifier, type: :mailer do
  describe 'instructions' do
    let(:user) { mock_model User, name: 'Lucas', email: 'lucas@email.com' }
    let(:mail) { described_class.instructions(user).deliver_now }
    it 'renders the subject' do
      expect(mail.subject).to eq('Instructions')
    end
    it 'renders the receiver email' do
      expect(mail.to).to eq([user.email])
    end
    it 'renders the sender email' do
      expect(mail.from).to eq(['noreply@company.com'])
    end
    it 'assigns @name' do
      expect(mail.body.encoded).to match(user.name)
    end
    it 'assigns @confirmation_url' do
      expect(mail.body.encoded)
        .to match("http://aplication_url/#{user.id}/confirmation")
    end
  end
end

Rails allows you to create very comprehensive tests for mailers.

Happy coding!

O módulo ActionMailer foi refeito no Rails 3 e os mailers ganharam um subdiretório próprio (dentro do app/) desde então. Nesse post vou demonstrar como testá-los no Rails using RSpec.

Supondo que temos um mailer como esse:

class Notifier < ActionMailer::Base
  default from: 'noreply@company.com'
  def instructions(user)
    @name = user.name
    @confirmation_url = confirmation_url(user)
    mail to: user.email, subject: 'Instructions'
  end
end

Para enviar um email através de um método da classe User:

class User
  def send_instructions
    Notifier.instructions(self).deliver_now
  end
end

Antes de testá-lo, garanta que o arquivo config/environments/test.rb esteja configurado assim:

Rails.application.configure do
  config.action_mailer.delivery_method = :test
end

Isso garante que os e-mails não serão realmente enviados, e sim armazenamos no array ActionMailer::Base.deliveries.

Verificado isso, basta criar os testes (exemplo: spec/models/user_spec.rb):

RSpec.describe User, type: :model do
  subject { create :user }
  it 'sends an email' do
    expect { subject.send_instructions }
      .to change { ActionMailer::Base.deliveries.count }.by(1)
  end
end

# spec/mailers/notifier_spec.rb
RSpec.describe Notifier, type: :mailer do
  describe 'instructions' do
    let(:user) { mock_model User, name: 'Lucas', email: 'lucas@email.com' }
    let(:mail) { described_class.instructions(user).deliver_now }
    it 'renders the subject' do
      expect(mail.subject).to eq('Instructions')
    end
    it 'renders the receiver email' do
      expect(mail.to).to eq([user.email])
    end
    it 'renders the sender email' do
      expect(mail.from).to eq(['noreply@company.com'])
    end
    it 'assigns @name' do
      expect(mail.body.encoded).to match(user.name)
    end
    it 'assigns @confirmation_url' do
      expect(mail.body.encoded)
        .to match("http://aplication_url/#{user.id}/confirmation")
    end
  end
end

O Rails nos possibilita criar testes bastante compreensivos para mailers.

Happy coding!

Após assistir o vídeo de preview do Windows 8 (enviado pelo Dude), resolvi escrever os motivos pelos quais eu não volto mais para a "Matrix".

Antes que me atirem pedras, quero deixar claro que essa é a minha opnião. Você tem todo o direito de não concordar (dê sua opnião nos comentários).

O Windows 7 e 8 tem vários recursos interessantes, mas o que me desagrada é o fato de existirem coisas definitivamente mais importantes do que uma interface "bonitinha" (apesar de ainda estar muito atrás do OS X macOS).

Exitem certas funcionalidades que fazem muita falta e que ninguém dá atenção, como um terminal decente por exemplo. Um através do qual você possa realmente ter controle total sobre sua máquina.

Tinha um comcercial do Windows Vista (ou 7) que dizia: "O Mac é bonitinho, mas você precisa de um S.O. de verdade". Que ironia, hein?!

Mensalmente o "Grupo de Usuários Ruby de SP" (aka. "Guru-SP") organiza encontros em São Paulo, nos quais programadores se reunem para discutir tecnologias e novidades do mundo Ruby.

O encontro mais recente aconteceu sábado (18/09/2010) com uma série de 17 palestras de 10 minutos. Eu fiz uma pequena apresentação falando sobre gerência de estados de objetos Ruby utilizando a gem state_machine.

Slides da minha apresentação:

Algumas fotos do evento:

Meu brother Thiago Aléssio (aka. "Xis Frango") foi comigo, valeu pela companhia, brother!

Nesse post vou compartilhar um script simples e eficiente pra fazer backup no Linux, usando o rsync. No exemplo que vou usar, temos dois diretórios: um de "origem" e um de "destino".

O rsync é na realidade um software de sincronização e isso signfica que todas as alterações que você fizer no diretório "origem" vão refletir no diretório "destino", sejam essas alterações a criação, a alteraração ou a exclusão de arquivos e pastas.

Vamos dar uma olhada no script:

#! /bin/bash
SOURCE_DIRECTORY=/home/caton/
DESTINATION_DIRECTORY=caton@10.10.10.2:/home/someuser/bkp
sudo rsync -Cavz --progress --partial --delete \
  --numeric-ids --exclude="*.gvfs" \
  $SOURCE_DIRECTORY $DESTINATION_DIRECTORY
echo Backup realizado com sucesso.
echo

Explicando: as variáveis SOURCE_DIRECTORY e DESTINATION_DIRECTORY são apenas pra deixar o script mais organizado e fácil pra alterar os diretórios. Note que o segundo diretório que eu coloquei é um diretório remoto, acessado via protocolo ssh. A sintaxe é simples: usuário@ip:diretório.

Sobre os parametros utilizados (progress, partial, etc.), vale a pena pesquisar não só para entender, mas também para customizar, de forma que te atenda melhor.

Se te interessar, é possível salvar um log de cada backup:

#! /bin/bash
SOURCE_DIRECTORY=/home/caton/
DESTINATION_DIRECTORY=caton@10.10.10.2:/home/someuser/bkp
LOG_FILE=~/logs/bkp_"$(date "+%F")".log
touch $LOG_FILE
sudo rsync -Cavz --progress --partial --delete \
  --numeric-ids --exclude="*.gvfs" \
  $SOURCE_DIRECTORY $DESTINATION_DIRECTORY > $LOG_FILE
echo Backup realizado com sucesso.
echo O log encontra-se em: $LOG_FILE
echo

Outra coisa interessante é colocar esse script no cron. Assim, de tempos em tempos ele será executado automaticamente.

Para finalizar, uma solução alternativa: dependendo do tipo de backup que você precisa, um simples alias no ~/.bashrc pode ser suficiente:

alias runrsync='sudo rsync -Cavz --progress --partial \
  --delete --numeric-ids --exclude="*.gvfs"
  /home/caton/ caton@10.10.10.2:/home/someuser/bkp'

Afinal, "Simplicidade é a sofisticação máxima" (Leonardo da Vinci).

Desafio

Escrever um script que rode em daemon (ou seja, em background), executando um ou mais comandos de tempo em tempo.

Há um tempo, eu precisei de um script que fizesse um listening em um determinado diretório e alterasse as permissões dos arquivos que eram movidos para esse diretório por outro software.

Solução

O script acabou ficando bastante simples e pode resolver vários tipos de problemas.

#! /bin/bash
while((1)); do
  # Substitua o seguinte comando para fazer a tarefa que você precisa
  chown -R nobody:faturamento /home/faturamento/importacoes;
  sleep 5; # Quantidade de segundos para ficar em pausa antes de rodar novamente
done & # O `&` faz o script rodar em background
echo 'Script rodando em daemon...'

Se você souber outras formas de fazer isso (possivelmente existem maneiras melhores), mande através dos comentários :)

Este post é um resumo de comandos úteis para administração de bancos de dados PostgreSQL.

Criar uma senha

sudo su postgres -c psql postgres

Quando o console do PostgreSQL abrir, rode:

ALTER USER postgres WITH PASSWORD 'sua_senha';

Criar um banco de dados pelo terminal

createdb -U username -E utf8 dbname -h localhost

Criar um banco de dados no console do PostgreSQL (psql)

create database dbname with owner=postgres encoding='utf8';

Renomear um banco de dados

alter database "old_name" rename to "new_name";

Apagar um banco de dados

drop database dbname;

Dump (backup) de um banco de dados

pg_dump dbname -h localhost -U postgres > backup.sql

Dump (backup) de uma tabela apenas

pg_dump dbname -h localhost -U postgres > backup.sql --table=nome_tabela;

Dump (backup) de um banco de dados com apenas algumas tabelas

pg_dump dbname -h localhost -U postgres > backup.sql --table=nome_tabela --table=outra_tabela;

Dump (backup) de um banco de dados sem determinada tabela

pg_dump dbname -h localhost -U postgres > backup.sql --exclude-table=nome_tabela;

Dump (backup) de um banco de dados excluindo várias tabelas

pg_dump dbname -h localhost -U postgres > backup.sql --exclude-table=nome_tabela --exclude-table=outra_tabela;

Restauração de um banco de dados (a partir de um arquivo SQL)

psql dbname -h localhost -U postgres < backup.sql

Dump (backup) dos usuários de um banco de dados

pg_dumpall -g -U postgres -h localhost > users.sql

Comandos especiais em queries SQL

Data

select (current_date + integer '7') as nome_campo;

Erros comuns

Duplicate key value violates unique constraint

Ao migrar um banco de dados para PostgreSQL ou fazer alguma coisa errada sem querer, o seguinte erro pode aparecer:

PGError: ERROR: duplicate key value violates unique constraint "tablename_pkey"

Para resolver:

select setval('entities_id_seq', (select max(id) from entities)+1);

Personalizando o psql

Basta criar um arquivo ~/.psqlrc (similar ou igual à esse)

Alterando o pager

\pset pager off
\pset pager off
\pset pager always
\pset pager occasionally
\pset pager at random`

Exibir (null) para campos null (em vez de não exibir nada)

\pset null '(null)'

Nota: Esse post é uma cópia do README do repositório github.com/lucascaton/lcaton-setuplinux que foi descontinuado e substituído pelos seguintes repositórios:

• https://github.com/lucascaton/dotfiles
• https://github.com/lucascaton/vimfiles

Atualizado em 22/07/2011

Personalização das configurações após instalação do Ubuntu Linux

Última versão testada: Ubuntu 11.04 (desktop edition - 32 bits)

Instalação básica

Antes de mais nada, vamos rodar um update :)

sudo apt-get update

Aptitude (a partir da versão 10.10 do Ubuntu o 'aptitude' não vem instalado por padrão)

sudo apt-get install aptitude

Open SSH Server

sudo aptitude install openssh-server

Ubuntu Restricted Extras

sudo aptitude install ubuntu-restricted-extras

Git & gitg

sudo aptitude install git-core gitg

Curl

sudo aptitude install curl

Suporte à arquivos compactados

sudo aptitude install rar p7zip-full

GTK Record My Desktop, Mencoder, Mplayer e AcidRip

sudo aptitude install gtk-recordmydesktop mplayer mencoder ffmpeg acidrip

nmap

Dica: Rode sudo nmap -sS <ip> pra saber as portas abertas de uma máquina remota. Ou rode netstat -npl | grep <port> para saber os processos servindo determinada porta.

sudo aptitude install nmap

Criar DVDs e converter vídeos

sudo aptitude install devede

Gimp

sudo aptitude install gimp

Cheese

sudo aptitude install cheese

Fonts true type

sudo aptitude install msttcorefonts

Wine

sudo aptitude install wine

Fonte Monaco

sudo mkdir /usr/share/fonts/truetype/myfonts
cd /usr/share/fonts/truetype/myfonts
sudo cp ~/.setuplinux/files/Monaco_Linux.ttf .
sudo chown root:root Monaco_Linux.ttf
sudo mkfontdir
cd ..
fc-cache

Gvim

sudo aptitude install vim-gnome ncurses-term exuberant-ctags

Gmate

git clone git://github.com/gmate/gmate.git
cd gmate && sh install.sh && cd .. && rm -rf gmate

PostgreSQL

sudo aptitude install postgresql postgresql-contrib libpq-dev pgadmin3

Configurar a senha do PostgreSQL

sudo passwd postgres
su - postgres
psql -c "ALTER USER postgres WITH PASSWORD 'sua_senha'" -d template1

Sqlite3

sudo aptitude install sqlite3

Ruby on Rails

Bibliotecas necessárias

Readline headers

sudo aptitude install libreadline5-dev

C++ compiler (necessário para o Ruby)

sudo aptitude install build-essential

Sqlite support

sudo aptitude install libsqlite3-dev sqlite-dev libdbd-sqlite3-ruby libsqlite3-ruby libsqlite3-ruby1.8

Mysql Client (necessário para a gem 'mysql')

sudo aptitude install libmysqlclient15-dev

libxslt (necessário para a gem 'capybara')

sudo aptitude install libxslt-dev

Sphinx (necessário para a gem 'thinking-sphinx')

wget http://www.sphinxsearch.com/downloads/sphinx-0.9.9.tar.gz
tar -xzvf sphinx-0.9.9.tar.gz && cd sphinx-0.9.9
./configure --with-pgsql && sudo make && sudo make install
cd .. && rm -rf sphinx-0.9.9

Image Magick (necessário para a gem 'gruff')

sudo aptitude install imagemagick libmagick9-dev

Cups Sys (necessário para a gem 'cups')

sudo aptitude install libcupsys2-dev

Avahi - dnssd (necessário para a gem 'specjour')

sudo aptitude install libavahi-compat-libdnssd-dev

RVM

curl -sSL https://get.rvm.io | bash -s stable

Atualizar RVM

rvm reload
rvm get stable

Ruby

rvm install ruby

Outros softwares

• Google Chrome
• TweetDeck
• Skype
• Ubuntu Tweak
• XMind
• TeamViewer

Extensões para Google Chrome

• Google bookmarks
• JSBeautify
• JSON formatter
• Last Pass
• Page Speed
• RSS Subscription Extension (by Google)
• XML Tree
• Evernote