terça-feira, 31 de janeiro de 2017

Spring MVC sem uso de XML

Fala galera!

Após um período de férias do blog (bem longo por sinal rsrsrs), convido vocês a acompanhar este post, que já faz um bom tempo que queria fazer. Mas agora com o tempo oportuno estou deixando com vocês. Bom, vamos lá!

Spring MVC sem uso de XML


Quando comecei a estudar programação utilizando a linguagem Java, fiquei muito empolgado, pois antes só havia programado utilizando as linguagens C e C++. Confesso que as facilidades que a linguagem proporcionava eram extremamente animadoras - e ainda são.

Porém, com o passar do tempo, percebi que existem alguns frameworks como o Spring, que exigem a configuração utilizando arquivos xml. Era até interessante no começo, mas de acordo que precisava iniciar projetos novos em alguns trabalhos freelancer, vi que estava ficando chato essas configurações.

Bem, com esses "problemas" em mãos resolvi fazer uma pesquisa e encontrei alguns sites que ensinam como organizar seu projeto utilizando o Spring sem o uso de xml. Então, vamos ao código.

Utilizarei o IDE Eclipse Luna com o Spring 4.3.5.

Vamos criar um novo projeto web e configurá-lo para o uso do Maven, onde adicionaremos as seguintes dependências:

        <properties>
  <!-- spring version -->
  <spring.version>4.3.5.RELEASE</spring.version>
 </properties>
 <dependencies>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-core</artifactId>
   <version>${spring.version}</version>
  </dependency>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-web</artifactId>
   <version>${spring.version}</version>
  </dependency>
  <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
   <version>${spring.version}</version>
  </dependency>
 </dependencies>

Agora, no pacote com.deviscoming.config, vamos criar a classe de configuração que será equivalente ao web.xml. Analise o código:


@Configuration
@EnableWebMvc
@ComponentScan(basePackages = {"com.deviscoming"})
public class AppConfig extends WebMvcConfigurerAdapter{
 
 @Bean
 public ViewResolver internalResourceViewResolver(){
  InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
  viewResolver.setPrefix("/WEB-INF/views/");
  viewResolver.setSuffix(".jsp");
  return viewResolver;
 }

}


@Configuration: esta annotation informa ao Spring que a nossa classe AppConfig será a classe de configuração do projeto;

@EnableWebMVC: aqui informamos ao Spring que vamos usar o Spring MVC;

@ComponentScan: para não precisarmos criar nossos beans, o Spring nos fornece esta annotation para fazer todo este trabalho para nós :). Na propriedade basePackges é informado qual pacote do projeto será escaneado pelo Spring. 

Lembram daquele trecho de código que existia no DispatcheServlet?


<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
 <property name="prefix" value="/WEB-INF/views/" />
 <property name="suffix" value=".jsp" />
</bean>

Pois bem, adicionaremos em nossa classe conforme abaixo:

@Bean public InternalResourceViewResolver internalResourceViewResolver(){
  InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
  viewResolver.setPrefix("/WEB-INF/views/");
  viewResolver.setSuffix(".jsp");
       return viewResolver;
}


A classe InternalResourceViewResolver mostra ao Spring onde estão nossas páginas, então instanciamos a classe e 'setamos' o prefixo e sefixo usando os métodos setPrefix() e setSuffix().

Beleza, já temos a primeira classe para executar nosso projeto. Vamos agora criar outra classe no mesmo pacote da AppConfig e nomearemos de WebAppInitializer. Confira abaixo:


public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer{

 @Override
 protected Class[] getRootConfigClasses() {
  return null;
 }

 @Override
 protected Class[] getServletConfigClasses() {
  return new Class[] {AppConfig.class};
 }

 @Override
 protected String[] getServletMappings() {
  return new String[]{"/"};
 }
 
}

Depois estendemos a classe AbstractAnnotationConfigDispatcherServletInitializer e implementamos seus métodos. 

Preste atenção nos métodos getServletConfigClasses() e getServletMappings(). O primeiro você deve informar a classe de configuração, no nosso caso AppConfig.


Pronto! pode executar seu projeto que ele irá funcionar perfeitamente.

É isso aí pessoal, até mais!

;)

terça-feira, 10 de janeiro de 2017

[Debug] Comparar/Listar Strings acentuadas usando Collactor

Fala galera que acompanha o blog...   
   
