Void Word - A palavra vazia sobre tecnologia, informação e diversão

Javascript patters, antipatterns and performance tips

2012-02-01T19:34:00.001-02:00

Shi Chuan, a freelance developer, has compiled, as himself sayd, "A JavaScript pattern and antipattern code collection that covers function patterns, jQuery patterns, design patterns, general patterns, literals and constructor patterns, object creation patterns, code reuse patterns (upcoming), DOM and browser patterns (upcoming)."

It is worth looking

Creating your own PEAR channel using GitHub

2011-12-07T19:19:00.001-02:00

Every PHP developer always dreamed about having his own PEAR channel, in this post I'll show you guys how to create it. Lets begin by understanding how does PEAR work, basically, a PEAR channel is a REST service with all the needed information about the packages on the channel, such as releases, stability, maintainers, categories and stuff. If you use this channel, the PEAR client will hit this "service" and parse all the information about the packages.

The last and final step is the installation of the package itself, the PEAR client hits the channel, parses the information about the last release of the package, download it and extract the files in the include path, nothing more, nothing less, it's that ease.

So the first step is create the channel is to set up GitHub, let's create a repository called "pear"

Create the repository on GitHub
$ mkdir pear
$ cd pear
$ git init
$ touch README
$ git add README
$ git commit -m 'First commit'
$ git remote add origin git@github.com:[your git username]/pear.git
$ git push -u origin master

Now we must active the gh-pages branch on our new repository. In every repository, if you create a branch called gh-pages, all the files on that branch will be available on the URL http://[your git username].github.com/[you repository name], and GitHub is transformed in a webserver.

$ cd pear
$ git symbolic-ref HEAD refs/heads/gh-pages
$ rm .git/index
$ git clean -fdx

Now, the next step is create the files that compose the PEAR channel/server structure, and as you can imagine, this is a very painfull (and boring) task, but in order to make things easier, we'll use Pirum, a PEAR package that automatically create all the needed files, and since Pirum is a PEAR package, we'll install it using...PEAR.

$ pear channel-discover pear.pirum-project.org
$ pear install pirum/Pirum

With Pirum installed, we just need to create one more file, called pirum.xml, this file contains the basic information that Pirum need in order to create the channel structure, it must be created inside the pear folder and must be as follows:

<?xml version="1.0" encoding="UTF-8" ?>
<server>
<name>[your github user].github.com/pear</name>
<summary>[your github user] PEAR channel</summary>
<alias>[your github user]</alias>
<url>http://[your github user].github.com/pear</url>
</server>

Change the file to meet your informations and save it, and with the file created, you are ready to create the channel.

$ cd pear
$ pirum build .
$ git add -A
$ git commit -m "Channel created"
$ git push origin gh-pages

Your PEAR channel is now available (but in some cases GitHub can take up to 10 minutes to activate GitHub Pages on your acount), and you can test it out.

$ pear channel-discover [your github user].github.com/pear
$ pear channel-info [your github user]

Now that you have your channel, you probably want to add some packages to it, and to make this you need to create a package.xml file for each project that you want to create a package, this file can be huge, mostly by the fact that every file in your project must be listed in the package.xml file, so create the package.xml file manually can be even more painfull than the creation of the channel itself, so again, in order to make things easier, we'll use another software, Pearfarm.

Pearfarm reads all the files in your project and create the package.xml file based on a specification file. But, enough talking, let's start.

$ pear channel-discover pearfarm.pearfarm.org
$ pear install pearfarm.pearfarm.org/pearfarm
Go to the directory that contains your project files (not the pear directory)
$ pearfarm build
After you run the above command, a file named pearfarm.spec will be created on the directory that contains your project files, open this file and edit the information about your project
$ pearfarm build

At this point, you are ready to create your package, let's validate the package.xml file generated by Pearfarm and then build our package (at this point, you can also make manual changes on the package.xml file that Pearfarm has generated if you need, but be carefull).

$ pear package-validate
$ pear package

Package created, now lets add it to your channel.

