Disseram-me IDE! Então eu VIM

Existem muitos artigos e flamewars (principalmente entre vim x emacs) sobre “a melhor IDE para se desenvolver qualquer coisa”. Não vou dizer qual a melhor, até mesmo porque a melhor é a que você gostar mais, mas nesse artigo vou tratar de um programa bem rico e customizável: o VIM.

De início, utilizar o vim parece um “parto”. Tudo é comando, as teclas de atalho mais conhecidas não funcionam, aquela interface simples chega a dar repulsa. Felizmente, isso passa. Nada do que um bom :help para aprender a mexer mo bichinho. Seguir o tutorial padrão do sistema é uma ótima ideia para se aprender o básico, e, daí, aproveitar o máximo que esse editor de textos pode proporcionar.

Uma das características principais do vim é sua customização. Praticamente tudo é customizável, e até programável. A possibilidade de fazer plugins e outras coisas mais como “syntax highlight” vão incrementando sua área de edição a ponto de deixar da maneira que você quiser.

Já utilizo o vim há um tempo, inicialmente para montar HTML + CSS e atualmente para programar em Rails. Praticamente abandonei o Eclipse e o Aptana para utilizar somente o vim. Para chegar a tal ponto de “migrar” de IDE, tive que passar por um relativo processo de customização do editor para que ele ficasse “no ponto”. Existe um arquivo chamado “.vimrc” na pasta raiz da aplicação. É lá que você vai aplicar as alterações propostas nesse artigo.

O arquivo que disponibilizo é uma versão customizada do vim criada por mim, e está todo comentado.

Inicialmente, recomendo a instalação dos seguintes plugins:

Depois, instale um corretor ortográfico da língua portuguesa. Para isso você precisará ter a versão 7 ou superior do vim.

  • Faça o download do dicionário
  • Descompacte o arquivo
  • No vim, digite o comando ‘:mkspell pt /caminho/do/descompactamento/pt_BR’
  • Copie o arquivo gerado para a pasta ~/.vim/spell/
  • Ative a correção: ‘:set spell’
  • Escolha o dicionário: ‘:set spelllang=pt’

Pronto, esses são os plugins que eu recomendo para a utilização do vim e transformá-lo numa verdadeira IDE, mas não basta só isso. Vamos agora para o principal: o arquivo de configuração .vimrc. Eu configurei um arquivo que pode ser utilizado tanto no vim para windows como na versão linux. Peguei um apanhado de configurações da internet e personalizei ao meu gosto. Acredito que provavelmente seja do gosto da maioria.

Se você utiliza o vim no Windows, adicione seguinte linha no início do arquivo:

source $VIMRUNTIME/vimrc_example.vim

Abaixo, o arquivo comentado e explicado.

"""""""""""""""""""""""""""""""""""
" CONFIGURAÇÕES PADRONIZADAS GOGS "
"""""""""""""""""""""""""""""""""""

set number                    " Numera as linhas
set nobackup                  " Não salva arquivos de backup~
set wildmode=longest,list     " Completa o comando com TAB igual o bash

set ignorecase                " Ignora o case sensitive nas buscas
set smartcase                 " Se tiver alguma letra maiúscula, ativa o case sensitive

set smartindent               " Auto-indenta
set expandtab                 " Identa com espaços

set tabstop=2                 " Quantidade de espaços por identação
set shiftwidth=2              " Quantidade de espaços da auto-indentação

set guioptions-=T                    " Deixa a GUI sem a toolbar
set autochdir                 " Vai pro diretório do arquivo aberto

" Corretor ortográfico
set spelllang=pt              " Escolhe o dicionário

" Inicia no modo INSERT
set im
imap <ESC> <C-L>

" Cria e escolhe as abas
noremap <C-T> :tabnew<CR>
noremap <C-TAB> :tabnext<CR>
noremap <C-S-TAB> :tabprevious<CR>
inoremap <C-T> <C-O>:tabnew<CR>
inoremap <C-TAB> <C-O>:tabnext<CR>
inoremap <C-S-TAB> <C-O>:tabprevious<CR>

" Mover texto com os TABs
vnoremap < <gv
vnoremap > >gv
noremap <TAB> >
noremap <S-TAB> <

