Introdução

Quem nunca ouviu as seguintes frases: “Escrever SQL nos dias de hoje não é uma boa prática” ou “Tente não escrever SQL, usa os recursos do ORM”, ainda não trabalhou o suficiente.

O mercado de startups parece cada vez mais alérgico ao SQL, um dos recursos mais poderosos e antigos(1974!) no mundo dos bancos de dados.

O que as pessoas esquecem ou escolhem ignorar é a capacidade que um banco de dados tem e pode te oferecer para resolver problemas banais.

Mas a questão é, como e porque devemos perder o medo do SQL?

Escrever SQL é sim uma boa prática

Quando estamos envolvidos demais com os ORMs que utilizamos para fazer aplicações, tentamos cada vez mais resolver os problemas de acesso de dados utilizando os recursos do ORM que muitas vezes são muito bons e completos.

Porém, quando precisamos resolver consultas mais complexas, nós enfrentamos elas geralmente de duas formas diferentes:

1. Realizando diversas buscas e processando a nível de aplicação
2. Escrever uma String de SQL e executá-la com o ORM

Por mais vantajoso em termos de desempenho seja escrever a String da consulta dentro do ORM, muitas vezes preferimos processar essas consultas em tempo de execução utilizando os lindos recursos de nossas maravilhosas linguagens dinâmicas. Afinal, é deselegante escrever uma String com uma query SQL no meio do nosso Business Logic, né?

Esse pensamento é bastante comum, pouco eficiente e bastante errado. Quando assumimos fazer o item 1, perdemos os recursos de otimização de query que o banco nos fornece e damos lugar um código que é muito provavelmente ineficiente e tem pouca garantia de consistência. Quando assumimos o item 2, ganhamos o fator otimização porém perdemos no fator manutenibilidade.

Você pode alegar que não se pode ganhar todas né? Nesse caso, você pode sim ganhar todas.

Routines e Procedures

Funções internas do banco de dados são normalmente chamadas de Procedure ou Routine. Essas procedures se comportam como uma função em qualquer linguagem de programação, ou seja, podemos chama-las através de consultas, podemos utilizá-las em outras procedures e podemos também chama-las através do nosso ORM de preferência.

Se quiser ler mais sobre procedures nativas do PostgreSQL tem uma matéria bem legal dando uma palhinha do que ele pode fazer por você.

Minhas procedures

Você também pode definir procedures para trabalhar com suas tabelas e fazer operações nos seus dados. A forma de definir é bastante simples.

CREATE OR REPLACE FUNCTION hello_world(p_name character varying)
RETURNS character varying
AS
$BODY$
BEGIN
    RETURN CONCAT('Hello, ', p_name, '!');
END;
$BODY$
    LANGUAGE plpgsql VOLATILE;

Para executar a procedure basta realizar uma consulta nela.

select hello_world('rafael');

-- Retorno
hello_world
----------------
Hello, Rafael!
(1 row)

Podemos ver então que a declaração de uma procedure é bastante simples e flexível. Podemos ter funções com diversos retornos como tabelas, tipos nativos e tipos criados pelo usuário.

Existe também aqueles que gostam de trabalhar somente com SQL por já ter se estressado o suficiente com o ORM e tentou recriar o Devise utilizando procedures (Este é um artigo bastante interessante de alguém que cansou de ter problemas com ORMs).

Lógica de Dados VS Lógica de Negócios

Hoje em dia chamamos tudo que está rodando na nossa aplicação de lógica de negócios, porém, não é bem assim. É importante conhecer os limites e as diferenças do que é lógica de dados e o que é lógica de negócios.

Lógica de Dados

Lógico de dados é tudo aquilo que opera somente na camada dos dados (Duh), ou seja, é tudo aquilo que representa condições do nosso dado.

Exemplos:

1. Criptografia de senhas
2. Timestamps de tabela (createdAt, updatedAt)
3. Softdelete (deletedAt)
4. Consistências (Verificação de unicidade, chaves primárias, etc)
5. Quando criar registro X, criar registro Y também

Lógica de Negócios

1. Quando um usuário criar uma conta, disparar um Email de boas vindas
2. Quando o usuário inserir um registro na tabela, notificar via SMS outro usuário
3. Usuário x só pode acessar lugares x, y e z do sistema

Para fazer a lógica de negócios funcionar, devemos mapear a lógica em dados e trabalhar a lógica de dados para atender nossa lógica de negócios.

Em um mundo ideal existe uma completa separação entre essas lógicas mas no mundo real isso acaba se sobrepondo para agilizar o desenvolvimento.

Como escrever SQL da forma certa

Nos pegamos então em um mundo onde é inevitável escrever SQL. Em algum momento das nossas aplicações, vamos ter que colocar um SQL no meio do nosso código para resolver uma consulta complexa. Quando isso acontecer o que devemos fazer?

Meça

Consultas difíceis de escrever no ORM não é o único motivo para escrever SQL na sua aplicação. Muitas vezes o ORM que você está usando é lento para determinadas tarefas. Para resolver isso, fuja um pouco dele e trabalhe no nível do SQL.

Separe as lógicas

Saiba separar o seu SQL do código da aplicação. Crie uma procedure e faça uma chamada. Dessa forma você desacopla a lógica da consulta da aplicação e se um dia essa consulta operar de forma diferente basta atualizar a procedure.

Aproveite o melhor dos dois mundos

Meu objetivo não é convencer ninguém a parar de usar ORMs, mas saber medir e tomar deciões através de dados. ORMs não solucionam todos os problemas de acesso aos dados, além de adicionarem uma camada desnecessária de complexidade na aplicação.

Alguns exemplos:

Antes

Aplicaçao

var sql = '';
sql += ' SELECT p1.id, p1.nome, p1.descricao,  ST_AsGeoJSON(p1."poiGeometrico") geojson, a1.nome "acervo_nome", c1.nome "categoria_nome", p1."urlIcone", ';
sql += ' p2.id id2, p2.nome nome2 , p2.descricao descricao2,  ST_AsGeoJSON(p2."poiGeometrico") "geojson2", a2.nome "acervo_Nome2", c2.nome "categoria_nome2", p2."urlIcone" "urlIcone2", ';
sql += ' ST_Distance(ST_Transform(p1."poiGeometrico",3067), ST_Transform(p2."poiGeometrico",3067)) distancia ';
sql += ' FROM "Poi" p1, "Poi" p2, "Acervo" a1, "Acervo" a2, "Categoria" c1, "Categoria" c2 ';
sql += ' WHERE c1.id = :categoriaId1 AND c2.id = :categoriaId2 AND ';
sql += ' p1."AcervoId" = a1.id AND p2."AcervoId" = a2.id AND ';
sql += ' p1."CategoriumId" = c1.id AND p2."CategoriumId" = c2.id ';
sql += ' AND ST_Distance(ST_Transform(p1."poiGeometrico",3067), ST_Transform(p2."poiGeometrico",3067)) < :distancia ';

var parametros = {
    categoriaId1: parseInt(req.body.categoriaId1, 10),
    categoriaId2: parseInt(req.body.categoriaId2, 10),
    distancia: parseInt(req.body.distancia, 10)
};

db.sequelize.query(sql, null, {
    raw: true
}, parametros)
    .then(function(data) {
        res.send(data);
    });

Depois

SQL

CREATE OR REPLACE FUNCTION deteccao_de_impacto(
    p_categoria_id1 integer,
    p_categoria_id2 integer,
    p_distancia integer
)
RETURNS TABLE (
    id integer,
    nome varchar,
    descricao varchar,
    geojson json,
    acervo_nome varchar,
    categoria_nome varchar,
    urlIcone varchar,
    id2 integer,
    nome2 varchar,
    descricao2 varchar,
    geojson2 json,
    acervo_Nome2 varchar,
    categoria_nome2 varchar,
    urlIcone2 varchar,
    distancia integer
) AS
$BODY$
#variable_conflict use_variable
BEGIN
    RETURN QUERY
    SELECT
        p1.id,
        p1.nome,
        p1.descricao,
        ST_AsGeoJSON(p1.poiGeometrico) geojson,
        a1.nome acervo_nome,
        c1.nome categoria_nome,
        p1.urlIcone,
        p2.id id2,
        p2.nome nome2,
        p2.descricao descricao2,
        ST_AsGeoJSON(p2.poiGeometrico) geojson2,
        a2.nome acervo_Nome2,
        c2.nome categoria_nome2,
        p2.urlIcone urlIcone2,
        ST_Distance(
            ST_Transform(p1.poiGeometrico, 3067),
            ST_Transform(p2.poiGeometrico, 3067)
        ) distancia
    FROM
        Poi p1,
        Poi p2,
        Acervo a1,
        Acervo a2,
        Categoria c1,
        Categoria c2
    WHERE
        c1.id = p_categoria_id1 AND
        c2.id = p_categoria_id2 AND
        p1.AcervoId = a1.id AND
        p2.AcervoId = a2.id AND
        p1.CategoriumId = c1.id AND
        p2.CategoriumId = c2.id AND
        ST_Distance(
            ST_Transform(p1.poiGeometrico, 3067),
            ST_Transform(p2.poiGeometrico, 3067)
        ) < p_distancia
    ;
END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION deteccao_de_impacto(integer, integer, integer)
  OWNER TO postgres;

Aplicaçao