Quando estamos trabalhando com strings, sempre nos deparamos com problemas clássicos, como por exemplo, comparar strings maiúsculas com minúsculas, acentuadas, com codificação diferente e até mesmo na hora de listar essas strings ordenando de forma crescente ou decrescente e por ai em diante.  
   
[Debug] Comparar/Listar Strings acentuadas usando Collactor


Nesse post eu vou estar ensinando uma forma de comparar strings acentuadas utilizando o Collactor. Acredite ou não, no Java existe uma classe que realiza essa comparação ignorando os acentos.   

Vamos utilizar como exemplo o meu nome Luíz Fágner Zordan, mas é claro que a forma original é sem acento algum. Veja essas premissas:   
 
Luíz Fágner Zordan e Luiz Fagner Zordan são as mesmas pessoas, o que difere são os acentos;   
Luiz Fágner Zordan e LUÍZ FÁGNER ZORDAN são as mesmas pessoas, o que difere são os acentos e as letras maiúsculas;   
Luiz Fágner Zordan e Luiz Vagner Zordan não são as mesmas pessoas;   
   
Veja esse código:   
 
class CollatorEmAcao { 

    public static void main(String[] args) { 

        // Compara Strings, ignorando os acentos 

        String st1 = "Luíz Fágner Zordan"; 

        String st2 = "Luiz Fagner Zordan "; 

        String st3 = "LUÍZ FÁGNER ZORDAN"; 

        String st4 = "Luiz Vagner Zordan"; // Perceba que o nome está escrito errado 
  

        Collator collator = Collator.getInstance (new Locale ("pt", "BR")); 

        collator.setStrength(Collator.PRIMARY);     

        if (collator.compare (st1, st2) == 0) { 

            System.out.println ("Os dois Fagner são as mesmas pessoas, o que difere são os acentos"); 

        } 

        if (collator.compare (st1, st3) == 0) { 

            System.out.println ("Os dois Fagner são as mesmas pessoas, o que difere são os acentos e as letras maiúsculas"); 

        } 

        if (collator.compare (st1, st4) != 0) { 

            System.out.println ("Os dois Fagner não são as mesmas pessoas"); 

        } 

} 



Bom, vimos como comparar strings ignorando os acentos, agora vamos ordenar as strings, ignorando os acentos. Para essa segunda parte vejam o seguinte exemplo:   
 
class CollactorEmAcao{ 

    public static void main(String[] args) { 

        // Ordena String, ignorando os acentos. 

        String[] nomes = { 

            "José Aparecido", 

            "João Simões", 

            "Jó Abedenego"   

        };   

        // Sem o uso de "collator" o resultado deve ser: 

       //  [José Aparecido, João Simões, Jó Abedenego] 

       //  que é o contrário da língua portuguesa 

        SortedSet<String> st1 = new TreeSet<String>(); 

        for (String nome : nomes) { 

            st1.add (nome); 

        } 

        System.out.println (st1); 

        // Usando "collator", o resultado deve ser: 

        // [Jó Abedenego, João Simões, José Aparecido] 

        final Collator coll = Collator.getInstance (new Locale ("pt", "BR")); 

  
        SortedSet<String> st2 = new TreeSet<String>(new Comparator<String>() { 

            public int compare (String s1, String s2) { 

                return coll.compare (s1, s2); 

            } 

        }); 

        for (String nome : nomes) { 

            st2.add (nome); 

        } 

        System.out.println (st2); 

    } 

}

Sem o uso do Collactor, não é respeitada as normas corretas de ordenação, por isso a ordenação acaba ficando "errada".

É isso ai pessoal, até a próxima

quinta-feira, 22 de dezembro de 2016

[JAVA] Anotação @Override

Fala galera que acompanha o blog...

Resolvi criar esse post especificamente sobre a Annotation @Override, pois é uma anotação muito comum quando estamos trabalhando com Orientação a Objetos e muita gente usa sem saber o porque de estar usando. Normalmente depois de uma refatoração o sistema para de funcionar, as vezes com umas mensagens estranhas. Então vamos entender o que acontece "por baixo dos panos".



Para início de conversa, a anotação @Override é uma forma de garantir que você está sobre escrevendo um método na super classe, e não criando um novo método.

Vamos ter como exemplo essa "Super" classe: 

public class SuperClasse {
    public void showMe() {
      System.out.println("Estou aqui SuperClasse");
    }
}

Certo, temos a nossa classe SuperClasse, que possui o método showMe(), que escreve uma mensagem no console.

Criamos uma nova classe (NovaClasse) no nosso projeto que estende a classe SuperClasse, e você gostaria de sobrescrever o método showMe(), pois é necessário que seja apresentado uma outra mensagem.  Então temos a seguinte classe:

public class NovaClasse extends SuperClasse {
       public void showMe() {
           System.out.println("Eu sou a NovaClasse");
       }
}

Perfeito! Acabamos de sobrescrever o método showMe(), da nossa SuperClasse e em momento algum usamos a anotação @Override e esse código funciona perfeitamente. Mas,  um amigo no projeto que você trabalha resolveu mudar o nome do método da sua classe SuperClasse de showMe() para showMessage().

E ai, percebeu o problema?

Nesse momento o seu projeto possui 2 métodos distintos:
SuperClasse possui o método showMessage();
NovaClasse possui o método showMe();

Se seu amigo, ou até mesmo você em uma fatoração, que seja, não se lembrar da sua classe NovaClasse que estendeu SuperClasse, que sobrescrevia um método dela... você terá um método que não está sobrescrevendo coisa nenhuma!

Mas, e se você tivesse usado a anotação @Override?

public class SuperClasse {
    public void showMe() {
       System.out.println("Estou aqui SuperClasse");
    }
}

public class NovaClasse extends SuperClasse {