" Auto-fecha parênteses, chaves etc.
"inoremap { {}<LEFT>
"inoremap ( ()<LEFT>
"inoremap [ []<LEFT>
"inoremap " ""<LEFT>
"inoremap ' ''<LEFT>

" Move linhas ou blocos usando ALT+SETA
nnoremap <A-DOWN> mz:m+<CR>`z==
nnoremap <A-UP> mz:m-2<CR>`z==
inoremap <A-DOWN> <Esc>:m+<CR>==gi
inoremap <A-UP> <Esc>:m-2<CR>==gi
vnoremap <A-DOWN> :m'>+<CR>gv=`<my`>mzgv`yo`z
vnoremap <A-UP> :m'<-2<CR>gv=`>my`<mzgv`yo`z

" Deleta linha com CTRL+D
noremap <C-D> dd
vnoremap <C-D> <C-C>dd
inoremap <C-D> <C-O>dd

" Organiza identação de um bloco selecionado com CTRL+ALT+F
noremap <C-A-F> ==
vnoremap <C-A-F> <C-Q>==
inoremap <C-A-F> <C-O>==

" Command-line com CTRL+ALT+C
noremap <C-A-C> :
vnoremap <C-A-C> <C-Q>:
inoremap <C-A-C> <C-O>:

" Busca com CTRL+F
noremap <C-F> /
vnoremap <C-F> <C-Q>/
inoremap <C-F> <C-O>/

" Abre arquivos com CTRL+O
noremap <C-O> :tabnew 
vnoremap <C-O> <C-Q>:tabnew 
inoremap <C-O> <C-O>:tabnew 

" Função que usa o omnicomplete apenas com o CTRL+SPACE
inoremap <C-SPACE> <C-X><C-O>
filetype plugin on

"""""""""""""""""""""""""""""
" Atalhos comuns de teclado "
"""""""""""""""""""""""""""""

" Permite selecionar com SHIFT + SETA como no Windows
set selectmode=mouse,key
set mousemodel=popup
set keymodel=startsel,stopsel
set selection=exclusive

" Backspace no modo de visão apaga a seleção
vnoremap <BS> d

" CTRL-X e SHIFT-Del corta
vnoremap <C-X> "+x
vnoremap <S-Del> "+x

" CTRL-C e CTRL-Insert copia
vnoremap <C-C> "+y
vnoremap <C-Insert> "+y

" CTRL-V e SHIFT-Insert cola
noremap <C-V>        "+gP
noremap <S-Insert>   "+gP
inoremap <C-V>       <C-O>:set nosi<CR><C-R>+<C-O>:set si<CR>
inoremap <S-Insert>  <C-R>+
cnoremap <C-V>       <C-O>:set nosi<CR><C-R>+<C-O>:set si<CR>
cnoremap <S-Insert>  <C-R>+

" CTRL-S salva
noremap <C-S>  :update<CR>
vnoremap <C-S> <C-C>:update<CR>
inoremap <C-S> <C-O>:update<CR>

" CTRL-Z desfaz
noremap <C-Z> u
vnoremap <C-Z> <C-C>u
inoremap <C-Z> <C-O>u

" CTRL-Y refaz
noremap <C-Y> <C-R>
inoremap <C-Y> <C-O><C-R>

" CTRL-A seleciona tudo
noremap <C-A> gggH<C-O>G
inoremap <C-A> <C-O>gg<C-O>gH<C-O>G
cnoremap <C-A> <C-C>gggH<C-O>G
onoremap <C-A> <C-C>gggH<C-O>G
snoremap <C-A> <C-C>gggH<C-O>G
xnoremap <C-A> <C-C>ggVG

" CTRL-F4 fecha a janela
noremap <C-F4> <C-W>c
inoremap <C-F4> <C-O><C-W>c
cnoremap <C-F4> <C-C><C-W>c
onoremap <C-F4> <C-C><C-W>c

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" Opções de plugins (Retire essas linhas se não tiver estes plugins) "
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

colorscheme ir_black                                              " Escolhe o tema
au BufNewFile,BufRead *.txt source ~/.vim/syntax/txt.vim          " Carrega o arquivo de sintaxe para TXT

" Atalhos para plugins
noremap <F5>  :NERDTree<CR>
noremap <F7>  :set spell<CR>z=
inoremap <F5> <C-O>:NERDTree<CR>
inoremap <F7> <C-O>:set spell<CR><C-O>z=