var sql = "select deteccao_de_impacto(:categoriaId1, :categoriaId2, :distancia)";
var parametros = {
    categoriaId1: parseInt(req.body.categoriaId1, 10),
    categoriaId2: parseInt(req.body.categoriaId2, 10),
    distancia: parseInt(req.body.distancia, 10)
};

db.sequelize.query(sql, null, {
    raw: true
}, parametros)
    .then(function(data) {
        res.send(data);
    });

---
Este artigo foi escrito por grillorafael.

Visite o nosso site para mais posts sobre desenvolvimento web! Tableless.

So long XMLHttpRequest

fetch() allows you to make network requests similar to XMLHttpRequest (XHR). The main difference is that the Fetch API uses Promises, which enables a simpler and cleaner API, avoiding callback hell and having to remember the complex API of XMLHttpRequest.

The Fetch API has been available in the Service Worker global scope since Chrome 40, but it’ll be enabled in the window scope in Chrome 42. There is also a rather fetching polyfill by GitHub that you can use today.

If you’ve never used Promises before, check out this great article by Jake Archibald.

Basic Fetch Request

Let’s start by comparing a simple example implemented with an XMLHttpRequest and then with fetch. We just want to request a URL, get a response and parse it as JSON.

XMLHttpRequest

An XMLHttpRequest would need two listeners to be set to handle the success and error cases and a call to open() and send(). Example from MDN docs.

function reqListener() {  
  var data = JSON.parse(this.responseText);  
  console.log(data);  
}

function reqError(err) {  
  console.log('Fetch Error :-S', err);  
}

var oReq = new XMLHttpRequest();  
oReq.onload = reqListener;  
oReq.onerror = reqError;  
oReq.open('get', './api/some.json', true);  
oReq.send();

Fetch

Our fetch request looks a little like this:

fetch('./api/some.json')  
  .then(  
    function(response) {  
      if (response.status !== 200) {  
        console.log('Looks like there was a problem. Status Code: ' +  
          response.status);  
        return;  
      }

      // Examine the text in the response  
      response.json().then(function(data) {  
        console.log(data);  
      });  
    }  
  )  
  .catch(function(err) {  
    console.log('Fetch Error :-S', err);  
  });

We start by checking that the response status is 200 before parsing the response as JSON.

The response of a fetch() request is a Stream object, which means that when we call the json() method, a Promise is returned since the reading of the stream will happen asynchronously.

Response Metadata

In the previous example we looked at the status of the Response object as well as how to parse the response as JSON. Other metadata we may want to access, like headers, are illustrated below.

fetch('users.json').then(function(response) {  
    console.log(response.headers.get('Content-Type'));  
    console.log(response.headers.get('Date'));

    console.log(response.status);  
    console.log(response.statusText);  
    console.log(response.type);  
    console.log(response.url);  
});

Response Types

When we make a fetch request, the response will be given a response.type of “basic”, “cors” or “opaque”. These “types” indicate where the resource has come from and can be used to inform how you should treat the response object.

When a request is made for a resource on the same origin, the response will have a “basic” type and there aren’t any restrictions on what you can view from the response.

If a request is made for a resource on another origin which returns the CORs headers, then the type is “cors”. “cors” and “basic” responses are almost identical except that a “cors” response restricts the headers you can view to `Cache-Control`, `Content-Language`, `Content-Type`, `Expires`, `Last-Modified`, and `Pragma`.

An “opaque” response is for a request made for a resource on a different origin that doesn’t return CORS headers. With an opaque response we won’t be able to read the data returned or view the status of the request, meaning we can’t check if the request was successful or not. With the current fetch() implementation it’s not possible to make requests for resources on a different origin from the window global scope. Find out why here, it should be added when the Cache API is available in the window object.

You can define a mode for a fetch request such that only certain requests will resolve. The modes you can set are as follows:

• “same-origin” only succeeds for requests for assets on the same origin, all other requests will reject.
• “cors” will allow requests for assets on the same-origin and other origins which return the appropriate CORs headers.
• “cors-with-forced-preflight” will always perform a preflight check before making the actual request.
• “no-cors” is intended to make requests to other origins that do not have CORS headers and result in an opaque response, but as stated, this isn’t possible in the window global scope at the moment.

To define the mode, add an options object as the second parameter in the fetch request and define the mode in that object:

fetch('http://some-site.com/cors-enabled/some.json', {mode: 'cors'})  
  .then(function(response) {  
    return response.text();  
  })  
  .then(function(text) {  
    console.log('Request successful', text);  
  })  
  .catch(function(error) {  
    log('Request failed', error)  
  });

Chaining Promises

One of the great features of promises is the ability to chain them together. For fetch, this allows you to share logic across fetch requests.

If you are working with a JSON API, you’ll need to check the status and parse the JSON for each response. You can simplify your code by defining the status and JSON parsing in separate functions which return promises, freeing you to only worry about handling the final data and the error case.

function status(response) {  
  if (response.status >= 200 && response.status < 300) {  
    return Promise.resolve(response)  
  } else {  
    return Promise.reject(new Error(response.statusText))  
  }  
}

function json(response) {  
  return response.json()  
}

fetch('users.json')  
  .then(status)  
  .then(json)  
  .then(function(data) {  
    console.log('Request succeeded with JSON response', data);  
  }).catch(function(error) {  
    console.log('Request failed', error);  
  });

We define the status function which checks the response.status and returns the result of Promise.resolve() or Promise.reject(), which return a resolved or rejected Promise. This is the first method called in our fetch() chain, if it resolves, we then call our json() method which again returns a Promise from the response.json() call. After this we have an object of the parsed JSON. If the parsing fails the Promise is rejected and the catch statement executes.

The great thing with this is that you can share the logic across all of your fetch requests, making code easier to maintain, read and test.

POST Request

It’s not uncommon for web apps to want to call an API with a POST method and supply some parameters in the body of the request.

To do this we can set the method and body parameters in the fetch() options.

fetch(url, {  
    method: 'post',  
    headers: {  
      "Content-type": "application/x-www-form-urlencoded; charset=UTF-8"  
    },  
    body: 'foo=bar&lorem=ipsum'  
  })
  .then(json)  
  .then(function (data) {  
    console.log('Request succeeded with JSON response', data);  
  })  
  .catch(function (error) {  
    console.log('Request failed', error);  
  });

Sending Credentials with a Fetch Request

Should you want to make a fetch request with credentials such as cookies, you should set the credentials of the request to “include”.

fetch(url, {  
  credentials: 'include'  
})

FAQ

How do I cancel a fetch() request?

At the moment there is no way to cancel a fetch, but this is being discussed on GitHub . H/T @jaffathecake for this link.

Is there a polyfill?

GitHub has a polyfill for fetch. H/T @Nexii for pointing this out.

Why is “no-cors” supported in service workers but not the window?

This is due to a security concern, you can learn more here.

2001: PostgreSQL 7.1: write-ahead log

PostgreSQL 7.1 introduced the write-ahead log (WAL). Before that release, all open data files had to be fsynced on every commit, which is very slow. Slow fsyncing is still a problem today, but now we’re only worried about fsyncing the WAL, and fsyncing the data files during the checkpoint process. Back then, we had to fsync everything all the time.

In the original design of university POSTGRES, the lack of a log was intentional, and contrasted with heavily log-based architectures such as Oracle. In Oracle, you need the log to roll back changes. In PostgreSQL, the nonoverwriting storage system takes care of that. But probably nobody thought about implications for fsyncing back then.

Note that the WAL was really just an implementation detail at this point. You couldn’t read or archive it.

2004: Slony

Just for context: Slony-I 1.0 was released in July 2004.

2005: PostgreSQL 8.0: point-in-time recovery

PostgreSQL 8.0 added the possibility to copy the WAL somewhere else, and later play it back, either all the way or to a particular point in time, hence the name point-in-time recovery (PITR) for this feature. This feature was mainly intended to relieve pg_dump as a backup method. Until then, the only backup method was a full dump, which would get impractical as databases grew. Hence this method to take an occasional base backup, which is the expensive part, and then add on parts of the WAL, which is cheaper.

The basic configuration mechanisms that we still use today, for example the recovery.conf file, were introduced as part of this feature.

But still no replication here.

2008: PostgreSQL 8.3: pg_standby

Crafty people eventually figured that if you archived WAL on one server and at the same time “recovered” endlessly on another, you’d have a replication setup. You could probably have set this up with your own scripts as early as 8.0, but PostgreSQL 8.3 added the pg_standby program into contrib, which gave everyone a standard tool. So, arguably, 8.3 is the first release that contained a semblance of a built-in replication solution.

The standby server was in permanent recovery until promotion, so it couldn’t be read from as it was replicating. This is what we’d now call a warm standby.

I think a lot of PostgreSQL 8.3 installations refuse to die, because this is the first version where you could easily have a reasonably up-to-date reserve server without resorting to complicated and sometimes problematic tools like Slony or DRBD.

2010: PostgreSQL 9.0: hot standby, streaming replication

In PostgreSQL 9.0, two important replication features arrived completely independently. First, the possibility to connect to a standby server in read-only mode, making it a so-called hot standby. Whereas before, a standby server was really mainly useful only as a reserve in case the primary server failed, with hot standby you could use secondary servers to spread out read-only loads. Second, instead of relying solely on the WAL archive and recovery functionalities to transport WAL data, a standby server could connect directly to the primary server via the existing libpq protocol and obtain WAL data that way, so-called streaming replication. The primary use in this release was that the standby could be more up to date, possibly within seconds, rather than several minutes with the archive-based approach. For a robust setup, you would still need to set up an archive. But streaming replication was also a forward-looking feature that would eventually make replication setups easier, by reducing the reliance on the old archiving mechanisms.