Copy the .tgz file to your pear directory
$ cd pear
$ pirum add . [filename].tgz
$ pirum build .
$ git add -A
$ git commit -m "My first package added to my channel, thanks Gabriel Ricci"
$ git push origin gh-pages

And you're done, now everyone can have access to your projects through PEAR, don't forget to take a look at my PEAR channels, http://gabrielricci.github.com/pear and http://terophp.github.com/pear and at my repositories in GitHub, http://www.github.com/gabrielricci and http://www.github.com/TeroPHP.

Oh, one last thing, in my experience PEAR is not the most easy application to deal with, it has it's own cache system which may drive you crazy, so, http://pear.php.net and Google are your friends.

My essential firefox extensions

2011-11-23T16:09:00.001-02:00

Hello, today I want to share the extensions I use in Firefox when I'm developing a website.

Firebug
http://getfirebug.com/

Firebug integrates with Firefox to put a wealth of web development tools at your fingertips while you browse. You can edit, debug, and monitor CSS, HTML, and JavaScript live in any web page.

MeasureIt
https://addons.mozilla.org/en-US/firefox/addon/measureit/

Draw a ruler across any webpage to check the width, height, or alignment of page elements in pixels.

JSONView
http://jsonview.com/

JSONView is a Firefox extension that helps you view JSON documents in the browser.

Besides the normal extensions, there are also extensions that work only with firebug.

Code Coverage for Firebug
http://code.google.com/p/code-coverage-for-firebug/downloads/list

This Firebug extension is used to report Javascript code coverage

CSS usage
https://addons.mozilla.org/en-US/firefox/addon/css-usage/

Firebug extension to view which CSS rules are actually used.

EventBug
http://getfirebug.com/wiki/index.php/Firebug_Extensions#Eventbug

Eventbug is a Firebug extension that lists all of the event handlers on the page grouped by event type

Firefinder
http://robertnyman.com/firefinder/

Firefinder is an extension to Firebug (in Firefox) and offers the functionality to, in a quick way, find HTML elements matching chosen CSS selector(s) or XPath expression. It allows you to instantly test your CSS selectors in the page while seeing the content at the same time, and matching elements will be highlighted. Additionally, you can auto-select elements when hovering or via the context menu.

FireFontFamily
https://addons.mozilla.org/en-US/firefox/addon/firefontfamily/?src=api

Highlight the rendered font-family in Firebug CSS panel

Firepicker
http://thedarkone.github.com/firepicker/

