diofeher

Vim - Tips and Tricks

I'm gonna use this post to put all tips and tricks that I found.

configuration

set invlist  # see invisible characters

set tabstop  #specifies the width of tab character
set softtabstop  #when enabled, fine tunes the amount of whitespace to be inserted 
set shiftwidth  #determines the amount of whitespace to insert or remove using identation
set expandtab  #when enabled, cause spaces to be used instead of tabs

Scrubs Quote

Miss Goldman: What now, Grampa?!

Dr. Kelso: You are going to shut your damn yapper and listen for a change, because I got you pegged, sweetheart. You want to take the easy way out with the surgery because you're scared. You're scared because if you try and fail, there's only you to blame. Well, Missy, let me break this down for you, Bobbo-style. Life is scary. Get used to it.

J.D.'s Narration: And then it seemed like Dr. Kelso wasn't only talking to her.

Dr. Kelso: There are no magical fixes. It's all up to you. So get up off your keister, get out of here, and go start doin' the work.

[Howie Day's "Collide" beings]

Miss Goldman: What if it's too hard?

Turk: [leaning down to face Dr. Kelso next to Miss Goldman] Yeah, what if it's too hard?

Dr. Kelso: Turkleton, I have no idea why you're chiming in, but I'll say this to both of you. Nothing in this world that's worth having comes easy.

Applications Links in Web Pages

This is how you link web pages to instant message applications in your pages.

AOL Instant Messenger: aim:goaim?screenname=#screenname#

Google Talk: gtalk:chat?jid=#google email# or gtalk:call?jid=#google email#

MSN/Windows Live IM: msnim:chat?contact=#screenname#

Skype: skype:#screenname#?call or skype:#screenname#?chat

Yahoo! Instant Messanger: ymsgr:sendim?#screenname#

An example can be seen at the header of my website.

Tips from journeyman to master

These tips come from a book that I finished reading yesterday. Its name is The Pragmatic Programmers: From Journeyman to master. It's very good for actually is a developer.

Tip 1: Care about your career

Tip 2: Think about your work

Tip 3: Provide options, don't make lame excuses

Tip 4: Don't live with broken windows

Tip 5: Be a catalyst for change

Tip 6: Remember the big picture

Tip 7: Make quality a requirements issue

Tip 8: Invest regularly in your knowledge portfolio

Tip 9: Critically analyze what you read and heard

Tip 10: It's both what you say and the way you say it

Tip 11: DRY - Don't Repeat Yourself

Tip 12: Make it easy to reuse

Tip 13: Eliminate effects between unrelated things

Tip 14: There are no final decisions

Tip 15: Use Tracer Bullets to find the target

Tip 16: Prototype to learn

Tip 17: Program close to domain

Tip 18: Estimate to avoid surprises

Tip 19: Iterate the schedule with the code

Tip 20: Keep knowledge in plain text

Tip 21: Use the power of command shells

Tip 22: Use a single editor well

Tip 23: Always use Source Code Control

Tip 24: Fix the problem, not the blame

Tip 25: Don't panic

Tip 26: Select isn't broken

Tip 27: Don't assume it, prove it

Tip 28: Learn a text manipulation language

Tip 29: Write code that writes code

Tip 30: You can't write perfect software

Tip 31: Design with contracts

Tip 32: Crash early

Tip 33: If it can't happen, use assertions to ensure that it won't

Tip 34: Use exceptions for exceptional problems

Tip 35: Finish what you started

Tip 36: Minimizing coupling between modules

Tip 37: Configure, don't integrate

Tip 38: Put abstractions in code details in metadata

Tip 39: Analyze workflow to improve concurrency

Tip 40: Design using services

Tip 41: Always design for concurrency

Tip 42: Separate views from models

Tip 43: Use blackboards to coordinate workflow

Tip 44: Don't program by coincidence

Tip 45: Estimate the order of your algorithms

Tip 46: Test your estimates

Tip 47: Refactor early, refactor often

Tip 48: Design to test

Tip 49: Test your software, or your users will

Tip 50: Don't use wizard code you don't understand

Tip 51: Don't gather requirements - dig for them

Tip 52: Work with a user to think like a user

Tip 53: Abstractions live longer than details

Tip 54: Use a project glossary

Tip 55: Don't think outside the box - find the box

Tip 56: Listen to nagging doubts - start when you are ready

Tip 57: Some things are better done than described

Tip 58: Don't be a slave to formal methods

Tip 59: Expensive too do not produce best designs

Tip 60: Organize around functionality, not job functions

Tip 61: Don't use manual procedures

Tip 62: Test early. Test often. Test automatically

Tip 63: Coding ain't done 'til all the tests run

Tip 64: Use saboteurs to test your testing

Tip 65: Test state coverage, not code coverage

Tip 66: Find bugs once

Tip 67: Treat english as just another programming language

Tip 68: Build documentation in, don't bolt it on

Tip 69: Gently exceed your users expectations

Tip 70: Sign your work

Later I will talk about these topics detailedly.

[]'s

Dicas para deixar os sites mais rápidos

Esse post foi inspirado por um livro que li sobre performance em websites. Seu nome é "High Performance Websites" e ele foi escrito por um desenvolvedor do Yahoo. Para quem é desenvolvedor de front-end sua leitura é indispensável. Resolvi publicar aqui no blog algumas dessas formas de otimização e explicar o porquê de cada.

1 - Fazer poucas requisições HTTP

Pesquisas mostram que mais de 80% do carregamento de uma página é gasto no front-end. Então diminuir o número de componentes para consequentemente ter menos requisições é uma boa. Para fazer isso, utilizam-se praticamente duas técnicas, chamadas de Image Maps e CSS Sprites. Nos Image Maps utilizamos uma imagem e mapeamos seus pontos. A imagem precisa ser contínua, como uma barra de navegação. Essa tarefa de marcar os pontos é muito suscetível a erros e é cansativa, por isso recomenda-se o uso de CSS Sprites. Com ele, juntam-se todas as imagens estáticas que compõem a estrutura do site e cada pedaço da imagem é colocado como fundo de um bloco e reposicionado usando background-position. Não se preocupe, algumas ferramentas online fazem isso para você, como o http://csssprites.com/

2 - Comprimir usando GZIP

A partir do HTTP 1.1 os browser implementaram um cabeçalho chamado Accept-Encoding. Isso significa que o servidor pode mandar um arquivo comprimido com deflate ou gzip (mais popular) que o browser conseguirá descomprimir. Essa compressão geralmente diminui o tamanho do arquivo em 70%. O único contra do Gzip é usá-lo em arquivos já comprimidos, tais como mp3, jpg, pdf entre outros, pois como esses arquivos tem sua compressão própria a compressão com gzip pode até aumentar o tamanho do arquivo. Ele é recomendando principalmente em arquivos de texto plano, tais como HTML, CSS e Javascript.

3 - Tornar o CSS e o JS externos

Com o CSS e o JS externos você diminui o tamanho do seu documento HTML e aumenta em duas requisições HTTP (considerando um arquivo para cada). Como isso pode ser bom, de acordo com 1 (Diminuir requisições HTTP)? Com os arquivos externos, você pode cachear-los, diminuindo consideravelmente o tempo de carregamento. Geralmente fazendo isso se tem um desempenho melhor nos sites. A única exceção para esse ponto são em páginas que geralmente são acessadas apenas uma vez (tais como páginas de home), tornando o cache inútil.

4 - Colocar o CSS no topo

Quando o browser está renderizando a página, ele renderiza na ordem que vai encontrando os elementos no seu html. O maior problema de colocar o CSS no final da página é que os browsers evitam de renderizar para não ter que renderizar novamente depois que acharem o CSS. Isso vai deixar uma página branca para o usuário, até que o CSS seja renderizado. Uma coisa que muita gente acha é que fazendo isso a página terá um tempo de carregamento mais rápido. Mas NÃO, o tempo de carregamento não é diferente. A única coisa que muda é a visualização por parte do usuário pois com o CSS no topo, ele pode navegar na página já com um feedback visual. Simples, né?

5 - Colocar o JS no rodapé

A regra geral é que são feitos dois downloads paralelos por domínio quando uma página é acessada. Colocar o script no head ou no meio da página HTML vai paralisar os downloads paralelos enquanto somente o script é carregado. Somente evite colocá-los no rodapé se eles contiverem alguma função como document.write, por exemplo.

6 - Colocar um cabeçalho Expires nos arquivos

Ao acessar um site pela primeira vez, seu browser faz um requisição de uma página para o servidor. O servidor processa e retorna uma página para você. O browser começa a fazer requisições dos outros arquivos que estão lá (imagens, CSS, scripts) até carregar tudo. Na segunda vez que você acessa o site, o carregamento é bem mais rápido, certo? Isso acontece porque o browser mantêm em cache os arquivos do site e logicamente o carregamento é bem mais rápido. Mas isso ainda pode ser melhorado. Desse modelo que citei anteriormente, o browser ainda precisa fazer um GET condicional, para saber se o arquivo mudou (geralmente essa comparação é feita com a data de última modificação, mas também pode ser feita de outros jeitos, como com E-tags) e então o servidor retorna uma requisição 304 (arquivo não modificado). Se colocar um cabeçalho Expires nos seus arquivos, o browser não precisa fazer esse GET condicional no servidor, deixando o carregamento ainda mais rápido.

7 - Minificar arquivos JS e CSS

A técnica de minificar se constitui em tirar espaços desnecessários (espaços, tabulações, linhas em branco) e comentários dos arquivos, diminuindo consideravelmente seu tamanho. Um dos que eu gosto de usar é o YUI Compressor.

Essas são somente algumas formas. Existem várias outras, e muitas estão nesse livro que citei no começo do post. Eu repito, se você é desenvolvedor web, não deixe de ler o livro. E aproveite também seu amigo Google para se aprofundar no assunto. :)