  @Override
  public void showMe() {
     System.out.println("Eu sou a NovaClasse");
  }

}


Até aqui tudo certo. Mas, quando seu amigo, ou você, resolver mudar o seu método de showMe() para showMessage(), o seu código não irá compilar, pois o @Override vai perceber que não está sobrescrevendo coisa nenhuma, por não vai existir um método showMe() na classe SuperClasse() e vai te mostrar uma mensagem com de erro:

NovaClasse() must override or implement a supertype method


Dessa forma deverá ser alterar o nome do método da classe NovaClasse() também para showMessage(), para que o código volte a funcionar perfeitamente. Assim, o @Override acaba servindo como um lembrete.

Bom pessoal, um post básico, mas muito importante pra quem trabalha com Orientação a Objetos, esse exemplo foi para a linguagem JAVA, mas vários outras linguagens OO possuem a sua forma de anotação de sobrescrita, especificamente o JAVA, optou por @Override.

Até a próxima.

segunda-feira, 12 de dezembro de 2016

[Debug] Reordenar um elemento dentro do Array com AngularJS

Fala galera que acompanha o blog... 

Esse post mesmo sendo voltado para AngularJS, adaptado pode ser utilizado para várias outras linguagens. 



O problema era o seguinte, ao implementar um chat, tenha em mente o WhatsApp, ao receber uma nova mensagem a sua lista de conversas são reordenadas, com esse contato que te mandou uma nova mensagem ficando no topo da lista de conversas. 

Quando estou trabalhando com AngularJS costumo utilizar a biblioteca Lodash, que facilita bastante o trabalho. 

Bom a solução para o problema mencionado foi o seguinte: 

$scope.setGroup = function(group) {

        moveElementArray($scope.chatList, _.indexOf($scope.chatList, group), 0);

 }; 


function moveElementArray(arrRef, fromIndex, toIndex) {

        var element = arrRef[fromIndex];

        arrRef.splice(fromIndex, 1);

        arrRef.splice(toIndex, 0, element);

 }

Onde: 
  • setGroup() é o método que eu chamo da minha página enviando group como parâmetro; 
  • group é o parâmetro (um Objeto) que representa uma conversa dentro da minha lista de conversas; 
moveElementArray() é uma função que recebe 3 parâmetros: 

  • lista de conversas; 
  • O index do meu objeto atualmente dentro da lista de conversas; 
  • 0 que é a primeira posição de um array. 

Dessa forma eu recupero o meu objeto dentro o array e reposiciono ele na primeira posição. Importante deixar claro que o trecho _.indexOf($scope.chatList, group), é a biblioteca Lodash me auxiliando, se você olhar a documentação vai ver que é possível realizar busca binária adicionando mais um parâmetro nessa função.  

Eu tentei deixar mais genérica possível a função moveElementArray para que eu possa utilizar diversas vezes de qualquer parte do meu código e resolvi compartilhar essa função simples, pois trabalhar com array é bastante comum e vai acabar me servindo de "cola" para outros projetos em que estiver trabalhando rs 

É isso ai pessoal, até a próxima!

sexta-feira, 9 de dezembro de 2016

[Debug] Remover acentos utilizando Normalize

Fala galera que acompanha o blog...

Estava criando uma classe de utilitários, que logo pretendo disponibilizar aqui no blog, e acabei encontrando uma forma muito elegante de remover acentos de uma string utilizando o Normalize.




Se você pesquisar algo como "como remover acentos de uma string", vai perceber que existem diversas formas de faze-lo, usando arrays, mapa de caracteres, usando a biblioteca Apache Commons Lang, replaceAll com regex, indexOf() e várias outras formas. No entanto a classe Normalize, foi a que me chamou mais atenção, veja o código abaixo:

package com.devic.main;
import java.text.Normalizer;
public class Main {