"""""""""""""""""""""""
" Informações e dicas "
"""""""""""""""""""""""
" Plugins recomendados:
" - NERDTree :: Lista os arquivos em árvore
" - ir_black :: Colorscheme bem bonito
" - txt.vim :: Sintaxe para arquivos de texto feito pelo aurelio.net
" - jquery.vim :: Sintaxe para arquivos jquery.vim
" - html_autoclosetag :: Fecha as tags HTML automaticamente
" - snipMate :: Autocompleta funções inteiras
"               Para que o <tab> do snipMate não anule o TAB para identar
"               blocos, edite o arquivo ~/.vim/after/plugin/snipMate.vim
"               substituindo os mapeamentos 'ino' por 'imap' como no ex.:
"               imap <silent> <tab> <c-r>=TriggerSnippet()<cr>
"               imap <silent> <s-tab> <c-r>=BackwardsSnippet()<cr>
"               imap <silent> <c-r><tab> <c-r>=ShowAvailableSnips()<cr>
"               Apague todas as linhas começadas por 'snor'.
"
" Corretor ortográfico em português brasileiro:
" - Faça o download do dicionário em: http://www.broffice.org/verortografico/baixar
" - Descompacte o arquivo
" - No vim, digite o comando ':mkspell pt pt_BR'
" - Copie o arquivo pt.utf-8.spl gerado para a pasta ~/.vim/spell/
" - Ative a correção: ':set spell'
" - Escolha o dicionário: ':set spelllang=pt'

Anúncios

Mongrel no lugar de Webrick

Vou ser bem direto: Webrick não é uma opção para servidor Ruby on Rails. Nem para testes.

Recentemente trabalhei no desenvolvimento de um sistema de indicações de oportunidades de negócios. O sistema era bem simples, e o desenvolvimento só não foi mais rápido pois foi o primeiro projeto adotado a ser desenvolvido em Ruby on Rails pela empresa. Como já citei num artigo anterior, “as primeiras semanas foram doloridas. Pensar tudo de trás para frente, uma nova linguagem, e tudo o mais que uma migração assim nos permite sofrer, pode ser um pouco dolorido, mas vale a pena.”

Uma das coisas que passei mais sufoco foi, com certeza, a dificuldade de configurar um servidor de entrega. Diversos fatores entraram em questão, a própria decisão de qual máquina seria escolhida, a criação da máquina virtual (já haviam outras máquinas virtuais instaladas) e outras particularidades que não dizem respeito ao RoR.

Se tratava de um servidor simples, que seria utilizado apenas para mostrar aos clientes o sistema funcionando e permitir que eles pudessem “brincar” um pouco com o sistema. Pensei logo: “ora, já usamos o Webrick para testes locais, logo não encontraremos problemas.” Mas não foi bem assim.

Rodar o Webrick localmente pode fazer tudo o que você pretende, mas tente rodar de um IP remoto. Pensando bem, tente rodar utilizando seu póprio IP da rede (não vale 127.0.0.1). No caso do nosso sistema, o carregamento de uma página simples de login durava cerca de 3 min. Quando entrava, enfim, no sistema, além da demora, alguns elementos (imagens) não eram carregadas. O Webrick era a grande dor de cabeça.

Parece besteira de iniciante. E realmente era, mas naquele momento eu simplesmente não poderia ter perdido tanto tempo com isso.

A segunda tentativa que nos parecia óbvia foi instalar o Passenger: um mod_rails para o Apache que supostamente seria a opção mais viável. A instalação não foi tão diferente quanto qualquer mod para Apache, e suas configurações. O problema foi a inconstância do pacote e das gems. Primeiro que é quase impossível desinstalar a gem. Quando assim o fiz, simplesmente a gem continuava lá na “gem list”, mesmo desinstalada. Depois de formatarmos a máquina virtual e instalarmos tudo do zero novamente, funcionou perfeitamente. Nos demos por satisfeitos.

No dia seguinte, sem maior explicação ou alguém ter sequer acesso ao servidor, o passenger não funciona mais. E isso já era véspera da entrega do sistema. Algo assim não poderia falhar. Não era uma opção.

A essa altura, depois de muitas tentativas de correção, já havíamos desistido de entregar através do servidor de testes. Continuamos o desenvolvimento do sistema, pois alguns tópicos precisavam ser finalizados.