Brainfuck – When you see it, you will shit bricks

o que é

Ontem tava sem nada para fazer e resolvi brincar um pouco com os problemas dos Google Code Jam anteriores. Vendo as soluções feitas por outras pessoas, acabei vendo a de um cara que fez em Brainfuck. Brainfuck, WTF???

Brainfuck é uma linguagem que foi criada em 1992 por Urban Müller, com o objetivo de ter o menor compilador existente. Ela implementa seus comandos de outra linguagem esotérica, chamada ``P. Essa linguagem é Turing completa.

Seu funcionamento é o seguinte: O compilador separa cerca de 30000 células de memória para o programa acessar (versões mais atuais de compiladores chegam a ter apenas 5000). Todas as células estão com o valor zero, e você tem um ponteiro que começa na posição inicial. Você pode usar esse ponteiro para movimentá-lo pelas células e então ter o funcionamento do seu programa.

A linguagem possui oito comandos, são eles:

> - acrescenta uma posição de célula de memória ao ponteiro.
< - diminui uma posição célula de memória ao ponteiro.
+ - aumenta o valor da posição que o ponteiro está.
- - diminui o valor da posição em que o ponteiro está.
[- itera por uma posição até a mesma chegar a 0.
]- indica o final da iteração
, - permite a entrada de um caractere. (getchar em C).
. - imprime na tela o valor atual do ponteiro.