 public static void main(String[] args) {
 String entrada = "çÇáéíóúýÁÉÍÓÚÝàèìòùÀÈÌÒÙãõñäëïöüÿÄËÏÖÜÃÕÑâêîôûÂÊÎÔÛ";
 System.out.println(Normalizer.normalize(entrada, Normalizer.Form.NFKD).replaceAll("\\p{InCombiningDiacriticalMarks}+", ""));
 }
}

Saida:

cCaeiouyAEIOUYaeiouAEIOUaonaeiouyAEIOUAONaeiouAEIOU

Bonito, não?

Esse trecho de código possui duas etapas:

  • Normalizar a nossa string seguindo o tipo de normalização enviado como parâmetro;
  • Realizar o replace de todos os caracteres normalizados para a sua forma normal.
Vamos ver outro código para entender melhor o que está acontecendo:

String entrada = "aáeéiíoóöőuúüű AÁEÉIÍOÓÖŐUÚÜŰ";
for (int i = 0; i < entrada.length(); i++) {
 
  // nos iremos escrever cada caracter separado, para visualizar melhor como ele funciona
  String texto = original.substring(i, i + 1);
 
  // realizando a normalização
  String decomposto = Normalizer.normalize(texto, Form.NFD);
  // removing diacritics
  String removido = decomposto.replaceAll("\\p{InCombiningDiacriticalMarks}+", "");

 System.out.println(texto + " (" + asHex(texto) + ") -> "
 + decomposto + " (" + asHex(decomposto) + ") -> "
 + removido + " (" + asHex(removido) + ")");
}


E a saída, ficará assim:

a (0061     ) -> a (0061     ) -> a (0061     )

á (00e1     ) -> á (0061 0301) -> a (0061     )

e (0065     ) -> e (0065     ) -> e (0065     )

é (00e9     ) -> é (0065 0301) -> e (0065     )

i (0069     ) -> i (0069     ) -> i (0069     )

í (00ed     ) -> í (0069 0301) -> i (0069     )

o (006f     ) -> o (006f     ) -> o (006f     )

ó (00f3     ) -> ó (006f 0301) -> o (006f     )

ö (00f6     ) -> ö (006f 0308) -> o (006f     )

ő (0151     ) -> ő (006f 030b) -> o (006f     )

u (0075     ) -> u (0075     ) -> u (0075     )

ú (00fa     ) -> ú (0075 0301) -> u (0075     )

ü (00fc     ) -> ü (0075 0308) -> u (0075     )

ű (0171     ) -> ű (0075 030b) -> u (0075     )