Adds a small color picker dialog when editing CSS rule in Firebug. The addon scans for values that can be parsed as CSS colors (#abc, rgb(1,2,3), blue, red etc.) and displays them in a drop-down list right below the firebug's CSS editor box. Clicking on the color value in the drop-down brings up a color picker dialog.

FireQuery
http://firequery.binaryage.com/

FireQuery is a Firefox extension integrated with Firebug.

jQuery expressions are intelligently presented in Firebug Console and DOM inspector
attached jQuery data are first class citizens
elements in jQuery collections are highlighted on hover
jQuerify: enables you to inject jQuery into any web page
jQuery Lint: enables you to automatically inject jQuery Lint into the page as it is loaded (great for ad-hoc code validation)

Flashbug
http://blog.coursevector.com/flashbug

Flashbug is a Firebug extension for Flash. It displays all the running .SWF file trace output and requires Flash Player Debugger to work properly.

Utilizes Firebug’s built in search feature – When you search for any words in the logs, the words will be highlighted in real-time.
Displays Trace logs – Displays the traces emitted from all Flash instances playing in any browser.
Displays Policy logs – Displays the policy log traces emitted from the Flash Player. These traces usually occur when using cross-domain policies or loading assets from a different domain.
Configure Debug Player settings – The Flash Player itself can be configured to trace out data differently. Those options are available in the preferences window.
Trace filters – There are a few builtin filters to display your traces differently.
Built-in Links – Any URLs that are detected in the traces will be dot underlined.
Read SharedObject – Read any Shared Objects associated with a page.
Read AMF/Remoting Request/Response Data – View AMF data sent to and from the page to the server.
Read SWFs – View SWF internal assets and data. Export SWF assets directly from Flashbug.

Inline Code Finder for Firebug
http://robertnyman.com/inline-code-finder/

Inline Code Finder is a tool to traverse through all elements in a web page, and when it finds a HTML element with any of these, it will highlight them:

Inline JavaScript events
Inline style
javascript: links

Page Speed for Firebug
http://code.google.com/speed/page-speed/

Page Speed is a tool for optimizing the performance of web pages, it allow you to evaluate the performance of your web pages and to get suggestions on how to improve them.

Pixel Perfect for Firebug
http://www.pixelperfectplugin.com/

Overlay a web composition over top of the developed HTML. By toggling the composition on and off, the developer can visually see how many pixels they are off in development.

Pixel percect has an opacity option so that you can view the HTML below the composition. By being able to see both the composition and the HTML you can now simultaneously use Firebug while Pixel Perfect is still in action.

DRY applied to web development

2011-11-11T20:01:00.001-02:00

"Remember that feature that we've used on the other screen? We'll need to use it on this screen too, okay?"

Every developer encountered this situation or a similar one at least once , what to do to avoid this problem? Obviously this type of situation would not occur (or at least should not occur) in well-designed systems, where there is a previous survey of requirements, where there is prototyping the screens and so on, but we all know that in real life the planning does not always occur, and that even in the most well planned projects, there are always last minute changes, so how do we minimize changes? How to avoid writing code twice? How to not repeat yourself?

My answer is that as frontend programmers, developers, designers, regardless of the situation, we should always look for ways to avoid reinventing the wheel and create reusable components. This can be done in different ways, let's start with the simplest of them.

You can be a great frontend programmer, you can know javascript like the palm of your hand, but still you can delegate some of the features of your project to some framework. For example, just doesn't make sense to write a function to show or hide a element in an HTML page when you can use a framework like jQuery for this. I'm not saying you can't implement all these features if you wanted, what I mean is that it makes no sense to reimplement features that have already been implemented by other frameworks, frameworks that support all browsers in the market and will be supporting them for a long time.

The same thing happens with CSS, but in a more delicate way because typically designers who focus on CSS are usually a little bit skeptical about using CSS frameworks (such as the Blueprint), many of them think that creating a good CSS style sheet is almost artisanal, a thing that must be done by hand, like a painting, but if we have a framework that resets the browser's style to maintain a standard, if this framework provides helper classes for columns, clearfix and several other resources to expedite our work, why not use it and focus our time on the particular features of the system or site that we're working?

Thinking this way we can use the same approach even to the particular features of each system, those who have to be developed manually. For example, suppose you are working on a video management system, and you have to load a list of videos on two screens. I have seen situations in which developers write JavaScript code on both screens, and this code was pretty much the same in both screens. The code made the request to the backend, which returned a list of videos in JSON or XML, and the list was treated to be displayed in the frontend, the problem here is that we have two different codes to treat the same data structure returned by the server.

A different approach to solve the above issue would be to create a unique script for the video's management, this script would have a standard data structure that would be used on both screens, and would have methods for persistence and management of the videos:

function Video(id){

this.id = id;
...attributes...

this.save = function(successCallback, errorCallback){alert('saving');};
this.delete = function(successCallback, errorCallback){alert('deleting');};
this.insert = function(successCallback, errorCallback){alert('inserting');};
...business methods...
}

Video.getByID = function(){alert('getting by id');}
Video.getAll = function(){alert('getting all videos');}

This class would be included by the two screens and would be responsible for the management and persistence of the videos and turn them into a standard data structure for all the screens that require this feature, that way, the scripts of each screen can be focused only on how to display the elements in the screen.

DRY concepts can also be used in other areas. Besides a frontend programmer, I also work in the backend, and beyond the backend frameworks (wich help as much as the frontend frameworks), also have seen relatively simple solutions that prevent you reinvent the wheel, for example, assuming you have a single table of customers in your database and also have two or more distinct systems that can manage this table in your database, all systems have connection to this database, so if you change a column of your customer table, you'll have to update the source code on all systems that work with that column, to solve this problem we have two solutions.

Depending on the size of your database, a good approach is to use procedures for updating, inserting or deleting data, and views for displaying data, making the tables virtually transparent to the application.

Another approach is to use webservices, you create a service to manage the customer base and all applications make calls directly to this service. In this case, this service is the only one who have access to the database, and applications have access only to the service in question, this architecture is called SOA (Service Oriented Architecture).

Today, for everything you need, you almost always find ways of not having to reinvent the wheel from project to project, if you work together with a large number of developers and designers, shares CSS, javascript or any other language's code, a framework can help and can also make the collaboration between the project members easier, moreover, sometimes even a single component can become a complex component that can be used in various parts of the same project in the future, so writting reusable components is paramount today, give some thought to the future is the key to your DON'T REPEAT YOURSELF.

Excelente artigo sobre testes de Javascript

2011-10-31T15:27:00.001-02:00

Um excelente artigo do THLopes sobre testes de códigos Javascript, vale a pena dar uma conferida.

Leia na íntegra em http://www.thlopes.com/2011/10/testando-javascript/

Design Patters essenciais para Javascript

2011-07-25T16:31:00.001-03:00

Excelente artigo cobrindo os design patterns essenciais para Javascript, vale a pena ler.

http://www.addyosmani.com/resources/essentialjsdesignpatterns/book/

Função de formatação de números em php

2011-07-19T10:50:00.001-03:00

Pequena função para formatação de números da mesma forma que em PHP.

var numberFormat = function(value, dec, decsep, milsep){
    // formata os parametros
    dec        = (typeof(dec) === 'undefined' ? 2 : dec);
    decsep    = (typeof(decsep) === 'undefined' ? ',' : decsep);
    milsep    = (typeof(milsep) === 'undefined' ? '.' : milsep);
    // fixa o valor
    value=value.toFixed(dec);
    // converte para string
    var localValue=value.toString();
    // separa as partes
    var arr = localValue.split('.');
    // verifica se existem casas decimais
    arr[1] = (arr.length > 1) ? (decsep + arr[1]) : '';
    // cria a expressao regular
    var re=/(\d+)(\d{3})/;

    // formata
    while (re.test(arr[0])){
        arr[0]=arr[0].replace(re, '$1'+milsep+'$2');
    }
    return arr[0]+arr[1];
}

Robular - Real time regular expression tester

2011-07-12T13:55:00.001-03:00

Robular é um editor de expressão regular baseado em Ruby, ele é útil para testar expressões regulares ao mesmo tempo que você as escreve.

Acesse em http://www.rubular.com/

Manual de como falar bem

2011-07-05T18:28:00.001-03:00

Prosopopéia flácida para acalentar bovinos
(Conversa mole pra boi dormir)

Colóquio sonolento para gado bovino repousar
(história pra boi dormir)

Romper a face
(Quebrar a cara)

Creditar o primata
(Pagar o mico)

Inflar o volume da bolsa escrotal
(Encher o saco)

Impulsionar a extremidade do membro inferior contra a região glútea de alguém
(Dar um pé na bunda)

Derrubar, com a extremidade do membro inferior, o suporte sustentáculo de uma das unidades de acampamento
(Chutar o pau da barraca)

Deglutir o batráquio
(Engolir o sapo)

Colocar o prolongamento caudal em meio aos membros inferiores
(Meter o rabo entre as pernas)

Derrubar com intenções mortais
(Cair matando)

Aplicar a contravenção do Sr. João, deficiente físico de um dos membros superiores
(Dar uma de João sem braço)

Sequer considerar a utilização de um longo pedaço de madeira
(Nem a pau)

Sequer considerar a possibilidade da fêmea bovina expirar fortes contrações laringo-bucais
(Nem que a vaca tussa)

Sequer considerar a utilização de instrumentos metálicos derivados do ferro
(Nem ferrando)

Derramar água pelo chão através do tombamento violento e premeditado de seu recipiente
Chutar o balde)

