Instalando Node.js 6.x e npm no Ubuntu 16.04

Instalando Node.js 6.x e npm no Ubuntu 16.04

Node.js é uma plataforma Javascript que permite que os desenvolvedores criem aplicações de rede escaláveis e de maneira rápida. É utilizada no mundo todo e mantida por uma grande comunidade.
Outro importante elemento é o gerenciador de pacotes npm (node package manager). Com o npm é possível ter acesso a um repositório online onde existem milhares de projetos de código-aberto para o Node e, claro, gerenciar todas as dependências e versões que precisarmos. Dito isso, vou mostrar duas maneiras de instalar o node e também como instalar o npm no seu Ubuntu 16.04. Vamos lá?
Utilizando os repositórios do Ubuntu
A maneira mais simples de instalar o node no Ubuntu é obtendo-o dos repositórios padrões do sistema operacional. Geralmente não será a última versão, mas será uma versão estável. Primeiro, precisamos ter certeza que nossos repositórios e os pacotes do sistema estão atualizados

$ sudo apt update
$ sudo apt upgrade

E logo então podemos instalar o node (aqui precisei de sudo)

$ sudo apt install nodejs

E por último o npm (também precisei de sudo)

$ sudo apt install npm

Para verificar que tudo foi instalado corretamente, vamos conferir as versões que foram instaladas (pode ser que você já tenha instalado uma versão mais atual)

$ node -v
v6.9.4
$ npm -v
3.10.10

Utilizando um PPA
PPA (Personal Package Archives) são pacotes pessoais que não pertencem as atualizações ou softwares padrões do Ubuntu; criados e mantidos pela comunidade. Geralmente são utilizadas para manter as versões mais atualizadas dos softwares, que não estão nos repositórios padrões. Eu não vou entrar aqui no assunto se PPAs são seguros ou não, porque nesse caso o PPA que vou indicar para vocês é indicado pelo site oficial do node.
Primeiro precisamos instalar uma dependência do pacote python-software-properties caso você ainda não o tenha

$ sudo apt install python-software-properties

e agora basta adicionar o PPA

$ curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -

Feito isso

$ sudo apt install nodejs

Utilizando o PPA, o npm é instalado automaticamente junto com o node. Novamente testando a instalação

$ node -v
v6.9.4
$ npm -v
3.10.10

No momento em que escrevi este artigo, a versão mais atual do Node.js é a v7.4.0, mas ela ainda não estava com LTS (Long Term Support), o que não impede você de testá-la ou usá-la. Se quiser fazer isso, simplesmente repita a instalação via PPA, mas com o seguinte repositório

$ curl -sL https://deb.nodesource.com/setup_7.x | sudo -E bash -

Verá que as versões foram atualizadas

$ node -v
v7.4.0
$ npm -v
4.0.5

É isso ai pessoal! Tem alguma dúvida? Me deixe uma mensagem nos comentários. Até a próxima!

O post Instalando Node.js 6.x e npm no Ubuntu 16.04 apareceu primeiro em Blog Locaweb – Notícias sobre tecnologia, programação e muito mais..

Instalando Node.js 6.x e npm no Ubuntu 16.04
Fonte: Locaweb

Instalando o Cordova 6.x no Ubuntu e Mac OS X

Instalando o Cordova 6.x no Ubuntu e Mac OS X

Instalar o Cordova no Ubuntu e no Mac OS X é uma tarefa bem simples se já tivermos com o Node.js e npm instalados. Caso você ainda não tenha essas dependências, você pode instalá-las utilizando um destes dois guias, para Ubuntu ou para Mac OS X.
Bom, agora que você já tem as dependências necessárias, vamos utilizar o npm para instalar o Cordova. Neste guia, eu estou utilizando o Ubuntu 16.04, mas os mesmos comandos podem ser utilizados para instalar no Mac OS X também. Para instalar o framework, simplesmente digite em seu terminal

$ npm install -g cordova

Aqui eu precisei de sudo, por conta de algumas permissões de pastas do meu computador. A saída desse comando, deve ser mais ou menos a seguinte (pode mudar dependendo de quantas dependências do cordova você já tiver instaladas)

Para ter certeza que tudo está certo, vamos então criar uma aplicação de teste bem simples. Todos os comandos que vamos precisar para criar essa aplicação serão feitos através da CLI (command-line interface) do Cordova.
Entre em um diretório de sua preferência onde deseja criar a aplicação. No meu caso