PostgreSQL 9.0 was the first release where one could claim that PostgreSQL “supports replication” without having to make qualifications or excuses. Although it is scheduled to go EOL later this year, I expect this release will continue to live for a long time.

2011: PostgreSQL 9.1: pg_basebackup, synchronous replication

pg_basebackup was one of the features facilitated by streaming replication that made things easier. Instead of having to use external tools like rsync for base backups, pg_basebackup would use a normal libpq connection to pull down a base backup, thus avoiding complicated connection and authentication setups for external tools. (Some people continue to favor rsync because it is faster for them.)

PostgreSQL 9.1 also added synchronous replication, which ensures that data is replicated to the designated synchronous standby before a COMMIT reports success. This feature is frequently misunderstood by users. While it ensures that your data is on at least two servers at all times, it might actually reduce the availability of your system, because if the standby server goes down, the primary will also go down, unless you have a third server available to take over the synchronous standby duty.

Less widely know perhaps is that PostgreSQL 9.1 also added the pg_last_xact_replay_timestamp function for easy monitoring of standby lag.

In my experience, the availability of pg_basebackup and pg_last_xact_replay_timestamp make PostgreSQL 9.1 the first release were managing replication was reasonably easy. Go back further, and you might feel constrained by the available tools. But in 9.1, it’s not that much different from what is available in the most recent releases.

2012: PostgreSQL 9.2: cascading replication

Not as widely acclaimed, more for the Slony buffs perhaps, PostgreSQL 9.2 allowed standbys to fetch their streaming replication data from other standbys. A particular consequence of that is that pg_basebackup could copy from a standby server, thus taking the load off the primary server for setting up a new standby or standalone copy.

2013: PostgreSQL 9.3: standby can follow timeline switch

This did not even make it into the release note highlights. In PostgreSQL 9.3, when a primary has two standbys, and one of the standbys is promoted, the other standby can just keep following the new primary. In previous releases, the second standby would have to be rebuilt. This improvement makes dynamic infrastructure changes much simpler. Not only does it eliminate the time, annoyance, and performance impact of setting up a new standby, more importantly it avoids the situation that after a promotion, you don’t have any up to update standbys at all for a while.

2014: PostgreSQL 9.4: replication slots, logical decoding

Logical decoding got all the press for PostgreSQL 9.4, but I think replication slots are the major feature, possibly the biggest replication feature since PostgreSQL 9.0. Note that while streaming replication has gotten more sophisticated over the years, you still needed a WAL archive for complete robustness. That is because the primary server didn’t actually keep a list of its supposed standby servers, it just streamed whatever WAL happened to be requested if it happened to have it. If the standby server fell behind sufficiently far, streaming replication would fail, and recovery from the archive would kick in. If you didn’t have an archive, the standby would then no longer be able to catch up and would have to be rebuilt. And this archiving mechanism has essentially been unchanged since version 8.0, when it was designed for an entirely different purpose. So a replication setup is actually quite messy: You have to configure an access path from the primary to the standby (for archiving) and an access path from the standby to the primary (for streaming). And if you wanted to do multiple standbys or cascading, maintaining the archive could get really complicated. Moreover, I think a lot of archiving setups have problematic archive_command settings. For example, does your archive_command fsync the file on the receiving side? Probably not.

No more: In PostgreSQL 9.4, you can set up so-called replication slots, which effectively means that you register a standby with the primary, and the primary keeps around the WAL for each standby until the standby has fetched it. With this, you can completely get rid of the archiving, unless you need it as a backup.

2015? PostgreSQL 9.5? pg_rewind?

One of the remaining problems is that promoting a standby leaves the old primary unable to change course and follow the new primary. If you fail over because the old primary died, then that’s not an issue. But if you just want to swap primary and standby, perhaps because the standby has more powerful hardware, then the old primary, now standby, needs to be rebuilt completely from scratch. Transforming an old primary into a new standby without a completely new base backup is a rather intricate problem, but a tool that can do it (currently named pg_rewind) is proposed for inclusion into the next PostgreSQL release.

Beyond

One of the problems that this evolution of replication has created is that the configuration is rather idiosyncratic, quite complicated to get right, and almost impossible to generalize sufficiently for documentation, tutorials, and so on. Dropping archiving with 9.4 might address some of these points, but configuring even just streaming replication is still weird, even weirder if you don’t know how it got here. You need to change several obscure configuration parameters, some on the primary, some on the standby, some of which require a hard restart of the primary server. And then you need to create a new configuration file recovery.conf, even though you don’t want to recover anything. Making changes in this area is mostly a complex political process, because the existing system has served people well over many years, and coming up with a new system that is obviously better and addresses all existing use cases is cumbersome.

Another issue is that all of this functionality has been bolted on to the write-ahead log mechanism, and that constrains all the uses of the write-ahead log in various ways. For example, there are optimizations that skip WAL logging in certain circumstances, but if you want replication, you can’t use them. Who doesn’t want replication? Also, the write-ahead log covers an entire database system and is all or nothing. You can’t replicate only certain tables, for example, or consolidate logs from two different sources.

How about not bolting all of this on to the WAL? Have two different logs for two different purposes. This was discussed, especially around the time streaming replication was built. But then you’d need two logs that are almost the same. And the WAL is by design a bottleneck, so creating another log would probably create performance problems.

Logical decoding breaks many of these restrictions and will likely be the foundation for the next round of major replication features. Examples include partial replication and multimaster replication, some of which are being worked on right now.

What can we expect from plain WAL logging in the meantime? Easier configuration is certainly a common request. But can we expect major leaps on functionality? Who knows. At one point, something like hot standby was thought to be nearly impossible. So there might be surprises still.

Como o projeto já estava atrasado, decidi que seria melhor continuar pesquisando alguma alternativa para resolver o problema da “limpagem” de strings, então encontrei a biblioteca URLify for PHP

A principio ele é uma classe simples em PHP com as funcionalidades que não são nativas do PHP, porém são uma mão na roda na hora de trabalhar com strings em projetos grandes, onde não existe tempo para o dev criar do zero (muito menos testá-los sem perder o foco do problema que realmente importa).

Como trabalho com CakePHP, só tive o trabalho de adicioná-lo no meu diretório ‘Lib’, importar a classe,

   
 App::uses('URLify','Lib');

e chamar a função ‘::downcode’, que transcreve os caracteres especiais para os seus correspondentes no alfabeto (Ex: ‘ç’ -> ‘c’ ; ‘á’ -> ‘a’)

   $mytext = 'caçamba lilás';
   $newtext = URLify::downcode($mytext);
   //cacamba lilas

e pronto, mantive meu código limpo, com uma biblioteca leve e elegante.

A classe também possui outros métodos bem legais de filtragem de strings como o ‘::add_chars’, que permite adicionar suas próprias exceções a lista de filtragem de caracteres.

     URLify::add_chars (array (
         '¿' => '?', '®' => '(r)', '¼' => '1/4',
         '¼' => '1/2', '¾' => '3/4', '¶' => 'P'
     ));

     echo URLify::downcode ('¿ ® ¼ ¼ ¾ ¶');
     // "? (r) 1/2 1/2 3/4 P"

e o ‘::remove_words’, que pelo nome ja dá pra saber o que faz…

     URLify::remove_words (array ('remove', 'these', 'too'));

E é isso, espero que tenha ajudado alguém, até o próximo post…

---
Este artigo foi escrito por chaves_dev.

Visite o nosso site para mais posts sobre desenvolvimento web! Tableless.

Criados em 1999, os cubesats são uma excelente pensada fora da caixa. Em vez de bilhões de dólares, décadas de desenvolvimento e complexidade inimaginável, eles resolvem problemas simples de forma simples. São cubinhos Knorr de dez 10 cm de lado, pesando pouco mais de 1 kg, e em geral pegam carona em foguetes lançando satélites de verdade.

Eles são usados em coletas de dados, testes de tecnologias e quando seu país é pequeno, pobre mas esforçado, como o Equador, são motivo de orgulho nacional. 

Há até projetos no Kickstarter onde colaborando com US$ 150,00 você ganha o direito de direcionar o satélite e fazer 15 fotos. Timesharing em um satélite espião, só seu! Amo o futuro.

Em 2013 a Escola Thomas Jefferson de Ciência e Tecnologia construiu o primeiro cubesat feito por estudantes, posteriormente lançado com ajuda da NASA. Esse tipo de trabalho é um senhor estímulo para as crianças, você não está plantando feijão ou fazendo sandália de pneu, você está construindo um fucking satélite e mandando-o para o fucking espaço.

No Brasil é de se esperar que isso não aconteça, dado nosso viralatismo e ódio a tudo que seja relacionado com ciência, a ponto de uma escola proibir um professor de fazer foguetes com garrafa PET e ar comprimido, por ser “perigoso”.

Por sorte há gente que não compra essa visão medíocre. Um deles é o Professor Cândido Moura, da Escola Municipal Tancredo Neves, de Ubatuba. Ele teve a idéia de engajar seus alunos em um projeto quixotesco: construir, no Brasil, com alunos de uma escola pública na faixa dos 12 anos um satélite.