Retirar o filhote de eqüino da perturbação pluviométrica
(Tirar o cavalinho da chuva)

Via Zé Bisteca

Buscando texto dentro de diretório recursivamente via linha de comando

2011-07-05T17:42:00.001-03:00

Comando muito útil caso você precise procurar por algum texto dentro de arquivos de algum diretório recursivamente, o comando que faz a mágica é o grep.

grep -R (texto) (diretorio)
E.g.: grep -R TODO .

Caso você esteja trabalhando com svn, você também pode excluir os diretórios chatos (.svn) da seguinte forma

grep -R (texto) (diretorio) | grep -v (parte do nome ou caminho do arquivo)
E.g.: grep -R TODO . | grep -v .svn

Podemos também excluir arquivos de backup de algum editor

grep -R (texto) (diretorio) | grep -v (parte do nome ou caminho do arquivo)
E.g.: grep -R TODO . | grep -v .bkp
E.g.: grep -R TODO . | grep -v .sw

Dicas avançadas de programação com Javascript

2011-07-05T11:33:00.001-03:00

Excelente artigo com diversas dicas de programação avançada que muita gente não conhece.

Vale a pena conferir na íntegra: http://code.google.com/p/jslibs/wiki/JavascriptTips#language_advanced_Tips_&_Tricks