$ pwd
/home/pablo
$ cd repos

Uma vez no diretório, digite

$ cordova create appTest
Creating a new cordova project.

Se nenhum erro apareceu, a aplicação inicial foi criada. Aqui não estamos falando de nenhuma plataforma, simplesmente estamos testando nosso framework. Por isso, vamos utilizar o nosso navegador mesmo para testar nossa aplicação, pois não vamos precisar instalar nenhuma dependência de plataforma. Com a aplicação criada, entre no diretório em que ela está

$ cd appTest

Agora vamos adicionar uma plataforma ao nosso projeto, neste caso como disse o próprio navegador (é possível que ele instale algumas dependências automaticamente)

$ cordova platform add browser
Adding browser project…
Running command: /home/phsil/.cordova/lib/npm_cache/cordova-browser/4.1.0/package/bin/create /home/phsil/repos/MyApp/platforms/browser io.cordova.hellocordova HelloCordova
Creating Browser project. Path: platforms/browser
Discovered plugin “cordova-plugin-whitelist” in config.xml. Adding it to the project
Fetching plugin “cordova-plugin-whitelist@1” via npm
Installing “cordova-plugin-whitelist” for browser

Uma vez que o nosso projeto agora tem suporte para o navegador, vamos então rodar nossa aplicação para confirmar que tudo deu certo

$ cordova run browser
Running command: /home/phsil/repos/MyApp/platforms/browser/cordova/build
Cleaning Browser project
Running command: /home/phsil/repos/MyApp/platforms/browser/cordova/run –nobuild
Static file server running @ http://localhost:8000/index.html
CTRL + C to shut down

Como você pode ver, foi criado um servidor estático no endereço http://localhost:8000/index.html. Abra seu navegador (se ele não foi aberto automaticamente) e digite o endereço do servidor.
Se tudo deu certo, você verá a seguinte tela:

Parabéns, você criou sua primeira aplicação utilizando o Cordova.
Você pode saber muito mais sobre o framework, olhando sua documentação neste link. É uma documentação bem completa que vai te ajudar a entender melhor os aspectos do framework e começar a desenvolver para outras plataformas, como Android e iOS.
Ficou alguma dúvida? Escreva aí nos comentários! Até a próxima!
O post Instalando o Cordova 6.x no Ubuntu e Mac OS X apareceu primeiro em Blog Locaweb – Notícias sobre tecnologia, programação e muito mais..

Instalando o Cordova 6.x no Ubuntu e Mac OS X
Fonte: Locaweb

Conheça a arte do SOLID

Conheça a arte do SOLID

Quando escuto ou leio a palavra SOLID me vem logo o Snake, do game Metal Gear Solid na cabeça e isso acontece há muito tempo. Não sou nenhum fã do jogo, mas também não sou hater, apenas não joguei o suficiente para entrar em um dos lados da força.
Agora, voltando ao tal do SOLID – que não é jogo -, você já ouviu falar dele? Já o usou? Sabe para que serve? Neste artigo vamos fazer um overview e ver a melhor forma de usar esse cara…
Primeiro precisamos saber que SOLID é uma sigla para Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion.
Para facilitar, o SOLID é um acrônimo para os cinco primeiros princípios da programação orientada para objetos, nós buscamos segui-los para que um projeto seja realmente orientado a objetos e não um fruto da nossa linda e maravilhosa criatividade.
Vamos ver o que cada um desses princípios tratam; só para facilitar o entendimento dos conceitos, utilizaremos alguns exemplos em JAVA e outros em Ruby:
– Single Responsibility
O Single responsibility está ligado diretamente ao objetivo que a cada classe possui, sendo que uma classe deve ter sempre um único objetivo. Se o sistema está crescendo e uma classe passou a ter duas responsabilidades é hora de dividi-la em duas classes, cada uma com uma responsabilidade. Exemplo:
class Client
def save(args)
super
ExecuteDepencencies.execute(args[:dependencies])
end
end

class ExecuteDepencencies
def self.execute(dependencies)
dependencies.each do |dependency|
dependency[:module].execute(dependency[:arg])
end
end
end

class UploadFile
def self.execute(file)
#Do the upload
end
end

class Sendmail
def self.execute(email)
#Send email
end
end