O projeto cresceu, eles ganharam reconhecimento, foram visitar a NASA e apresentaram o projeto no Japão. Meninos e meninas tiveram seu futuro mudado por causa do projeto, que rendeu um documentário que assim como o satélite está pra ser lançado.

O Tancredo 1, como chamam o satélite, custou R$ 14 mil. Mil, não milhões, escola pública, lembra? Hoje em dia há um monte de empresas vendendo kits de cubesats, como o usado pelos alunos. O topo de linha da CubeSatKit por exemplo custa US$ 8.750,00.

Como todo kit é uma ferramenta de aprendizado, e pode ser agregado com tecnologias experimentais e soluções próprias, como os alunos da Tancredo Neves fizeram.

Enquanto isso, no Programa Espacial Brasileiro…

O INPE e o ITA entraram na brincadeira dos Cubesats também, mas como tudo no Brasil tem que ser grande, caro e não funcionar. Construíram o AESP-14, com tanta pompa e circunstância que tem até site em inglês.

Pois bem; provando que nós não sabemos mesmo construir satélites, o AESP-14 foi lançado da Estação Espacial. É muito bonito de se ver, os bichinhos são suavemente ejetados e se afastam lentamente…

O Cubesat brasileiro (que nem é o primeiro) deveria realizar vários experimentos durante os 15 dias de autonomia da bateria. Deveria, mas como estamos falando de Brasil no Espaço, a antena não abriu, o satélite não teve como se comunicar com a Terra e o projeto fracassou.

Pra completar, o tamanho da facada. Um kit de Cubesat, tecnologia que você literalmente compra online, custa uns US$ 8.500,00 dependendo da loja. Quanto saiu o mais novo pedaço de lixo espacial, que vai matar o George Clooney?

R$ 400 mil.

E pra finalizar, de novo o estagiário do INPE foi rápido no gatilho. Lembra quando o CBERS-3 foi lançado, soltaram o release declarando sucesso pra 5 minutos depois o satélite cair na Antártica matando pinguins? Fizeram de novo. A Agência Espacial Brasileira soltou release celebrando o sucesso do lançamento do cubesat que nasceu morto.

É triste amar ciência no Brasil. Felizmente temos a gurizada de Ubatuba pra nos dar um fio de esperança.

Fonte: O Globo.

The post Nanossatélite brasileiro é lançado e — você já sabe, né? appeared first on Meio Bit.

Sejamos realistas: escadas não são só o maior inimigo do Professor X, são ruins pra todo mundo que usa cadeiras de rodas. A própria geografia urbana é um desafio, com grandes, fradinhos, aquelas malditas bolas de concreto que o César Maia espalhou no Rio Cidade…

Mesmo assim qualquer país decente e até mesmo o Brasil possuem Leis de Acessibilidade, prevendo a construção de rampas e outros meios para permitir a cadeirantes o sagrado direito de entrar em um prédio. Na prática ainda vemos muito quebra-galho. Há lugares onde a “Entrada para Deficientes” é pelos fundos, outros colocam rampas que transformam o sujeito em piloto de Rally. 

Em alguns casos é simplesmente impossível construir uma rampa, a menos que o sujeito consiga subir 45 graus. Bem, não mais, e desta vez não é nem idéia de designer, que nunca se tornará viável. A solução é completamente pé no chão (dsclp) e viável. Claro, não é barata, mas melhor gastar dinheiro com isso do que com carro elétrico brasileiro de Facebook.

A idéia da AllGood britânica é um produto chamado Escadas Sésamo. Não descaracteriza a fachada, ocupa ZERO de espaço e é bem mais seguro que uma rampa.

Nem vou postar foto pra não estragar o vídeo:

allgoodplc — Allgood Trio Sesame steps

Isso, crianças, é uma solução criativa para um problema, desenvolvida por um engenheiro, não um calouro de design deslumbrado na primeira semana de aula. Quanto aos designers, bem, eles também estão projetando soluções para cadeirantes, e estudam tão bem o problema que criam esta bosta aqui:

Não tem braços, não tem cintos, o sujeito sem tônus muscular nenhum terá que se equilibrar o tempo todo, ao mesmo tempo prestando atenção pra não roer a anca com a roda exposta nas laterais. Escoras? Isso não existe, por isso não há acolchoamento no assento.

Ah sim, note que também não colocaram o absolutamente desnecessário deixe-as-pernas-balançando suporte para os pés. Já esta aqui tem o suporte, só lembre de trazer silvertape, caro amigo cadeirante.

Ah? Como ela funciona? Poder da imaginação, claro.

Fonte: WU.

The post Rampas? Onde vamos não precisamos de rampas! appeared first on Meio Bit.

Uma vez uma conhecida minha pedagoga sindicalista reclamou que havia saído pra comprar um negócio, foi em várias lojas, cada uma tinha um preço diferente. Disse que o Governo deveria determinar o preço assim ela não perderia tempo batendo perna.

Ela obviamente esqueceu do templo do Plano Cruzado, com congelamento de preços, ágio, escassez de produtos, etc. Também esqueceu toda a história da Europa Oriental, e como durante mais de 20 anos o Lada não mudou um parafuso. 20 anos era aliás o prazo de entrega.

No mundo real lojas têm custos diferentes, margens de lucro diferentes, valores agregados diferentes. Isso é economia básica, mas escapou à minha amiga e escapou a Sundar Pichai, chefe de produto do Google. 

Em uma entrevista para a Forbes ele falou da diferença na abordagem entre o Google e a Apple.

“Os usuários usam nossos serviços por opção. São produtos muito amados. Temos muitos, muitos produtos com mais de um bilhão de usuários. Eles proveem um monte de valor, e nós disponibilizados muitos desses serviços de graça”

Que lindo. Uma lágrima comunista escorre pelo meu rosto. Vou fingir que o Google não fatura vendendo dados demográficos e exibição de anúncios. Pelo lógica de Pichai a Globo também é uma ONG como o Google, pois não cobra nada ao exibir sua programação para os espectadores.

Esquecendo que fabricantes Android também têm aparelhos premium, continuou:

“É um pouco irresponsável dizer que tudo deve custar várias centenas de dólares, [como os produtos da Apple]”

Bem, Pichai, então eu acho que tenho um problema. Me acompanhe.

Este é um Aston Martin DB9 Volante, meu sonho de consumo. Será adquirido assim que Hollywood comprar os direitos de meu livro. Custa US$ 200 mil, com loura opcional. Não é o mais caro mas também não é o mais barato, esse título é do V8 Vantage, aquele lixo, meros US$ 98 mil.

Só que eu não posso mais comprar um Aston, a empresa é, segundo Sundar Pichai, IR RES PON SÁ VEL. Por não oferecer produtos atendendo todos os segmentos de mercado. Se eu comprar um Aston, estaria sendo conivente. CO NI VEN TE.

O problema, Pichai, é que nem todo mundo é obrigado a seguir o seu modelo de negócios, ele não é o único e não é o único correto. A Apple vende equipamentos caros, oferecendo extrema qualidade, cuidado quase patológico nos detalhes e uma maçã que brilha. Os Androids topo de Linha, os Lumias high-end, que custam tanto quando um iPhone estão na mesma faixa de preço.

A Apple, ao contrário do Google não é uma ONG. Mesmo assim o consumidor dela tem a mesma prerrogativa do seu, Pichai: NINGUÉM obrigou o sujeito a comprar um iPad, um iPod ou um iPhone. Tim Cook não colocou uma arma na cabeça de todo mundo que gastou uma baba em um MacBook.

Muitas das críticas à Apple são verdadeiras, mas é no mínimo ingenuidade reclamar da escolha de segmento de atuação. Se for assim a Ferrari até ser vendida à FIAT era extremamente irresponsável, mas agora, como uma espécie de Crédito de Carbono da Pobreza compensa cada LaFerrari produzida com Fiats Unos.

Pichai quer que a Apple lance um iPobre, com direito a app avisando quando cai o Bolsa Família. Não vai acontecer. Todo mundo lembra quando saiu o iPhone 5c e todo mundo caiu de pau. Apple popular não rola.

No final fica a preocupação de que o chefe de produto de uma das maiores empresas do mundo não entenda que software e serviços são diferentes de hardware, e que comunismo, como roupas tamanho único só garante que todos ficarão desconfortáveis.

Fonte: CNet.

The post Executivo do Google esquece o que é capitalismo e ataca preços da Apple appeared first on Meio Bit.

Imagem meramente ilustrativa fruto de uma busca absolutamente aleatória.

Imagine que você gostou de um filme. Viu diversas vezes vezes, sabe falas inteiras de cabeça… passa o fim de semana inteiro com o DVD no autoreplay. Chega segunda você espera ansiosamente o recreio e entre uma coxinha e uma groselha, conta aos amigos, em detalhes tudo sobre Emmanuelle IV.

No meio do filme um grupo de advogados ninjas invade a quadra, mata todos os seus amigos e diz:

“Isso é só um aviso! Nós detemos os direitos autorais sobre o filme e você não está autorizado a recontá-lo.”

É o que acontece com letras e cifras de músicas. As pessoas montam sites com letras, tiram cifras no violão, distribuem, colaboram, executam as canções que a gente quer ouvir, às vezes de forma legal, às vezes bem ruinzinho, mas é assim que se aprende.

Não mais. Ressuscitando a velha briga contra as revistinhas de cifras, Roberto Carlos e Ana Carolina entravam com representação legal contra o Cifra Club e o Letras.mus, exigindo a retirada de várias músicas do acervo. Note, por músicas entenda-se letras e cifras, o que não é nem uma partitura, muito menos uma cópia da versão dos músicos.