Dia seguinte, dia de entrega. Lendo alguns artigos em blogs que tratavam de Rails, me veio a possibilidade de testar o Mongrel. Fui meio sem esperança, pensando se tratar de algo “como o Webrick”, que serviria apenas para testes locais. A instalação é bastante simples, não passando de um “gem install mongrel”. Para rodar, bastava digitar “mongrel_rails start”. Nenhuma configuração foi necessária, nenhuma palha foi mexida, nada mais foi feito. Simplesmente duas linhas e lá estava meu servidor de testes funcionando e rodando a aplicação perfeitamente.

Em 2 min concluí uma operação que me custou cerca de 20 horas sem sucesso. Mais tarde, ao me aprofundar e ler casos de uso, descobri que o mesmo servidor Mongrel é o servidor Rails utilizado pelo Twitter. Sem sombra de dúvidas, poderia ser facilmente utilizado no servidor final, de produção.

Programação orientada a layout

O que vou falar aqui talvez não seja grande novidade (afinal o que é que se fala que alguém já não tenha falado antes?), mas se trata de uma forma que gosto de pensar em por em prática um dia, sob uma rotina organizada e real.

Se trata de pensar como o cliente, e dar ao cliente o que ele precisa, logo de cara, para evitar alterações no sistema e tornar o processo de produção e desenvolvimento algo “palpável”, direto e real.

Tenho apreciado bastante Metodologias Ágeis, principalmente XP (eXtreming Programing) e isso tem tudo a ver com o que eu estou falando: a partir das iterações (reuniões periódicas), apresentar pequenas funcionalidades e etapas do projeto, ao invés de simplesmente estipular um prazo X e tentar correr para cumpri-lo, e até lá o cliente fica “na mão”.

Um ótimo livro que recomendo para a leitura que fala justamente disso é o “Getting Real” (Caia na Real, em tradução livre), recomendado pelo caríssimo Clavius Tales.

Pensando no layout primeiro

Uma das coisas que mais emperram um projeto é cliente que cisma com pequenas coisinhas do projeto. As vezes um tempo valiozo é perdido ajeitando-se “bugs” de layout, ou erros de português, enquanto que poderia-se estar desenvolvendo funcionalidades que tornariam o sistema realmente funcional.

Sendo assim, a prototipação entra em primeiro lugar. De que adianta mostrar ao cliente um cadastro sendo efetuado sob uma aparência completamente irreal? O próprio cliente se tornaria mais interessado e já teria “algo nas mãos” se o layout fosse pensado e realizado inicialmente, além de evitar que toda uma equipe seja deslocada para o desenvolvimento.

Não diria que tudo do sistema deveria ser desenhado previamente, mas ao menos todas as funcionalidades solicitadas para a primeira etapa do

Cito aqui um trecho do livro de Seth Godin: http://gettingreal.37signals.com/GR_por.php#ch09

Desenhe a interface antes de começar a programar

Muitos aplicativos começam com a mentalidade de programar primeiro. Isso é uma má idéia. Programação é o componente mais pesado de construir em um aplicativo, significando ser o mais caro e mais difícil de mudar. Ao invés disso, comece desenhando primeiro.

Design é relativamente leve. Um esboço de papel é barato e fácil de mudar. Rascunhos HTML são relativamente simples de modificar (ou jogar fora). Isso não é verdade na programação. Desenhar antes deixa você flexível. Programar primeiro prende você e gera custos adicionais.

Outra razão para projetar primeiro é que a interface é o seu produto. O que as pessoas vêem é o que você está vendendo. Se você somente rabiscar uma interface no final, os buracos vão aparecer.

Nós começamos pela interface para que possamos ver como o aplicativo será desde o começo. Este será constantemente revisado no decorrer do processo. Isso faz sentido? É fácil de usar? Ele resolve um problema de imediato? Existem perguntas que você só poderá realmente responder quando você lidar com telas reais. Desenhar antes deixa você flexível e o leva para essas respostas no processo mais cedo do que mais tarde.

WebDesigner e Designer de Interação têm espaço garantido

Já não dá mais para pensar em programar só código e desmerecer o layout. Lembre-se que a maior parte do contato que o usuário vai ter com seu sistema será o layout e as facilidades ou dificuldades que a interface irá proporcionar a ele. Não se dê ao luxo de não precisar de alguém que faça um design bacana do seu sistema, só para economizar uma grana com salário ou serviço “por fora”. Hoje em dia sistemas pouco intuitivos não têm mais espaço no mercado.