Imagine um formulário de cadastro onde o usuário ao submeter os dados já faz o upload do arquivo anexo e envia um e-mail para o mesmo confirmando o cadastro. A responsabilidade de salvar ficou na classe do cliente enquanto fazer o upload e enviar o e-mail ficaram em classes separadas, podendo ser utilizados em outros lugares do sistema em que seja necessário novamente fazer o upload de um arquivo como no cadastro de produtos ou enviar um e-mail como no fechamento de uma compra.
– Open-closed
O princípio de aberto e fechado nos traz o conceito de que devemos sempre deixar nossas classes abertas para serem expandidas, porém fechadas para serem modificadas. Ou seja, você deve isolar a regra para que assim outras classes possam usar ela. Exemplo:
public class User {
public void executeRole(String role){
if(role == ‘Admin’){
// Do Something
}

if(role == ‘Client’){
// Do Something
}
}
}

No exemplo acima sempre que implementarmos alguma regra nova, por exemplo um Fornecedor (Provider), iremos colocar um if a mais no código e esses ifs tendem ao infinito.
A ideia do princípio é colocar a role em uma interface para retirar esses ifs. Exemplo:
public interface Role {
void executeRole(String role);
}

public class Admin implements Role {}
public class Client implements Role {}
public class Provider implements Role {}

Desta forma dentro das classes iremos implementar o método executeRole sem nenhum if, apenas executando o que cada um deveria fazer. A ideia nesse caso é que a interface Role seja pouco modificada (o ideal é que ela não seja modificada) e apenas a sua implementação nas classes que irão utilizá-la sejam alteradas conforme a necessidade da classe.
 
– Liskov substitution
Esse princípio está relacionado a herança e diz que se você tem um objeto B que herda A, em qualquer lugar que você tenha A você pode substituir por B sem precisar alterar o programa. Exemplo:
class Gadget
def call(number)
true
end
end

class Smartphone < Gadget
end

class Psp < Gadget
def call(number)
raise “This gadget do not make calls”
end
end

Basicamente temos uma classe Gadget e ela possui um método de call (ligar), sendo que Smartphone e PSP são Gadgets, logo herdam ela e trazem consigo o método call. Porém, o PSP não faz ligações, por isso mesmo faremos o método retornar uma exception. Com isso ferimos o princípio de Liskov.
Se tivéssemos uma instância de Gadget e a mesma fosse substituída por Smartphone funcionaria normalmente. O método call, ao invés de ter um retorno booleano, como o método da classe pai fazia, acaba retornando uma exception (claro que poderíamos fazer o método call no PSP, mas queria deixar dessa forma, como um exemplo).
 
– Interface segregation
O Princípio da Segregação de Interface trata da coesão de interfaces e diz que classes não devem ser forçadas a depender de métodos que não usam. Exemplo:
public interface Activity {
void buy(Order order);
}

public class ShopOwner implements Activity {}
public class Client implements Activity {}
public class Provider implements Activity {}

Esse exemplo está ferindo o princípio, pois o dono da loja pode comprar do fornecedor e o cliente comprar do dono da loja, mas o fornecedor não compra de ninguém e, nesse caso, você seria obrigado a implementar o método buy no fornecedor, mesmo o método não servindo para ele.
– Dependency inversion
O princípio de inversão de dependência nos diz que SE devemos acoplar alguma classe em outra, devemos fazer esse acoplamento em classes estáveis. De forma mais simples o princípio quer dizer:

Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender de abstrações.
Abstrações não devem depender de detalhes. Detalhes devem depender de abstrações.

Exemplo:
public interface ActionAfterBuy {
void execute(User user);
}

public class Cart implements ActionAfterBuy {}

Nesse exemplo o carrinho é um módulo de alto nível e o ActionAfterBuy (Ação depois de comprar) é uma abstração. Perceba que o ActionAfterBuy é uma classe estável, pelo fato de que ela pouco vai ser alterada ao longo do tempo (a ideia de classes estáveis é justamente essa, não alterá-la durante o ciclo de vida do software); além disso, ela não conhece detalhes de sua própria implementação.
Esse é apenas um resumo do que é o SOLID, caso queira se aprofundar no assunto, recomendo fortemente o livro “Orientação a Objetos e SOLID para ninjas” do Maurício Aniche. Outro bom artigo é o “The Principles of OOD”.

Gostou do que falamos? Ficou com alguma dúvida? Deixe nos comentários!
O post Conheça a arte do SOLID apareceu primeiro em Blog Locaweb – Notícias sobre tecnologia, programação e muito mais..

Conheça a arte do SOLID
Fonte: Locaweb