Dody Sirena, advogado do Roberto, declarou inacreditavelmente:

“Algumas letras têm peso comercial, como Esse Cara Sou Eu. Não temos interesse em disponibilizá-la. Isso é um negócio, não é questão de censura.”

Eu pergunto: tenho cara do irmão retardado da Hellen Keller? Ou estou correto ao imaginar que qualquer um com um bloquinho, uma caneta e um gravador K7 consegue “piratear” uma letra? Eu não consigo, é uma deficiência minha, mas há gente que decora letra de música. Será que isso é um inconveniente? Então o Rei deveria distribuir com seus LPs um desses:

O mercado de licenciamento de música é um inferno, uma zona, um bataclã. Muitas vezes episódios de séries são reeditados em DVD sem as músicas que foram ao ar, o licenciamento para DVD é caro demais. Dependendo do caso a série não passa em outro país pois as músicas não estão licenciadas, e complica mais ainda quando mais de uma empresa detém o licenciamento.

São regras arcaicas incapazes de lidar com um mundo moderno conectado.

No caso das letras e cifras estão exigindo a retirada de algo que qualquer um com ouvidos funcionando consegue sozinho. Os únicos prejudicados são os fãs, que precisarão de mais trabalho para conseguir tocar e cantar as músicas de seus ídolos.

Não sei realmente qual valor comercial uma letra de música teria, em um país com 200 milhões de habitantes e a grande maioria deles capaz de ouvir a música e ENTENDER a letra. Ana Carolina diz que se preocupa com a qualidade das cifras, e que até disponibiliza algumas.

Pode isso, Arnaldo?

Poxa, será que um adolescente dedilhando um violão, trocando o Ré Bemol por um Sustenido é tão terrível assim? Eu entendo o desejo de controlar a própria obra, embora defenda que Han atirou primeiro, só que sem os fãs um artista não paga as contas. Subir num pedestal, ignorar as vítimas inocentes em nome de perfeccionismo ou “razões comerciais” é algo que soa muito mal.

O mais triste de tudo é perceber que, ao contrário do que dizem, um Rei pode perder a majestade, sim.

Fonte: Folha.

The post Roberto Carlos e Ana Carolina — quem diria, a Velha Guarda appeared first on Meio Bit.

Paris, March 2 2015

DALIBO is proud to present the second release of PoWA, the PostgreSQL Workload Analyzer.

Complete rewrite of the User Interface

The first major change is the new graphic design : we've rebuilt the web interface from scratch and placed it on a separate module called powa-web. It is now easier to move the PoWA interface out of the database server.

The new interface is based on the previous version and it adds many improvements, including:

• More graphs
• New types of graph : Bar / Pie Charts
• New configuration view
• New index suggestion widget
• New physical resource consumption graphs
• Better Global Query Chart
• Breadcrumbs
• Python 2.6, 2.7 and 3.4 compatibility
• Better browser compatibility

Screenshot:

http://powa.readthedocs.org/en/latest/stats_extensions/pg_stat_statements.html#where-is-it-used-in-powa-web

Advanced Filesystem Stats

Second, the core-engine of PoWA is now a separate module too: it's called powa-archivist and we've extended it to archive any kind of internal stats. The main source of stats remains the pg_stat_statements extension but we've integrated 2 other extensions: pg_qualstats and pg_stat_kcache.

With pg_stat_kcache, PoWA is now able to gather statistics about the physical disk access and the CPU consumption of each PostgreSQL backend. This allows the DBA to get a glimpse of the OS-level cache hit ratio.

Screenshot:

http://powa.readthedocs.org/en/latest/stats_extensions/pg_stat_kcache.html#where-is-it-used-in-powa-web

Missing Index Finder + Advanced WHERE Clause Analyzer

Third major improvement, with pg_qualstats PoWA is now collecting metrics about the operations in the WHERE clause of each query. With this data, you can know what are the most common values in your SQL statements and evaluate their "selectivity". And for columns with a very high selectivity and no index, PoWA will suggest index creation to speed up you queries.

Screenshot:

http://powa.readthedocs.org/en/latest/stats_extensions/pg_qualstats.html#where-is-it-used-in-powa-web

Disruptive changes

It was a hard choice but if we want to implement ground-breaking features like the Missing Index Finder, we need to use the latest capacities of PostgreSQL and thus we decided to drop the compatibility with PostgreSQL 9.3.

Of course, we will continue to maintain PoWA v1.2 and you can continue to use it on your PostgreSQL 9.3 servers. In a nutshell, If you already use PoWA here's what you need to know:

• If you're running PostgreSQL 9.4, we recommend that you switch to PoWA 2.0
• If you're running PostgreSQL 9.3, you can either keep PoWA 1.2 or upgrade your PostgreSQL instance and switch to PoWA 2.0

Here's a detailed explanation on why we are Moving Fast and Breaking Things

Credits & Licence

DALIBO would like to thank all the developers who contributed to this release: Rodolphe Quiedeville, Hyunjun Kim, Grégoire Pineau, Ahmed Bessifi, exordium-frozen, Christopher Liu, menardorama and especially Ronan Dunklau and Julien Rouhaud for the hard work on the GUI.

POWA is an open project available under the PostgreSQL License. Any contribution to build a better tool is welcome. You just have to send your ideas, features requests or patches using the GitHub tools or directly to powa@dalibo.com

Links :

For PoWA 2.0:

• Download: http://dalibo.github.io/powa/
• Demo: http://demo-powa.dalibo.com (login/pass = powa/demo)
• Doc: http://powa.readthedocs.org/
• Mailing list: https://groups.google.com/forum/?hl=fr#!forum/powa-users
• Issues: https://github.com/dalibo/powa/issues

For the new stats extensions:

• pg_stat_kcache
• pg_qualstats

For the complete list of changes, please checkout the release note on http://powa.readthedocs.org/en/latest/releases/v2.0.html

About POWA :

PoWA is a PostgreSQL Workload Analyzer that gathers performance stats and provides real-time charts and graph to help monitor and tune your PostgreSQL servers. It is similar to Oracle AWR or SQL Server MDW.

Code & Demo at http://dalibo.github.io/powa/

About DALIBO :

DALIBO is the leading PostgreSQL company in France, providing support, trainings and consulting to its customers since 2005. The company contributes to the PostgreSQL community in various ways, including : code, articles, translations, free conferences and workshops

Check out DALIBO's open source projects at http://dalibo.github.io

Geralmente existem 3 motivos pelos quais grande parte da população mundial não está online ainda, são elas:

1. Infraestrutura: Pessoas não acessam a internet por que eles não vivem em lugares com infraestrutura física, não permitindo a conexão.
2. Preço: Algumas pessoas não conseguem arcar com os custos de acesso.
3. Relevância: Pessoas não se conectam por que eles estão alheios à internet, não leem ou não entendem o conteúdo disponível.

Pelo menos é isso que o report anual que a o pessoal da Internet.org informa logo nas primeiras páginas. Se você quiser um dado mais palpável: somente 1 em cada 3 pessoas conseguem acessar a internet. Isso é bem pouco. Se você parar para perceber, a febre dos smartphones é bastante recente. Aqui os aparelhos e os serviços de acesso à internet são bem caros. Tudo isso dificulta para uma adesão maior do grande público.

O gráfico acima é bem interessante. Veja qual a qualidade da conexão da grande maioria do público brasileiro que acessa a internet. Só 2% dos usuários tem 4G. E ainda tem dev (e gerente) que diz que acessibilidade e performance são assuntos para serem abordados no final do projeto. Pelo contrário. Ambos precisam ser tratados como uma feature do projeto. Há também um outro gráfico que mostra o tráfego mobile nas velocidades 2G, 3G e 4G. Aqui no Brasil, a galera que usa 2G tem um tráfego um pouco maior que a galera 3G/4G.

Se você quiser se aprofundar mais nos dados, o que eu aconselho muito, baixe o PDF aqui.

---
Este artigo foi escrito por Diego Eis.

Visite o nosso site para mais posts sobre desenvolvimento web! Tableless.

One of the neat little features that arrived at PostgreSQL 9.4 is the WITH ORDINALITY ANSI-SQL construct. What this construct does is to tack an additional column called ordinality as an additional column when you use a set returning function in the FROM part of an SQL Statement.

A minha necessidade era atraves de um painel de controle (escrito em PHP) executar um comando especifico (neste caso: csf -dr IP). O procedimento poderia ser simples, usando o exec() do PHP, mas por medidas de segurança o mesmo esta desabilitado no servidor.

Como diz meu grande ídolo Dadá Maravilha, vamos a solucionática: Fazer um Shell Script que le um arquivo TXT linha por linha, onde serão gravados os IPs e executar o comando com estes IPs.

Segue o código:

Vamos botar pra rodar?

1. Entre no seu servidor via SSH
2. Crie um arquivo com o código acima atraves do comando: edit DesBloquearIPTxt
3. Faça dele um executavel com o comando: chmod +x DesBloquearIPTxt
4. Abra o agendador de tarefas: crontab -e
5. Adicione na ultima linha: * * * * * ./DesBloquearIPTxt >/dev/null 2>&1
6.  Salve e seja feliz! :)

Avisos importantes:

• Altere o nome do arquivo no código acima para o caminho exato de onde esta o arquivo, no meu caso, com os IPs gravados: DesbloquearIps.txt”
• De permissão 0777 para este arquivo, mesmo vazio
• Agora é so fazer um script em PHP para gravar os IPs que deseja desbloquear no TXT

Prontinho, agora o CRON cuida do resto. A cada minuto ele verifica se o arquivo existe, se existir, verifica linha por linha se é um IP válido, se for o IP válido ele faz o desbloqueio do IP.

Have Fun! ;)

johanirae:

kaxen:

mawkit:

doggables:

look at this

for anyone interested these are paso fino horses and this gait is natural! they are the smoothest ride with no bumpy movements. you could practically drink juice and not once would it spill on your face!

okay I watched this for like five minutes so I guess I’ll reblog

Tippy Toe horse

No dia 10 de fevereiro de 2015, comemoramos o Dia Mundial da Internet Segura. Este artigo explora a importância e os benefícios do certificado SSL (Secure Socket Layer). É importante ressaltar que, se você utiliza qualquer aplicativo que administra informações sensíveis, você necessita da encriptação da informação através do certificado SSL. Uma vez que informações sensíveis são trocadas na web sem o SSL, os dados ficam facilmente acessíveis a terceiros. Essa é a principal motivação para o uso do certificado. Porém, listamos aqui alguns motivos que vão além dessa compreensão essencial.

Oferecer segurança de dados

Segurança na navegação é o principal motivo para adotar o certificado SSL. Com o certificado, você garante que dados importantes dos seus clientes trafeguem com segurança, sob criptografia forte. A criptografia é uma codificação das mensagens trocadas através do seu site, a qual pode ser decifrada apenas através das chaves que o destinatário da mensagem possui. Como consequência disso, outra segurança oferecida pelo certificado é a integridade dos dados trocados. Isso é tão importante para o emitente quanto para o receptor da informação – ambas as partes ficam confiantes de que os dados não serão adulterados ou forjados na transação.

Um exemplo clássico da segurança que o SSL proporciona é a proteção contra phishing. Essa prática criminosa é caracterizada pelo envio de e-mails aos clientes de determinada empresa, onde criminosos tentam imitar uma comunicação oficial. Nesse caso, existem duas possíveis formas de ataque: criminosos podem incluir um link no e-mail para seus próprios websites (tentando passar-se pelo oficial) ou podem utilizar o próprio site da empresa oficial como meio para copiar as informações trocadas durante a transação (com um criminoso acompanhando a comunicação). Nos dois casos citados, o SSL protege tanto o cliente quanto a empresa atacada, deixando evidente o crime.

Obter vantagem competitiva

O certificado SSL é uma maneira de garantir privacidade na web, e boa parte dos usuários já sabe disso. Em geral, consumidores que compram online reconhecem um site seguro, graças aos sinais como o HTTPs na barra de endereço, o selo de proteção, entre outros. Graças a esses sinais, um negócio pode fortalecer a confiança na marca. Além disso, para conseguir o certificado que proporciona a navegação segura, a identidade do seu site precisa ser confirmada por uma autoridade certificadora, ou seja, você conta com a vantagem de ter seu site legitimado como uma representação da sua marca.

Expandir o seu negócio

Em seu site do Brasil, o Paypal divulgou recentemente que mais de 80% dos usuários utilizam cartões de crédito para pagar suas compras online. Eles atribuem a larga adoção do cartão de crédito às possibilidades de pagamento parcelado e sem juros, mas também existe a ideia de segurança associada ao seu uso. Para você poder oferecer essa facilidade, é necessário entrar em contato com uma operadora e fazer uma adesão. Porém, a possibilidade de oferecer o pagamento em sites via cartões de crédito está ligada ao uso do certificado SSL. As operadoras requerem esse sistema para garantir a integridade das operações online.

Otimizar SEO

Diversos fatores influenciam a colocação de sites no ranqueamento do Google. Em 6 de agosto de 2014, saiu um artigo no blog Webmaster Central do Google, onde eles comentam sobre como a segurança na web é uma prioridade para o Google e estabelecem o protocolo HTTPS (obtido através do uso do certificado SSL) como mais um fator para obter-se um bom ranqueamento. De acordo com o texto, atualmente o peso desse aspecto no algoritmo é pequeno, mas é provável que a influência desse fator aumente no decorrer do tempo. Tudo isso como estímulo ao uso da navegação segura na web.

Dicas do Google para ter seu site com SSL beneficiado nas buscas incluem: ter cuidado para não bloquear seu site da indexação através do arquivo robots.txt e permitir a indexação de páginas quando possível, evitando a tag noindex no seu código.

Ter o custo otimizado

Por fim, muitos veem o custo associado ao uso do SSL uma desvantagem do produto. Porém, como comentamos acima, o certificado é um investimento importante. Ainda com relação ao custo, é possível escolher um plano que se adapte à sua necessidade.

Novidades:

Li-Fi – Promete ser o Sucessor da Wi-Fi

Li-Fi significa “Light Fidelity” (Luz, Fidelidade – Traduzindo individualmente cada palavra). Um grupo de pesquisadores da Universidade Fundan de Xangai tiveram a brilhante ideia de transformar lâmpadas comuns em emissoras de sinais de wi-fi.

A tecnologia Li-Fi, por enquanto, é alvo apenas de testes de pesquisadores e permite altas velocidades bidirecionais — um usuário poderia tanto enviar como receber informações com a velocidade de 224 Gbps.

Segundo TechTudo, o Li-Fi funciona de formar similar ao conhecido Wi-Fi. Porém, o sistema recebe sinais de comunicação ao ligar e desligar as lâmpadas de LED em um período de nanossegundos. Apesar de as luzes precisarem ficar ligadas para transmitir os dados, elas podem ser reguladas a um ponto invisível para os olhos, mas isso diminui o seu alcance. Porém, a torna mais segura contra hackers. Além disso, cada lâmpada é capaz de oferecer conectividade para até quatro computadores.

Enquanto o Wi-Fi requer circuitos de rádio, antenas e receptores mais complexos, a Li-Fi utiliza métodos de modulação semelhantes aos raios infravermelhos, tais como os controles remotos. As lâmpadas de LED são semicondutores e a saída óptica pode ser modulada em velocidades altas capazes de serem detectadas em dispositivos fotodetectores e convertidas de volta para a corrente elétrica.

Um teste feito por Chi Nan, professor de Tecnologia da Informação da Fudan University, conseguiu manter quatro computadores conectados à Internet por meio de apenas uma lâmpada de LED com um alcance de 150 Mbps.

Já os pesquisadores alemães atingiram a marca de 500 Mbps com aparelhos colocados a 2 metros um dos outros. Com a distância de 20 metros, a velocidade caiu para 100 Mbps. Até então, a velocidade mais rápida relatada era de 3 Gb/s, pelo Instituto Heinrich Hertz Fraunhofer, na Alemanha.

O Li-Fi tem sido apontado como sucessora do Wi-Fi por oferecer mais velocidade, o esperado pelos pesquisadores é que tecnologia custe menos. O futuro dos aparelhos de celulares, tablets e computadores deverão vir com detectores de fotossensíveis e devem conseguir conexão de um poste de luz em vias públicas, por exemplo.

É preciso fazer mais testes, pois a conexão não pode ser interrompida. Acredita-se que a Li-Fi estará disponível até 2018 para todos, residências e empresas.

O post Li-Fi – Promete ser o Sucessor da Wi-Fi apareceu primeiro em VirtX.

Novidades:

HTTP/2 –  Novo Protocolo Promete Acelerar a Internet

Recentemente foi aprovado o protocolo HTTP/2, anunciado pela Internet Engineering Steering Group (IESG), órgão responsável por revisões técnicas nos padrões da internet.

A título de curiosidade, desde 1999 você está utilizando o mesmo protocolo que usa atualmente, o protocolo HTTP/1.1. A IESG finalizou a lista de especificações básicas e também uma outra lista chamada HPACK, que comprime e otimiza os cabeçalhos das páginas.

• HPACK – Cada arquivo que o navegador baixa, possui um cabeçalho, que contém informações do arquivo, tamanho, informações do servidor. O cabeçalho, não passa de 1Kb. Imagine milhares de arquivos que você baixa dos sites diariamente sem perceber. O HPACK, vai justamente otimizar a comprimir estes cabeçalhos, tornando assim ainda mais rápida a conexão.

O HTTP/2 é um variante de um protocolo apresentado pelo Google em 2009, chamado SPDY.

• SPDY (pronunciado speedy), é um protocolo de rede desenvolvido principalmente pela Google para transporte de dados pela internet. Apesar de não ser atualmente um protocolo padrão, o grupo que está desenvolvendo o SPDY está trabalhando em direção a uma padronização cuja última versão é o spdy/4.3 O SPDY é similar ao HTTP, cujos objetivos são a redução da latência na carga de páginas web e o aumento da segurança ao navegar na internet. O SPDY alcança a redução da latência através da compressão, multiplexação e priorização. O nome não é um sigla, mas um versão reduzida da palavra “speedy” do inglês. SPDY é uma trademark do Google.

Segundo o Google, a internet poderá ficar até 60% mais rápida depois que os navegadores passarem a suportar este novo protocolo e também os servidores e sites aderirem.