  (0020     ) ->   (0020     ) ->   (0020     )

A (0041     ) -> A (0041     ) -> A (0041     )

Á (00c1     ) -> Á (0041 0301) -> A (0041     )

E (0045     ) -> E (0045     ) -> E (0045     )

É (00c9     ) -> É (0045 0301) -> E (0045     )

I (0049     ) -> I (0049     ) -> I (0049     )

Í (00cd     ) -> Í (0049 0301) -> I (0049     )

O (004f     ) -> O (004f     ) -> O (004f     )

Ó (00d3     ) -> Ó (004f 0301) -> O (004f     )

Ö (00d6     ) -> Ö (004f 0308) -> O (004f     )

Ő (0150     ) -> Ő (004f 030b) -> O (004f     )

U (0055     ) -> U (0055     ) -> U (0055     )

Ú (00da     ) -> Ú (0055 0301) -> U (0055     )

Ü (00dc     ) -> Ü (0055 0308) -> U (0055     )

Ű (0170     ) -> Ű (0055 030b) -> U (0055     )


É isso ai pessoal, espero que tenham gostado e que seja bastante útil ai no projeto de vocês.

Até a próxima!

quarta-feira, 23 de novembro de 2016

[JAVA] Encapsulamento | Modificadores de acesso

Fala galera!

Em uma das noites de desenvolvimento, me peguei pensando: "Por que não fazer um post falando um pouco sobre encapsulamento?". Para quem está iniciando na área de programação ou até mesmo quem já está um tempinho na área, pode acontecer de ter uma dúvida de como funciona ou quando utilizar. Então nesse post, vou tentar passar o que tenho de conhecimento e mais uma boa parte de pesquisas. Vamos lá!



Afinal, o que é encapsulamento? 


É um dos principais conceitos da orientação a objetos. Seu objetivo é organizar os dados relacionados, formando grupos em objetos(classes). Assim, mantém a legibilidade de um programa com milhares de linhas e também o torna fácil de trabalhar e fazer manutenções. Entende-se também por encapsulamento, a proteção da integridade da classe escondendo informações e disponibilizando somente o preciso para usar a classe. Mas lembre-se, para manter a qualidade do projeto, é necessário ter o baixo acoplamento entre as classes e o encapsulamento ajuda a manter esta característica.

Modificadores de acesso


Como o nome diz, os modificadores de acesso são utilizados para os componentes da aplicação acessíveis ou não por outras partes. Além disso, são divididos em dois níveis no encapsulamento:
  • Nível de classe: public ou package-private (default);
  • Nível de membro: public, private, protected ou package-private (default).

public

Talvez ao ler a palavra public, claramente você pensou em público. E esse é, vamos dizer assim, a ideia desse modificador. Permite que qualquer componente da classe seja acessada por outra.

protected

Esse modificador já é um pouco mais restritivo. Os componentes da classe que são protected, podem ser acessados por classes/interfaces que estão no mesmo pacote. Em caso de classes derivadas, pode ser acessado mesmo estando em pacotes diferentes.

package-private (default)

Quando não definimos um modificador de acesso a um componente, ele assume o modificador package-private (default/padrão). Neste caso, os componentes da classe só podem ser acessadas por outras que estão no mesmo pacote independente se a classe é derivada ou não.

private

O modificador private só permite que o componente seja visível somente pela própria classe. Dessa forma, podem existir classes no mesmo pacote ou em outros, podendo ser classes derivadas ou não, tudo que estiver com o modificador private não estará acessível.


Bom galera, espero que tenham curtido mais esse post. Encapsulamento é algo importante para se aprender, pois é fundamental para linguagens baseadas no paradigma da orientação a objetos.

Até mais!

;)

Fonte: 
            TI Expert
             Equipe.nce.ufrj.br
            High5Devs

quinta-feira, 17 de novembro de 2016

[MucilaCast - 003] Internet sua linda

Fala galera que acompanha o blog...

Mais um episódio do MucilaCast, com o tema "Internet sua linda". Nesse episódio falamos sobre os primeiros sites que acessávamos na internet, várias coisas curiosas que existem pela internet, principalmente uns sites, podemos dizer, bizarros que existem nessa internet maravilhosa rs


[MucilaCast - 003] Internet sua linda


Falamos também sobre algumas redes sociais e principalmente dos programas de chats utilizados antigamente, como o grande ICQ, famoso pelos seus jogos fodas, também falamos do maravilhoso MSN Messenger, muito utilizado para indiretas utilizando o campo de status e é claro que não podia faltar o famoso chat da UOL (quer TC? kkk) e diversos outros assuntos que com certeza você deve ter utilizado ou vivenciado.
Não se esqueça de deixar nos comentários, algum outro site que você acessava antigamente e do que você sente mais saudade... 



Participação:
  • Felipe Pereira de Souza;
  • Luiz Fagner Zordan;
  • Renan Rodrigues Ramos.
Música e efeitos:

As músicas utilizadas nesse podcast foram obtidas através do YouTube:
    Capa: Fagner Zordan
    Edição: Renan Rodrigues Ramos

    É isso pessoal, até a próxima!

    quarta-feira, 16 de novembro de 2016

    Uowww 10000 visualizações

    Fala galera que acompanha o blog...

    E mais uma vez: "Vocês são demais rs"!
    Depois de exatos 9 meses e aproximadamente 270 dias chegamos a marca das 10 mil visualizações!!!


    Uowww 10000 visualizações

    Atualmente o blog possui quase 150 posts, sobre diversos assuntos, clique aqui para entender como nossos posts são organizados, o que gera aproximadamente 1200 visualizações por mês *-*

    Começamos um canal de podcast, MucilaCast, que foi fundamental para a quantidade de visualizações que o blog possui. Se você não conhece nosso canal pode acessar esse link aqui e acompanhar todos os nosso episódios. Estamos com uma lista de novos episódios para serem gravados e vários deles com convidados, continue nos acompanhando para não perder nenhum episódio rs

    Muito obrigado por acompanhar o nosso blog, obrigado pelos feedbacks, pelas mensagens com sugestões de novos posts.

    É isso ai pessoal, até a próxima!


    AEWWWWW

    sábado, 12 de novembro de 2016

    Sobre AngularJS #001

    Fala galera que acompanha o blog...

    Se você trabalha com desenvolvimento de aplicações web, principalmente com a parte front-end de um sistema, já deve ter pelo menos ouvido falar do "queridinho" AngularJS, ou para os íntimos Angular.

    AngularJS é um framework JavaScript open-source que Segue o padrão MVW (model, view e whatever rs), posteriormente foi considerado MVC, MVP, MVVM da engenharia de software, foi contribuído sobre a crença de que a programação declarativa é melhor do que a programação imperativa quando se trata da construção de interfaces com o usuário, enquanto a programação imperativa é excelente para escrita de regras de negócio.


    Sobre AngularJS #001

    A sua principal característica é com certeza a "Ligação bidirecional de dados" (Two-way data binding). Essa característica reduz a quantidade de códigos escritos para mostrar os dados processados pelo servidor. A variável $scope do Angular detecta mudanças no modelo e modifica o HTML na view por meio de um controller. Da mesma forma, qualquer alteração da view é refletida no model. Vamos perceber essa característica quando começarmos a implementar alguns exemplos.

    Ahhh! E é claro, não poderia de deixar de dizer, que o framework é mantido pelo Google rs



    Para compreender um pouco sobre a popularidade do framework, basta pesquisar pela palavra "Angular" no YouTube e verificar os mais de 424.000 resultados (aproximadamente) que são apresentados. E não é só isso!


    Ao acessar o repositório do Angular no GitHub você se depara com mais de 53 mil estrelas, aproximadamente mil contribuintes e mais de 200 mil repositórios com scripts que utilizam o framework.

    Nos próximos posts vou mostrar alguns exemplos básicos de Angular, explicando as diretivas, expressões, filtros, modulos, formulário, validações e várias outras coisas bem legais.

    É isso pessoal, até a próxima!

    segunda-feira, 31 de outubro de 2016

    [MucilaCast Especial - 001] Dia das Crianças

    Fala galera que acompanha o blog...

    E nesse mês de Outubro é comemorado um dia muito divertido e alegre não só para as crianças mas pra muitos "barbudos" por ai rs


    DIA DAS CRIANÇAS UHUUUUU

    É aquele dia especial onde a criançada pode tomar sorvete, ganha aquele presente divertido e pode jogar 2 horas seguidas de vídeo game eee os marmanjos aproveita a festa pra "levar a criançada pra passear" e volta a ser criança e se divertem muitoo juntos.

    E não podemos nos esquecer das famosas frases "vou contar até 3... 1, 2", "se eu ouvir um pioo..." piuuu , "aiii se eu for ai e achar...", "vou chamar seu pai..." e várias outras frases lindas e são fundamentais pra uma boa educação rsrs

    E para comemorar esse dia, fizemos nosso primeiro episódio "MucilaCast Especial", onde vamos falar sobre os tempos de crianças, das brincadeiras, as artes e vários outros assuntos saudosos.

    [MucilaCast Especial - 001] Dia das Crianças

    Para esse episódio, convidados um amigo paraibano, que nasceu em Patos na Paraíba... Rafael Araujo Ôxiiiii!
    Rafael foi nosso primeiro convidado para gravar um episódio e foi bastante interessante. 

    Comparamos os nomes das brincadeiras de Minas com os da Paraíba, e confesso que o nome de lá são mais complicados rs


    Ahhh e deixa nos comentários o que você tem mais saudade de quando era criança, o objeto mais interessante que você tomou um coro ou alguma historia pra lermos aqui no próximo episódio.

    Faça o download ou ouça em seu navegador:

    Participação:
    • Felipe Pereira de Souza;
    • Luiz Fagner Zordan;
    • Renan Rodrigues Ramos.
    • [Convidado] Rafael Araújo
    Música e efeitos:

    As músicas utilizadas nesse podcast podem ser encontrados nos endereços:

    - DanoSongs
    • Crazy from the Message;
    • Great World;
    • Heart Quake.
    • The impossebulls - 5 x 5.
    • Get The Flow
    • Zoosters

    Capa: Luiz Fagner Zordan
    Edição: Felipe Pereira de Souza

    É isso pessoal, até a próxima!