Converter SWF par HTML5? Use o Swiffy

2011-07-04T14:49:00.001-03:00

Uma ferramenta recém lançada do Google converte arquivos SWF para HTML5. Veja mais em http://br-linux.org/2011/converter-swf-para-html5-com-o-swiffy/

CSS Beautifier

2011-06-28T10:03:00.001-03:00

É um pequeno site que formata qualquer CSS não formatado, facilitando a leitura do mesmo.

Ideal para você que tem que trabalhar com folhas de estilo feitas por terceiros.

http://senchalabs.github.com/cssbeautify/

Modernizr e Progressive Enhancement

2011-06-14T16:44:00.001-03:00

A pergunta: como fazer com que o site em que estamos trabalhando seja visualizado de forma funcional em todos os browsers/celulares/tablets/qualqueroutroequipamento disponível no mercado, desde os mais antigos até os mais novos?

A resposta é o progressive enhancement, ou melhoria progressiva, como desejar. Essa abordagem consiste em criar um markup HTML o mais semântica e simples possível, de forma que roda até no Internet Explorer nos piores browsers possíveis, e depois trabalhar nesse markup, testando as funcionalidades do browser e adicionando CSS e Javascript dinamicamente a página.

Supondo que temos a necessidade de criar um dropbox customizado, com diversas opções dentro, onde o usuário deve selecionar apenas uma, esse dropbox é altamente estilizado e tem diversas funções, como filtragem e etc. Até então sem problemas, temos como fazer elementos deste tipo usando os novos recursos disponíveis em diversos browsers atuais, como o Google Chrome e o Firefox, porém como fazer esta mesma solução funcionar no IE6? A resposta é: não faremos.

Com o progressive enhancement, partimos do princípio básico de que todos os browsers conseguem carregar apenas os elementos mais básicos do HTML, então no caso acima, substituimos o dropbox customizado por uma simples <select> no nosso markup geral, em todos os browsers será carregado um elemento <select> no markup, porém nivelar todo o markup pela mediocridade não é uma alternativa, em browsers mais recentes poderiamos customizar essa <select> de forma que a mesma fique mais parecida com o que precisamos.

É ai que entra em ação o enhancement progressivo, após a página básica renderizada, executamos testes javascript para verificar se o browser que está sendo utilizado tem os recursos mínimos para transformar aquela simples <select> em um dropbox moderno e customizado da forma que precisamos, se o resultado dos testes for verdadeiro, carregaremos dinamicamente folhas de estilo e scripts para transformar a select no que precisamos, porém como fazer esses testes. É ai que entra o Modernizr.