escrevendo um programa

Resolvi escrever um I love you em brainfuck, então vou mostrar como fiz esse programa:

++++++++++[>+++++++>++++++++++>+++++++++++>++++++++++++>+++
<<<<<-]>+++.>>>>++.<<<++++++++.>+.+++++++.<-------.>>>.<+.<-------.++++++.>>+.
<<<<<+++++++++++.

Agora identado para melhor compreensão:

+++++ +++++
[
> +++++ ++ add 7 to cell 1
> +++++ +++++ add 10 to cell 2
> +++++ +++++ + add 11 to cell 3
> +++++ +++++ ++ add 12 to cell 4
> +++ add 3 to cell 5
<<<<< -
]

> +++ .          print 'I'
>>>> ++ .        print ' '
<<< ++++++++ .   print 'l'
> + .            print 'o'
+++++++ .        print 'v'
< ------- .      print 'e'
>>> .            print ' '
< + .            print 'y'
< ------- .      print 'o'
++++++ .         print 'u'
>> + .           print '!'
<<<<< +++++++++++  .

Na primeira linha, aumentei o contador da célula 0 para 10, que vai ser o número de iterações pelo loop. Usando a tabela ASCII, juntei os caracteres que tem a representação decimal próximos (exemplo: o é 111 e u é 117). No final da iteração, diminuimos o contador, até chegar a zero, o que determina o final da iteração. Então, a célula 1 ficou com valor de 70, a célula 2 de 100, a célula 3 de 110, a célula 4 de 120 e a célula 5 de 30.

Depois da iteração, é só ir mudando de uma célula para a outra, e adicionando os valores que forem necessários (na célula 3 temos 110, então adicionamos 1 para poder imprimir um caractere ASCII 'o'). Se algum valor tiver maior, é só dimunuir com - e quando chegar no código do caractere, é só imprimir!

Espero que isso deixe a cabeça de muita gente louca ;)