Segundo o MundoBit, o protocolo HTTP/1.1 realiza diversas conexões para poder exibir uma única página. Por exemplo, além das conexões para ler e exibir o que está no servidor original da página, o navegador ainda precisa acessar outros servidores como páginas de redes sociais, links do YouTube, etc.  Isso causa um excesso de tráfego que aos poucos está prejudicando a internet, que fica sobrecarregada. No novo protocolo HTTP/2, o navegador vai acessar todas essas informações em uma única solicitação. É a chamada “multiplexação”, aliado à compressão dos cabeçalhos, o novo protocolo tornará o acesso às páginas bem mais rápido que o normal.

O Google já havia anunciado que iria adotar o HTTP/2 em seu navegador Chrome “gradualmente nas próximas semanas”. O Internet Explorer do Windows 10 Technical Preview também está pronto para o novo padrão. A Mozilla Foundation testa o HTTP/2 desde a sua versão 34.

O post HTTP/2 – Novo Protocolo Promete Acelerar a Internet apareceu primeiro em VirtX.

When I was invited to join the Turing Centenary Advisory Committee in 2008 by Professor Barry Cooper to prepare for the Alan Turing Year in 2012, I would have never imagined that just a few years later, Turing’s life and work would have gained sufficient public attention to become the subject of a Hollywood-style feature film, nor that said movie would go on to earn eight Oscar nominations.

The Imitation Game is in essence a rather accurate summation of the life and brilliant work of Alan Turing, even while some aspects of the movie are clearly fictional. Turing was in many ways a victim of his great achievements—he was forbidden from telling of his accomplishments during the war to anyone, including his family. Imagine you have the chance to save the world—and you do so—but you are required to keep it confidential; that was the case of Turing and his colleagues at Bletchley Park. He was also prosecuted toward the end of his life in an unfair turn of events. Nevertheless, Turing was never engulfed by his circumstances and remained interested in what can be considered the greatest questions in science and beyond, from what intelligence is in both humans and machines to what mechanisms nature harnesses to produce forms and shapes, and ultimately life itself.

At Bletchley Park, Turing, together with other mathematicians and engineers of great talent, made longstanding contributions to science and to human history by building the first automated machines to decipher encrypted messages. His work and the work at Bletchley led to what is today one of the greatest intelligence agencies—the UK Government Communications Headquarters (GCHQ). One can play with a computer program online to see the inner workings of the famous Enigma machine used by the Germans to encode their messages, which Turing and his team were able to crack. The example below from the Wolfram Demonstrations Project shows the inner workings of such an encryption machine that used cylinders to scramble and conceal the contents of messages during World War II.

It is worth taking a minute to see how computers, and ultimately the human race, have come this far, with Turing himself playing a central role. Turing approached several scientific endeavors with incredible idiosyncrasy. When tackling what would become his most seminal work, which gave rise to the digital computer, Turing was actually not thinking of computers but of humans. Indeed, he asked how humans calculate and how much of that could be captured by mechanical calculation. By pursuing this idea to its final consequences, Turing revealed two incredibly powerful concepts of priceless intellectual value.

Turing first showed that either a human or computer with the same resources would find a fundamental limit on the sort of things that could be proven to be true or false about a theory. In other words, there are formally unanswerable questions whose answers are nevertheless known to be true or false; hence, truth and proof are separate concepts. Indeed, in this very technical formal approach, not all truths can be proven by mechanical means.

At the same time, Turing also found that he could build a single machine to do the work of any other computing machine; this is what we call a “computer” today. Computers that are capable of emulating any other computer are called “universal,” because they can do whatever any other machine can do. You can check email, watch videos, and play video games all on the same computer, as it can be reprogrammed to perform multiple tasks. That’s obvious to us now, but it wasn’t at all obvious to someone living in the 1930s.

An “a” machine, as Turing would first call it (for “automatic”), today known as a Turing machine, is the most basic unit of study in the field of theoretical computer science. The concept not only gave birth to the whole field but remains the object of reference for most purposes in computer science. For example, when you want to know how much memory one theoretically needs to perform a computation, a universal Turing machine is always the point of reference. An immediate follow-up question is whether this kind of “universal” computation occurs naturally in the world and is responsible for the complexity and structure we find in the universe.

One way to answer this question is to look at how many resources are required to build such universal computers. If it turns out that this type of computation is very easy to implement because it requires only a few simple resources, one might be persuaded that nature makes use of this computational resource to produce the shapes and patterns we find around us. And indeed, it turns out that the resources needed to implement a universal computing machine are so incredibly simple that they are available everywhere in nature. This was illustrated by a competition sponsored by Stephen Wolfram to prove whether an exceptionally simple Turing machine that he had found in his exploration of these computers in his book, A New Kind of Science, was actually capable of universal computation. The contest started and ended in a heated but rich discussion on the necessary and sufficient initial conditions for a system to become and be considered universal.

The machine above starts with an empty “tape” on which a reading “head” is placed; the head moves to the right or left and writes or deletes colors over time following the rules displayed at the bottom. While this small Turing machine requires a special initial condition to perform as a universal computer, it does not violate any previous result in the field, and thus meets the conditions for a system to be universal. An excellent place to learn about this rich computing model can be found here, and more about the smallest universal Turing machine here.

Another question related to Turing’s main interests is about the shapes and forms that emerge in nature all around us, especially in connection to life. By looking at another, but equivalent, type of computing program that Stephen Wolfram introduced in the 1980s called 1-dimensional cellular automata, one can quickly see that computer programs are incredibly rich in behavior, and that even the simplest computer programs can display an incredibly complex range of behavior. Below (see pyramidic figure) is a minimalistic computer program of this type with only three colors—an example of Wolfram’s 1-dimensional cellular automata—that starts from the simplest possible initial condition (a single dark cell at the top) and replaces the cell according to a simple set of rules (see top figure) that looks only at the neighbor’s colors to determine the color of the next central cell.

The program produces all sorts of simple and complex patterns that interact without destroying each other. There is even a small transient at the intersection of the rightmost fractal behavior and the middle one where regions of high complexity emerge just before dying out, whereas on the leftmost side there is a stripe of regular behavior feeding a seemingly never-ending, random-looking region that expands over time. The digital computers that humans produce may be simply imitating the computations that occur naturally throughout the universe, and that are, indeed, the very basis of how the universe functions.

Among the many interests of Alan Turing was the challenge of mathematical notation, which he explored in a manuscript, “Notes on the Foundations of Computer Science,” to be auctioned on April 13 of this year. Wolfram Research has built on Turing’s ideas since its beginning, and the topic of mathematical notation has also been key to the development of Wolfram Mathematica and the Wolfram Language. It is the Wolfram Language that enables Wolfram|Alpha, the world’s only computational knowledge engine, to understand queries in both formal and natural language. Stephen Wolfram has written and spoken extensively on these matters.

Recently Wolfram Research has taken an interesting direction toward pervasive computation (and related to Turing’s seminal idea of universal computation) with Wolfram Programming Cloud, bringing revolutionary technology to the real world for creating and deploying software and applications to anywhere, from anywhere. Also, the Wolfram Connected Devices Project takes us closer to the goal of injecting the power of universal computation even in the simplest devices from the Internet of Things, effectively making any physical device into a universal Turing machine. Devices like the Raspberry Pi mini-computer, already powerful in its own right, is made even more so by being shipped with the Wolfram Language and Mathematica preinstalled, enabling inquiry and exploration for the next generation of scientists and makers.

Much still remains to be discovered in connection to Turing’s main ideas, as it may turn out that the universe itself is some sort of universal Turing machine. In fact, as far-fetched as this might sound, it is exactly what classical physics prescribes: a fully deterministic world governed by computable rules and therefore emulative by a simple computer program such as a Turing machine. When physicists explain their ultimate quest for a theory of everything, they are endorsing just such an idea. Stephen Wolfram has his own approach to tackle this challenge and anticipates this being one of his next major projects as time permits.

Wolfram|Alpha shows a spike in the number of visits to the Wikipedia entry for Alan Turing on several important dates in modern history. First, the official public apology given by British Prime Minister Gordon Brown on September 10, 2009, and then around several academic events in late 2011 and early 2012. We see a great spike exactly on the 100th anniversary of his birthday on June 23, 2012—and by strange coincidence, as Stephen Wolfram notes in recognizing Turing’s 100th birthday, Mathematica’s anniversary also falls on June 23 (1988). Another spike occurs on December 24, 2013, when a posthumous royal pardon was granted for Turing’s 1952 conviction for homosexuality. More recently, there has been a steady increase due to the release of the movie The Imitation Game.

Regardless of the outcome of the Oscars awards this Sunday, in a way, Alan Turing has already won. The achievements of Turing, widely considered to be the father of modern computing, are now known worldwide, in ironic contrast to the unfortunate circumstances that led to his death. While he accomplished much in his relatively short lifetime, the best way to remember Turing is by continuing to advance his greatest ideas with the same kind of eagerness that he always had toward scientific inquiry, and by finding answers in unexpected directions. At Wolfram Research, we strive to do exactly that.

Brasileiros alcançam melhor resultado juntos desde que iniciaram a parceria, no ano passado

Da redação, no Rio de Janeiro (RJ) – 21/2/2015

Gustavo Tsuboi (44º colocado do ranking mundial) e Hugo Calderano (70º) conseguiram um grande feito neste sábado (21) ao garantirem a classificação para as semifinais de duplas do Aberto do Qatar, terceira etapa do Circuito Mundial 2015. Com o feito, os brasileiros já asseguraram ao menos a medalha de bronze.