Modernizr is an open-source JavaScript library that helps you build the next generation of HTML5 and CSS3-powered websites.

Em outras palavras, Modernizr é uma biblioteca javascript open source que te ajuda a criar a nova geração de websites HTML5 e CSS3, e como ele faz isso?

Modernizr gives you finer control over the experience through JavaScript-driven feature detection

Ou seja, ele executa diversos testes via javascript para determinar quais as são as capacidades do browser que está sendo utilizado, quando o browser tem todas as capacidades necessárias para uma melhoria ser feita, o próprio Modernizr oferece recursos para carregamento dinâmico de novos scripts e folhas de estilo, bastando somente que você implemente a lógica para as melhorias (como por exemplo, transformar um elemento <select> em um dropbox customizado).

// Give Modernizr.load a string, an object, or an array of strings and objects Modernizr.load([ // Presentational polyfills { // Logical list of things we would normally need test : Modernizr.fontface && Modernizr.canvas && Modernizr.cssgradients, // Modernizr.load loads css and javascript by default nope : ['presentational-polyfill.js', 'presentational.css'] }, // Functional polyfills { // This just has to be truthy test : Modernizr.websockets && window.JSON, // socket-io.js and json2.js nope : 'functional-polyfills.js', // You can also give arrays of resources to load. both : [ 'app.js', 'extra.js' ], complete : function () { // Run this after everything in this group has downloaded // and executed, as well everything in all previous groups myApp.init(); } }, // Run your analytics after you've already kicked off all the rest // of your app. 'post-analytics.js' ]);

Primeiro post (a partir de) no Posterous

2011-06-14T16:11:00.001-03:00

Essa é a minha primeira experiência com o Posterous, não sei bem como funciona, estou aprendendo, mas parece que consigo centralizar todos os updates dos meus blogs, facebook, twitter e etc, tudo por aqui, vamos ver.

Valentão quis bater no gordinho e se fodeu!

2011-03-14T19:10:00.000-03:00

HAHAHA, esse ai SE FODEU!

Via @AncelmoCelblack

Depois que a gente fala desses EMOs a galera reclama!

2011-03-13T15:12:00.001-03:00

"Não sei nem se tem gente civilizada por lá!" Comentou ou nem? Melhor nem né?

(Via Blog dos Manolos.)

Peido assusta!

2011-03-13T15:10:00.001-03:00

Quem assustou o bebê?: "

Nunca vi ninguém se assustar com o próprio peido! HAHAHA

(Via Blog dos Manolos.)

Comerciais de TV - 01

2011-03-08T17:47:00.001-03:00

A Batelco, uma empresa de telecomunicações do Bahrein, fez um dos comerciais mais incríveis que eu já vi na minha vida!

(Via Haznos - Do Jeito que o Diabo gosta.)

O Japão sempre foi estranho!

2011-03-08T14:35:00.001-03:00

O Japão sempre foi estranho!: "

Velho, que coisa nojenta, o Japão realmente é bizarro!

(Via Blog dos Manolos.)

I believe I can fly!

2011-03-03T17:00:00.000-03:00

Por que as mulheres choram?

2011-03-03T16:00:00.000-03:00

Carro atropela dezenas de ciclistas em passeata em Porto Alegre

2011-03-03T15:00:00.000-03:00

Uma pessoa dessa não merece ser chamada de ser humano, uma pessoa dessa é um monstro que não sabe o valor da vida!

A cena do atropelamento ocorre em 1:10 de duração do vídeo.

Lamentável que cenas assim ocorram!

Como NÃO dar uma entrevista ao vivo

2011-03-03T14:00:00.000-03:00

"Nossa...deu branco!"

Então tá, voltamos já já!

Visto no Uhull SA

Burro (ou burros) do dia: Roubo de banco na China

2011-03-03T11:00:00.000-03:00

Não sei quem foi mais idiota ai, o ladrão, ou os policiais, hahaha!