Sabe-se que a grande maioria dos usuários só utilizam uma pequena porcentagem das ferramentas que os sistemas dispõem. Então para quer pensar em tudo, e acabar oferecendo um trem complicado de pilotar? Por que não oferecer uma bicicleta para o seu cliente, e, aos poucos ir incrementando rodinhas e outras coisas mais até ela se tornar uma Harley Davidson?

O Designer de Interação tem a visão necessária para entender o que realmente precisa estar ali e o que é inutil para o cliente. Um exemplo bem prático é o MSN. Alguém já leu algum tutorial ou manual de MSN? Porém todos sabem mexer. É uma ferramenta simples, mas super útil. Pense bem nisso antes de querer fazer um sistema de chat com suporte a mediadores e diversas salas e sub-salas com usuários X que fazem Y coisas. Pense simples! Caia na real.

Maré de Agilidade em Fortaleza

Convido a todos para o Maré de Agilidade, que o correrá em Fortaleza dos dias 6 a 8 de agosto.

Não dá mais para ser um programador “meia-boca” e programar por conta própria (mesmo numa equipe) sem ter noções de metodologias ágeis. Nem só de tecnologias e linguagens novas se baseia a evolução da informática e seus meios de produção, mas também de técnicas de gerência e de divisão de tarefas.

Para quem não conhece, recomendo dar uma estudada sobre o que eu estou falando, principalmente sobre XP e Scrum. Garanto que muitos horizontes irão se abrir (e ótimas oportunidades de trabalho).

O evento visa promover, de 06 a 10 de agosto de 2009, três dias de mini-cursos e um dia de palestras e discussões sobre as novas tendências em gerência de projetos e técnicas de desenvolvimento de software que constituem atualmente o grande diferencial de empresas como Apple, Google, Microsoft, Yahoo e Globo.com.br.

Maiores informações poderão ser encontradas no site dos organizadores e as inscrições serão feitas pela Fortes Treinamentos.

CodeIgniter + Ruby on Rails + Django

Gostaria de fazer um breve comparativo entre esses três frameworks, pois julgo terem bastante semelhanças e trabalham de forma parecida.

Confesso que o título original desse artigo era “CodeIgniter x Ruby on Rails x Django“, mas por que ser ‘versus’ se pode ser ‘mais’?

Não vou ser determinista nem tampouco taxativo, mas poderia resumir uma possível dúvida quanto à escolha do melhor na seguinte frase: “Escolha sua linguagem e pegue seu Framework“. Diria que é mais um relato de utilização do que propriamente um comparativo de funcionalidades.

CodeIgniter

Trabalhei com CodeIgniter no desenvolvimento do site Portal da Classe Contábil, projeto iniciado pela Fortes Informática e hoje um dos maiores portais de contabilidade do país. Já tínhamos uma equipe que trabalhava com PHP e outra que trabalha com Java, sendo que a de PHP nunca havia experimentado um framework antes.

A curva de aprendizado foi realmente muito curta, apesar de não termos utilizado todos os plugins e bibliotecas que ele oferecia (muita coisa tivemos que fazer na mão, devido a complexidade do portal). Os conceitos de MVC são muito bem aplicados e nos permitiu ter um ritmo de desenvolvimento realmente ágil. Como entrei no projeto inicialmente como webdesign, a separação do ambiente das “views” foi essencial para o sucesso da equipe.

Ruby on Rails

Recentemente recebemos uma demanda muito grande no desenvolvimento de sistemas para web e, como já vínhamos adotando XP e metodologias ágeis na empresa, buscamos alguma ferramenta que pudéssemos ser mais produtivos e realizar testes e iterações mais eficientes.

Foi determinado então que a ferramenta utilizada seria o Ruby on Rails. Por quê? Porque foi um framework realmente pensado e elaborado para ser utilizado por quem utiliza metodologias ágeis.

Sob a consultoria de Christiano Milfont, tivemos o prazo de 2 meses para desenvolver um sistema interno de indicações de prospectos. Confesso que as primeiras semanas foram doloridas. Pensar tudo de trás para frente, uma nova linguagem, e tudo o mais que uma migração assim nos permite sofrer, pode ser um pouco dolorido, mas vale a pena.