Em um duelo emocionante, contra rivais considerados favoritos, Tsuboi e Calderano superaram nas quartas o bielorrusso Vladimir Samsonov (12º) e o esloveno Bojan Tokic (63º), por 3 sets a 2, parciais de 13/11, 2/11, 11/8, 1/11 e 11/6.

Nas semis, os brasileiros terão pela frente o croata Ruiwu Tan e polonês Wang Zengyi (57º), logo mais, às 10h30 (de Brasília). A partida terá transmissão ao vivo pelo site da Federação Internacional de Tênis de Mesa (ITTF).

“Hoje, o Gustavo serviu e recebeu muito bem. Ele me deu oportunidade de jogar bem a primeira bola, foi uma boa combinação”, afirmou Calderano, em sintonia com seu parceiro.

“Definitivamente, foi importante ter tomado a iniciativa, tivemos de ser agressivos. Concordo com Hugo, a primeira bola foi vital”, emendou Tsuboi.

Esta é apenas a terceira vez que os dois brasileiros atuam juntos nas duplas. Nos Abertos da Suécia, no fim de 2014, e do Kuwait, na semana passada, eles haviam chegado às oitavas de final. Agora, estabelecem uma nova marca para a parceria.

Individualmente, Tsuboi, de 29 anos, igualou seus melhores resultados em duplas no Circuito Mundial, quando também chegou às semis nos Abertos da Rússia (2012) e do Brasil (2012 e 2008). Já Calderano, 18, havia sido vice-campeão no Brasil, em 2012.

Confira os confrontos brasileiros já definidos no Aberto do Qatar:

INDIVIDUAL MASCULINO

Fase preliminar – 128 avos de final
Thiago Monteiro (145º) 4 x 0 Mohamed Bannout – 11/4, 11/7, 11/3 e 11/6

Fase preliminar – 64 avos de final
Gustavo Tsuboi (44º) 4 x 2 Alexandre Cassin (163º) – 8/11, 11/9, 11/4, 11/3, 11/13 e 11/4
Thiago Monteiro (145º) 1 x 4 Stephane Ouaiche (91º) – 11/7, 5/11, 5/11, 5/11 e 7/11
Hugo Calderano (70º) 1 x 4 Jean-Michel Saive (128º) – 6/11, 11/9, 9/11, 8/11 e 8/11
Cazuo Matsumoto (89º) 1 x 4 Romain Lorentz (105º) – 12/10, 9/11, 8/11, 7/11 e 9/11

Fase preliminar – 32 avos de final
Gustavo Tsuboi (44º) 2 x 4 Wu Zhikang (100º) – 8/11, 7/11, 11/4, 11/6, 6/11 e 7/11

INDIVIDUAL FEMININO

Fase preliminar – 64 avos de final
Caroline Kumahara (117ª) 4 x 0 Noora Al-Abri – 11/1, 11/8, 11/1 e 11/2

Fase preliminar – 32 avos de final
Caroline Kumahara (117ª) 0 x 4 Li Xue (56ª) – 4/11, 7/11, 5/11 e 5/11

DUPLAS MASCULINAS

Fase preliminar – 32 avos de final
Cazuo Matsumoto (89º)/Thiago Monteiro (145º) 3 x 0 Ramil Jafarov/Farhad Ismaylov (512º) – 11/5, 11/2 e 11/1

Fase preliminar – 16 avos de final
Cazuo Matsumoto (89º)/Thiago Monteiro (145º) 2 x 3 Wu Zhikang (100º)/Yang Zi – 11/7, 8/11, 11/9, 5/11 e 3/11

Chave principal – Oitavas de final
Gustavo Tsuboi (44º)/Hugo Calderano (70º) 3 x 0 Patrick Franziska/Bastian Steger (26º) – 11/7, 11/9 e 11/3

Chave principal – Quartas de final
Gustavo Tsuboi (44º)/Hugo Calderano (70º) 3 x 2 Vladimir Samsonov (12º)/Bojan Tokic (63º) – 13/11, 2/11, 11/8, 1/11 e 11/6

Chave principal – Semifnais
Gustavo Tsuboi (44º)/Hugo Calderano (70º) x Ruiwu Tan/Wang Zengyi (57º) – 21/2, às 10h30

DUPLAS FEMININAS

Fase preliminar – 16 avos de final
Caroline Kumahara (117ª)/Carole Grundisch (94ª) 3 x 0 Maha Faramazi/Aia Mohamed (535ª) – 11/3, 11/5 e 11/3

Chave principal – Oitavas de final
Caroline Kumahara (117ª)/Carole Grundisch (94ª) 0 x 3 Liu Jia (12ª)/Iveta Vacenovska (46ª) – 6/11, 11/13 e 2/11

SUB-21 FEMININO

Chave principal – Oitavas de final
Caroline Kumahara (37ª) 0 x 3 Zeng Jian – 4/11, 7/11 e 1/11

A Confederação Brasileira de Tênis de Mesa conta com recursos da Lei Agnelo/Piva – Lei de Incentivo Fiscal e Governo Federal – Ministério do Esporte.

Siga a CBTM nas redes sociais:

FACEBOOK: www.facebook.com/TMBrasil
TWITTER: www.twitter.com/cbtm_tm
INSTAGRAM: @cbtenisdemesa

iDigo | Assessoria de comunicação CBTM
imprensa@cbtm.org.br

I’m a programmer by trade. And if there’s one thing I’ve learned over the past 17 years doing this professionally, it’s that everything old is new again. There are really only so many patterns, and they just circle back around with new (and often more ridiculous) names.  

It’s rare that something really new comes along. I’d argue that the web, more specifically http, offered up the last truly new paradigm in computing. It is a single, elegant standard for distributed systems. We should all take the time every now and then to think about the beauty, power, and simplicity of this standard.

I’ve always had a similar affinity for RSS. If content is going to be distributed all over the world, it’s essential to have an elegant system for syndicating and subscribing to content sources. On top of that, a huge percentage of content sites adopted this standard years ago and still maintain it to this day. Man, are we lucky.  I can’t believe how many people still browse from site to site or just take what they can get from Twitter, et al.

It’s easy to get swept up in the latest trends in technology. Hardware, apps, development frameworks, social networks and so on. It’s never ending. But too often it takes us away from what I really want to be able to do with technology. Give me a browser, an RSS reader, and an email account and I’m all set. These are the standards that are built to last. Everything else just comes and goes.

Not later than this week a bug regarding pg_dump and compression with zlib when dumping data has been reported here.

The issue was that when calling -Fd, the compression level specified by -Z was ignored, making the compressed dump having the same size for Z > 0. For example with a simple table:

=# CREATE TABLE dump_tab AS SELECT random() as a,
                                   random() as b
   FROM generate_series(1,10000000);
SELECT 10000000

A dump keeps the same size whatever the compression level specified:

$ for num in {0..4}; do pg_dump -Fd -t dump_tab -f \
    level_$num.dump -Z num ; done
$ ls -l level_?.dump/????.dat.gz level_0.dump/????.dat
-rw-r--r--  1 michael  staff  419999247 Feb 20 22:13 level_0.dump/2308.dat
-rw-r--r--  1 michael  staff  195402899 Feb 20 22:13 level_1.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  195402899 Feb 20 22:14 level_2.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  195402899 Feb 20 22:15 level_3.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  195402899 Feb 20 22:16 level_4.dump/2308.dat.gz

After a couple of emails exchanged, it was found out that a call to gzopen() missed the compression level: for example to do a compression of level 7, the compression mode (without a strategy) needs to be something like "w7" or "wb7" but the last digit was simply missing. An important thing to note is how quickly the bug has been addressed, the issue being fixed within one day with this commit (that will be available in the next series of minor releases 9.4.2, 9.3.7, etc.):

commit: 0e7e355f27302b62af3e1add93853ccd45678443
author: Tom Lane <tgl@sss.pgh.pa.us>
date: Wed, 18 Feb 2015 11:43:00 -0500
Fix failure to honor -Z compression level option in pg_dump -Fd.

cfopen() and cfopen_write() failed to pass the compression level through
to zlib, so that you always got the default compression level if you got
any at all.

In passing, also fix these and related functions so that the correct errno
is reliably returned on failure; the original coding supposes that free()
cannot change errno, which is untrue on at least some platforms.

Per bug #12779 from Christoph Berg.  Back-patch to 9.1 where the faulty
code was introduced.

And thanks to that, the dump sizes have a much better look (interesting to see as well that a higher compression level is not synonym to less data for this test case that has low repetitiveness):

$ for num in {0..9}; do pg_dump -Fd -t dump_tab -f \
    level_$num.dump -Z num ; done
$ ls -l level_?.dump/????.dat.gz level_0.dump/????.dat
-rw-r--r--  1 michael  staff  419999247 Feb 20 22:24 level_0.dump/2308.dat
-rw-r--r--  1 michael  staff  207503600 Feb 20 22:25 level_1.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  207065206 Feb 20 22:25 level_2.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  198538467 Feb 20 22:26 level_3.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  199498961 Feb 20 22:26 level_4.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  195780331 Feb 20 22:27 level_5.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  195402899 Feb 20 22:28 level_6.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  195046961 Feb 20 22:29 level_7.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  194413125 Feb 20 22:30 level_8.dump/2308.dat.gz
-rw-r--r--  1 michael  staff  194413125 Feb 20 22:32 level_9.dump/2308.dat.gz

Nice community work to sort such things out very quickly.