Com o Ubuntu Builder você pode fazer isso!
Baixe a última versão do Ubuntu Builder, instale-o e ai, é só abrir o programa.
Não criei uma distro Ubuntu Dicas
Bem, quem testar ai, me diga depois se é bom mesmo este trem?
Abraaaaços!
Com o Ubuntu Builder você pode fazer isso!
Baixe a última versão do Ubuntu Builder, instale-o e ai, é só abrir o programa.
Não criei uma distro Ubuntu Dicas
Bem, quem testar ai, me diga depois se é bom mesmo este trem?
Abraaaaços!
Para começar, precisamos de algumas ferramentas:
Entre os frameworks Javascript, nessa série de posts pretendo utilizar inicialmente jQuery, por ser atualmente o mais utilizado no mundo. Você pode baixá-lo aqui e acessar a documentação aqui.
Para incluir a biblioteca jQuery na sua página, o código mais simples possível é esse:
1 2 3 4 5 6 7 | <html> <head> <script src="/path/to/jquery-1.7.1.min.js" type="text/javascript"></script> <!-- OU --> <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"></script> </head></html> |
Dentro da tag <head>, temos duas opções: adicionar o caminho do script que você baixou (ideal para desenvolvimento local), ou utilizar o acesso que a Google fornece livremente (e que muitos sites utilizam, sendo provável que o usuário já tenha uma cópia em cache desse arquivo e sua página deve carregar mais rápido).
Depois de incluir o jQuery na nossa página, vamos fazer alguma coisa com ele. Algo simples, como acessar a API do Youtube e pesquisar pelos 5 vídeos mais recentes sobre Linux:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | <html> <head> <script src="jquery-1.7.1.min.js" type="text/javascript"></script> </head> <body> <script type="text/javascript"> // isso será executado ao carregar a página $(document).ready(function() { // acessa a API do Youtube e pesquisa por vídeos sobre Linux // vamos usar o formato JSON para receber os resultados (o padrão é XML) $.get('http://gdata.youtube.com/feeds/api/videos?q=Linux&alt=json&max-results=5', function(result) { // esses são os resultados retornados na pesquisa var entries = result.feed.entry; // vamos exibir os dados de cada um $.each(entries, function(index, item) { var title = item.title.$t, // o título desc = item.content.$t, // a descrição link = item.link[0].href; // o link // exibindo os dados na página // aqui você poderia formatar a saída, adicionar estilos CSS, etc. // vamos só exibir de forma básica $('body').append('<h3><a href="' + link + '">' + title + '</a></h3><p>' + desc + '</p>'); }); }); }); </script> </body></html> |
Esse é um exemplo bem simples. Repare que ao exibir os dados nós não formatamos nada. Apenas exibimos o título com link para o vídeo e a descrição. Mas a API do Youtube retorna muito mais dados, como nome do usuário que postou o vídeo, data de publicação, e muito mais! Não é o nosso objetivo aprender a API do Youtube aqui, mas eu recomendo acessar diretamente a URL que utilizamos na requisição GET e estudar o retorno do Youtube para ver o que mais é possível (caso esteja interessado).
Espero que tenham entendido o exemplo. Caso algo não tenha ficado muito claro, comentem. Se tiverem alguma ideia, comentem também! Até o próximo post.
Primeiro, o que é uma página dinâmica? De uma maneira simples, é uma página HTML com a capacidade de se atualizar (alterar os dados apresentados na tela) sem ser necessário recarregar a página. Antes, era necessário recarregar a página para que fosse possível consultar no banco de dados do servidor as novas informações a serem apresentadas. Hoje, isso pode ser feito utilizando-se tecnologias como AJAX para receber os dados em formato JSON ou XML e Javascript para interpretá-los.
Vejamos um exemplo: você está no Twitter, meu perfil por exemplo, quando alguém escreve algum tweet. O que você prefere: atualizar a página só para ler esse tweet, ou ver uma notificação onde só é necessário um clique para atualizar a timeline? A segunda opção, é claro. É nessa parte que entra o Javascript!
Vejamos um exemplo básico de como é possível alterar uma página dinamicamente:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | <!DOCTYPE html><html> <head> <title>Curso de Javascript do Blog infognosis</title> </head> <body> <form id="formulario" onsubmit="formSubmit(); return false;"> <label for="nome">Qual é o seu nome? </label> <input type="text" id="nome" placeholder="Digite o seu nome"> <input type="submit"> </form> <!-- uma div vazia, por enquanto... --> <div id="visitantes"> </div> <script type="text/javascript"> function formSubmit() { // pegando o valor digitado pelo usuário var nome = document.getElementById("nome"); // a div onde vamos exibir os dados var visitantes = document.getElementById("visitantes"); // aqui adicionamos um nova linha ao conteúdo existente visitantes.innerHTML += "<br>" + nome.value + " esteve aqui."; // limpando a caixa de texto nome.value = ""; } </script> </body></html> |
Esse exemplo muito simples apenas pega o valor digitado pelo usuário e exibe ele na página (ou seja, o conteúdo da página foi atualizado, sem ser necessário recarregar a página :D). Repare que na tag <form> definimos que no evento onsubmit a nossa função deveria ser executada e deveria ser retornado falso. Esse return false no final faz uma parte importante da mágica: evita que a página seja atualizada.
Nesse exemplo usamos a entrada do usuário para atualizar a página, mas é possível também incluir dados externos! Mas isso é assunto para o próximo post.
Hoje vamos começar uma série de posts sobre programação em Javascript. Vamos criar desde códigos simples até alguns códigos mais avançados, e ainda apresentar diversas ferramentas úteis para um desenvolvedor Web. Mas como é de costume em qualquer curso, vamos começar com a teoria.
Javascript é uma linguagem interpretada (isto é, não precisa ser compilada e gerar um arquivo binário para que possa ser testada) voltada para a Web. Embora existam aplicações no lado do servidor, seu uso é mais comum no lado cliente, ou seja, no navegador do usuário, pois permite a criação de uma página dinâmica. O Javascript pode ser utilizado desde códigos simples para validação de um formulário, por exemplo, até aplicações complexas desenvolvidas com centenas de milhares de linhas de código.
Vamos começar com o básico: como incluir Javascript em minha página HTML? (esse curso supõe que você tenha pelo menos um conhecimento básico de HTML)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | <html> <head> <title>Curso de Javascript do Blog infognosis</title> <!-- podemos incluir um arquivo externo assim: --> <script src="javascript.js" type="text/javascript"></script> </head> <body> <!-- ou inserir o código no meio do arquivo assim: --> <script type="text/javascript"> alert("Curso de Javascript do Blog Infognosis!"); </script> </body></html> |
Pronto, você já tem seu código Javascript rodando. Mas sem fazer nada. Agora vamos ver alguma coisa um pouco mais útil, pegar o valor de um campo de texto digitado pelo usuário e exibi-lo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | <html> <head> <title>Curso de Javascript do Blog Infognosis</title> </head> <body> <!-- Nosso código Javascript --> <script type="text/javascript"> function formSubmit() { var nome = document.getElementById("nome").value(); alert("Olá " + nome + "! Bem-vindo ao Blog Infognosis!"); } </script> <!-- vamos criar um formulário com um campo de texto e um botão --> <form id="formulario" onsubmit="formSubmit()"> <label for="nome">Digite seu nome: </label> <input type="text" id="nome" /> <input type="submit" id="submit" text="Enviar" /> </form> </body></html> |
Basicamente uma estrutura de dados é um tipo de dado heterogêneo criado pelo usuário, ou seja, é uma variável que armazena tipos de dados diferentes. A strutc pode ser comparada a um registro. Hoje explicarei como criar e utilizar uma estrutura.
Imagine que você precise armazenar um registro de um cliente onde esse registro contém os campos Código, Nome e Telefone. Agora imagine que você precise armazenar 100 registros iguais a esse.
Para resolver esse problema iremos mesclar a estrutura de dados com arrays.
Criando uma estrutura:
struct regEstrutura {
int atributo1;
char atributo2;
float atributo3;
}
Declaração de uma variável da estrutura criada:
struct regEstrutura Clientes;
Declaração de um array de uma estrutura:
struct regEstrutura Clientes[10];
Exemplo de uso de registro:
#include <stdio.h>
#include <stdlib.h>
#define NUMCADAS 9 // Número de cadastros
main(){
/* Criação da estrutura de dados */
struct regCadastro {
/* Declaração dos atributos da estrutura */
int codigo;
char nome[20];
};
/* Criação de um tipo de dado regCadastro */
struct regCadastro Cadastro[NUMCADAS];
/* Variável de controle do loop */
static int cont;
int ind;
int opcao;
int pesquisa;
cont=1;
do {
printf(“1. Cadastrar\n”);
printf(“2. Consultar\n”);
printf(“\n\n\n Digite 0 para sair “);
printf(“\n Opção: “);
scanf(“%d”,&opcao);
switch(opcao){
case 1:
printf(“\nDigite o código: “);
scanf(“%d”,&Cadastro[cont].codigo);
printf(“\nDigite o nome: “);
scanf(“%s”,Cadastro[cont].nome);
cont=cont+1;
break;
case 2:
printf(“\nDigite o código: “);
scanf(“%d”,&pesquisa);
for(ind=1;ind<=cont;ind++){
if (Cadastro[ind].codigo==pesquisa){
printf(“\nNome: %s”,Cadastro[ind].nome);
break;
}
}
}
system(“sleep 2;clear”);
} while (opcao!=0);
}
Esta é uma dica simples que pode ser muito útil. Aqui poderemos executar comandos do linux a partir de um bloco de comandos em C
É bem simples, inclua a biblioteca stdlib.h no seu código e use o comando system como segue abaixo:
#include <stdio.h>
#include <stdlib.h>
main(){
int opcao;
printf("1. Abrir o Google Chrome\n");
printf("2. Abrir o Gedit\n");
scanf("%d",&opcao);
// o comando system chama as funções do sistema, exemplo:
switch(opcao){
case 1: system("chromium-browser");
break;
case 2: system("gedit");
break;
}
}Salve tudo isso como ex_system.c e digite:
# gcc ex_system.c -o ex_system
# ./ex_system
Hoje falarei sobre os funções;
Funções
As funções server para dividir tarefas grandes em tarefas menores, permitindo que pessoas possam trabalhar juntas e poder reutilizar o que pessoas já fizeram. E é claro, deixa o código mais simples no conceito “dividir para conquistar”.
Uma função é um bloco de código desenhada para cumprir uma tarefa particular.
O printf() é uma função que utilizamos muitas vezes sem saber realmente como ela trabalha.
Como declarar uma função:
nomedafuncao (declaração dos argumentos)
{
instrução1;
instrução2;
instruçãoN;
}
No exemplo abaixo existe uma função que calcula o preço de um carro de uma agência:
/*
EXEMPLO DE FUNÇÃO
*/
#include <stdio.h>
funcao(double custo){
double impostos;
double comissao;
double preco;
impostos=custo*0.15; // 15% de impostos
comissao=custo*0.3; // 30% de comissão
preco=custo+impostos+comissao;
printf(“\nValor dos impostos: %lf”,impostos);
printf(“\nComissão: %lf”,comissao);
printf(“\nValor total do carro: %lf\n”,preco);
}
main(){
double preco;
printf(“\nDigite o preço do carro: “);
scanf(“%lf”,&preco);
funcao(preco);
}
Hoje falarei sobre os comandos break, continue.
Também falarei sobre a criação de arrays pois é muito dificil exemplificar a utilidade de um laço e dos comandos break e continue sem utilizar arrays
Os arrays (vetor e matriz) são variáveis multivaloradas, ou seja, conseguem armazenar vários valores. São como os vetores e as matrizes da matemática, onde você utiliza o índice do array para referenciar uma posição.
Como declarar um array:
tipodedado variavel[N];
Esta variável é como um vetor, e pode armazenar seus valores em N posições.
Como declarar um array bidimensional:
tipodedado variavel[M][N];
Exemplo:
/*
Exemplo de arrays
*/
#include <stdio.h>
main() {
int vetor[5];
int matriz[5][5];
int indL, indC;
// Lendo os valores do vetor
for(indL=1;indL<=5;indL++) {
printf("Digite um número para a posição %d do vetor: \n",indL);
scanf("%d",&vetor[indL]);
}
// Lendo os valores da matriz
for(indL=1;indL<=5;indL++){
for(indC=1;indC<=5;indC++){
printf("Digite o valor para a posição %d,%d da matriz: \n",indL,indC);
scanf("%d",&matriz[indL][indC]);
}
}
// Exibindo os valores do vetor
for(indL=1;indL<=5;indL++) {
printf("Valor do vetor na posição %d: %d \n",indL,vetor[indL]);
}
// Exibindo os valores da matriz
for(indL=1;indL<=5;indL++){
for(indC=1;indC<=5;indC++){
printf("Valor da matriz na poisção %d,%d: %d \n",indL,indC,matriz[indL][indC]);
}
}
}
O comando break é utilizado para causar uma saída imediata de um laço, passando para a instrução seguinte.
Vamos escrever um programa que encontra o fatorial de um número de apenas um algarismo utilizando laço e o comando break.
/*
Encontra o fatorial de algum número
*/
#include <stdio.h>
main(){
int num;
long resposta;
while(1) {
printf("\n Digite o número: ");
scanf("%d",&num);
resposta=1;
while(num > 1)
resposta *= num--;
printf("O fatorial é %ld\n", resposta);
break;
}
}
Ao encontrar a resposta o programa imprime o fatorial e força a saída do laço.
O comando continue pula um bloco de instruções dentro de um laço indo direto para o teste. No exemplo a seguir não é executado o comando que está após o comando continue:
/*
Exemplo do comando continue
*/
#include <stdio.h>
main(){
int indice;
indice=1;
while(indice<10){
printf("O índice atual é %d!\n",indice);
indice=indice++;
continue;
printf("Isto não irá aparecer!");
}
}
Já teve alguma ideia de como o seu sistema deveria funcionar e como tudo seria mais fácil se fosse desse jeito? Lembra do Matrix? tudo é possível na matrix, só depende da sua criatividade! O mundo do desenvolvimento (O livre principalmente) não tem limites! você pode integrar seu sistemas, automatizar serviços, CRIAR! sem precisar procurar pela internet frustrado por ninguém ainda ter inventando uma coisa que na sua cabeça pode ser tão simples! então porque não aprender programar? Ensinarei aqui, algoritmos, lógica de programação e linguagem C.
Para programar em C, iremos instalar o compilador GCC e o editor VIM. Para instalar digite:
# apt-get install gcc vim-full
Uma variável, em matemática, é um valor que depende de fatores externos. Em informática, uma variável é um espaço reservado na memória para um dado que pode ser ou não alterado durante um processo.
Uma constante em matemática é um valor fixo. Em informática, é como uma variável que não tem seu valor alterado durante o processo, ou seja, é um espaço reservado na memória para um dado que permanecerá o mesmo durante todo o processo.
Ao declarar uma variável ou uma constante, devemos definir o tipo de variável que ela é, uma variável do tipo inteiro não poderá receber um dado do tipo literal (texto). Em C existem 5 tipos de variáveis básicas. Nos computadores do tipo IBP-PC a tabela seguinte é válida:
TIPO BIT BYTES ESCALA
char 8 1 -128 a 127
int 16 2 -32768 a 32767
float 32 4 3.4E-38 a 3.4E+38
double 64 8 1.7E-308 a 1.7E+308
void 0 0 sem valor
Em algoritmo utilizaremos os tipos inteiro, real, literal (texto) e logico (verdadeiro ou falso).
= Operador de atribuição
+ Soma
- Subtração
* Multiplicação
/ Divisão
% Módulo (devolve o resto da divisão inteira)
- Menos unário
O operador unário é utilizado apenas para troca de sinal algébrico do valor.
A teoria dos sistemas, que foi criada pelo biólogo Ludwig von Bertalanffy, basicamente define um sistema em três passos:
Entrada: Um dado ou uma informação
Processo: O que acontece com o dado ou informação dentro do sistema
Saída: É o resultado do processo, esta saída pode também ser uma nova entrada
As funções de entrada e saída que iremos utilizar em algoritmo são:
Leia(valor)
Escreva(valor)
“Um algoritmo não representa, necessariamente, um programa de computador, e sim os passos necessários para realizar uma tarefa. ”
Um algoritmo em programação, é a forma de definir todos os passos do seu programa, ou seja, é aonde você planeja o seu programa.
Como todas as tarefas de níveis elevados de complexidade, devemos planejar como o nosso sistema funcionará para evitar problemas futuros e ter até de reescrever todo o sistema. Não devemos tapar buracos, devemos planejar bem prever o que pode ser previsto.
Um algoritmo também evita erros de lógica durante a programação, deixando todos os erros de lógica durante a criação do algoritmo, o que facilita a detecção de problemas futuros caso ocorram.
Basicamente a estrutura de um algoritmo possui o nome do programa seguido da palavra ínicio, todas as funções ques serão executadas e ao fim do algoritmo um fimalgoritmo, exemplo:
Programa “Lê o nome”
Inicio
funcao1…
funcao2…
funcaoN…
fimalgoritmo
Mesmo antes de criar os algoritmos existem alguns passos, como a definição das entradas, processos e saída, exemplo:
Vamos fazer um programa que lê um número inteiro e soma 5 à esse número
Programa “Soma 5″
Inicio
crie numero : inteiro
escreva(“Digite um número que será somado à 5:”)
leia(numero)
escreva(“O número somado a 5 é: “,numero)
fimalgoritmo
OBS: Não se preocupe, explicarei detalhadamente declaração de variáveis e funções de entrada e saída futuramente.
Abra o editor vim:
# vim
Digite:
/*
Programa: Lê e imprime o nome do usuário
*/
# include <stdio.h>
main ()
{
int num;
printf(“Digite um número inteiro que será somado à 5: \n”);
scanf(“%u”,&num);
num = num + 5;
printf(“O nome do usuário é %u\n”,num);
}
Salve com o nome de programa.c e após sair do editor digite:
# gcc programa.c -o programa
# ./programa
Aqui falarei sobre funções de entrada e saída de dados e estrutura de fluxo em C.
A função printf imprime uma sequência de caracteres na tela.
Para imprimir uma variável, deve informar dos argumentos dentro do texto seguido de vírgula e nome da variável, exemplo:
printf(“%argumento do texto”,variavel);
%d decimal
%o octal
%x hexadecimal
%u decimal sem sinal
%e notação científica
%f ponto flutuante
%c caractere simples
%s cadeia d caracteres
Existem também os argumentos para formatação da impressão, são eles:
\n nova linha
\t tabulação
\b backspace
\” aspas
\\ barra
\f salta formulário
\0 nulo
Função scanf()
A função scanf lê o valor de uma variável. Você deve informar o tipo de variável de acordo com a tabela acima, seguido de vírgula e o nome da variável, exemplo:
#include <stdio.h>
main(){
int a;
char b;
printf(“Digite um número seguido de uma letra: \n”);
scanf(“%d”,&a);
scanf(“%d”,&b);
printf(“Número: %d \t Letra: %c”,a,b);
}
Estruturas de controle de fluxo
As estruturas de controle de fluxo executam um teste lógico e tomam caminhos diferentes para resultados diferentes como verdadeiro ou falso.
sintaxe:
if(condição)comando;
Exemplo:
/*
Programa: Lê números maiores que 5
*/
#include <stdio.h>
main()
{
int a;
printf(“Digite um número maior que 5: “)
scanf(“%d”,&a)
if(a>5) printf(“%d é maior que 5″,a)
}
O else é usado para direcionar o fluxo do código caso o resultado da operação resulte em falso. Exemplo:
/*
Programa: Lê números maiores que 5
*/
#include <stdio.h>
main()
{
int a;
printf(“Digite um número maior que 5: “)
scanf(“%d”,&a)
if(a>5) printf(“%d é maior que 5″,a)
else printf(“Você não digitou um número maior que 5!”)
}
if-else-if
O else if executa um segundo teste lógico caso o primeiro teste lógico seja falso, mas para que o código dentro do else if seja executado ele também deve ser verdadeiro!
Exemplo:
/*
Programa: Lê números maiores que 5
*/
#include <stdio.h>
main()
{
int a;
printf(“Digite um número maior que 5: “)
scanf(“%d”,&a)
if(a>5) printf(“%d é maior que 5″,a)
else if (a=5) printf(“%d é igual a 5″, a)
else printf(“%d é menor que 5″, a)
}
O if também pode ser digitado com conchetes caso sejam utilizados muitos comandos após o if. Exemplo
#include <stdio.h>
main() {
int a;
printf(“Digite um número maior que 5: “);
scanf(“%d”,&a);
if (a>5) {
printf(“%d é maior que 5″, a);
}
else if (a<5) {
printf(“%d é menor que 5″,a );
}
}
O switch testa uma variável com uma lista de caracteres, caso uma das condições sejam verdadeiras ele executará o que está no bloco.
Se nenhuma das coincidências forem verdadeiras o default será executado. A sequência de comandos é executada até que o comando break seja encontrado.
Exemplo:
#include <stdio.h>
main(){
char opcao;
int numero;
printf(“1. Somar com 10\n”);
printf(“2. Subtrair de 20\n”);
opcao=getchar();
switch(opcao)
{
case ’1′:
printf(“Digite seu número: \n”);
scanf(“%d”,&numero)
numero=numero+10
printf(“%d com 10 é igual à: n”,numero);
break;
case ’2′:
printf(“Digite seu número: \n”);
scanf(“%d”,&numero)
numero=20-numero
printf(“20 menos %d é igual à: \n”,numero);
break;
default:
printf(“Opção inválida\n”)
}
Aqui falarei sobre estruturas de repetição em C.
As estruturas de repetição servem básicamente para repitir um bloco de comandos enquanto uma condição for verdadeira ou falsa ou um determinado número de vezes sem a necessidade de reescrever este bloco.
O laço for repete um bloco de comandos até que a condição seja satisfeita. O laço for tem um argumento de incremento ou decremento.
Sintaxe:
for(variavel;condição;incremento)
Exemplo:
Este exemplo imprime números de 0 a 9.
/*
conta de 0 a 9
*/
main()
{
ind int;
for(ind=0;ind<10;ind++)
printf(“Número atual: “,ind) ;
}
O laço for também pode utilizar colchetes para organizar o bloco de código. Exemplo:
/*
conta de 0 a 9
*/
main()
{
ind int;
for(ind=0;ind<10;ind++){
printf(“Número anterior: “,ind-1);
printf(“Número atual: “,ind);
printf(“Próximo número: “,ind+1);
}
}
O while repete um bloco de código enquanto a condição for falsa. A diferença do for é que ele não tem um argumento de incremento e esse argumento deve ser inserido dentro do código, caso contrário o loop será infinito.
Sintaxe:
while(condição){
instrução1;
instrução2;
instrução3;
incrimento;
}
Exemplo:
/*
exemplo de laço while
*/
#include <stdio.h>
main(){
contador int;
contador=0;
while(contador<10) {
print(“A contagem está em “,contador);
// aqui vai o incremento:
contador=contador++;
}
}
Diferente dos dois laços anteriores, o laço do-while executa o código dentro do bloco pelo menos uma vez e ao final da execução é feita a expressão de teste.
Sintaxe:
do {
instrução;
} while(expressão teste);
Exemplo:
/*
Exemplo de laço do-while
*/
#include <stdio.h>
main() {
contador=0
do {
contador=contador+20;
} while(contador<10);
}
Neste caso ele executará pelo menos uma vez o laço, mais não executará a segunda pois será incrementado 20 ao contador na primeira execução do código.
Na última versão, o Ubuntu mudou sua tela de login para o LightDM. Um leve e rápido gerenciador de login baseado em tecnologias web como HTML e CSS! Não só isso, o fato mais interessante sobre o LightDM, é que ele pode ser personalizado de qualquer maneira que você quiser. O truque é saber como fazê-lo e encontrar as ferramentas certas!
Vamos aprender a mudar o fundo da tela de login, usando uma pequena ferramenta chamada “Simple Lightdm Manager”. Tudo que você precisa é uma imagem de fundo do seu gosto! Vamos lá..
Vamos adicionar o seguinte repositório PPA:
sudo add-apt-repository ppa:claudiocn/slm
sudo apt-get updatesudo apt-get install simple-lightdm-manager
Vá ao dash do Unity e procure por Simple Lightdm Manager:
Agora, escolha o background e o logo que você quer aplicar ao seu Ubuntu:
Aplique as alterações e pronto!
Não esqueça de rebootar a máquina para ver as mudanças.
Fonte: techhamlet.com