Não diria que virei fã incondicional de Ruby on Rails, mas com certeza diria que é um framework excelente e bastante produtivo. Creio que o domínio da ferramenta e um interesse por aprender uma nova linguagem possam fazer do profissional um cara extremamente produtivo.

Django

Meu coração até bate forte ao falar de Python (sem maldade, por favor). Não entendo por que essa linguagem não é utilizada por todos. Mas, quer saber? Não estou nem aí. Desde que eu a utilize e consiga fazer tudo muito rápido e com o código altamente organizado e simples, eu não me importo com o que os outros achem.

Django é um framework altamente pythônico. Pythônico no que se diz a “programe pouco que eu faço tudo”. Realmente é incrível como ele trata com simplicidade tarefas corriqueiras. E não engessa tanto. Talvez essa seja uma de suas principais qualidades: você pode usar o framework, mas se não quiser, não use!

Suas pastas são todas organizadas da mesma forma que classes do Python e tem um plugin fantástico, onde toda a administração é gerada automaticamente. Não se preocupe com (quase) nada do backend… o Django faz (quase) tudo para você.

Python é minha escolha para projetos pessoais e pretendo com um tempo utilizar profissionalmente. Me espanta as empresas e os próprios programadores não darem valor a uma linguagem tão produtiva e organizada. Talvez por ser fácil demais, e eles não acreditarem que possa ser uma linguagem realmente poderoza, ou talvez por modismo mesmo (as que estão em voga ainda são Java e Ruby).

Conclusão

Acho que deu para perceber qual seria a minha escolha, mas se você for escolher um desses frameworks, pensem primeiro que linguagem você gostaria de utilizar, então estude o framework correspondente.

… mas não descarte os outros. Hoje em dia programador nenhum pode se dar ao luxo de se prender a uma só linguagem.

A internet e o usuário

Parece que o pessoal está levando essa história de Web 2.0 muito a sério. E cada vez estão inventando novas maneiras de interação com o usuário.

Não bastassem as redes sociais, os twitters, os fotologs, onde “quem manda” é o usuário, agora estão buscando novas experiências de navegação. A utilização da webcam já é algo comum em alguns sites por aí.

Destaco o site da Agência Interativa F. biz. (dica do Robertson Freitas), onde é possível “rolar” o site para a direita ou para a esquerda utilizando o movimento da mão. Com certeza é algo bem interessante e inovador, próprio dessas ideias malucas que as agências tem. 😀 Apesar de ser uma forma de navegar completamente inusitada, “a la” Wii ou iPhone, não acredito que pode vir a se tornar uma tendência dos sites, ou que vá aposentar o mouse, mas vale a pena experimentar essa inovação.

Outros exemplos que posso dar é aquela história de realidade aumentada. Recentemente vi no site da Brainstorm9 um link interessantíssimo de uma ação da Doritos em que o cara posicionava o saquinho de Doritos em frente à webcam e lá estava… um show do Blink 182 dentro do saquinho que você acabou de esvaziar. Muito legal!

Para aqueles que precisam inovar no seu site, fica aí a dica. Para aqueles que querem ter essas experiências com realidade aumentada, uma boa busca no Google vale a pena.

Blender Day Fortaleza – Um resumo

Quem me segue no twitter pôde acompanhar minha ansiedade pelas palestras e as oficinas que estariam por vir, e não muito fora de minhas espectativas: aquele velho discurso com exemplos que já conhecia pela internet e uma certa propraganda dos organizadores e sua empresa.

Apesar de tudo posso apresentar pontos muito positivos, principalmente sobre as oficinas. Com oficinas como Blender para iniciantes e modelagem de personagens, o conteúdo adquirido foi bastante rico e despertou o meu interesse ainda mais nessa maravilhosa ferramenta.

Blender talvez seja um dos mais perfeitos exemplos de um software livre bem utilizado para fins profissionais e que não se trata apenas de um “similar ao comercial“, mas conseguiu atingir o patamar de “ferramenta referência”. O que se percebe é que ferramentas comerciais hoje já se espelham no Blender e copiam algumas de suas funcionalidades.

Como foi um curso rápido, pude praticar um pouquinho e abaixo posto meu primeiro objeto 3D.

Taça desenhada em Blender
Taça desenhada em Blender