Durante esse desafio, conhecemos Vanessa Tonini, uma front-end developer gaúcha, que mora em Londrina (PR), e que está acabando sua pesquisa de pós-graduação em UX. Conversamos com ela e descobrimos mais sobre o seu trabalho e como foi participar do desafio que envolvia a responsabilidade de ser avaliada por quem criou a tecnologia que ela estava usando.

Vanessa tem apenas 23 anos, mas é bem ativa na comunidade do Magento, a plataforma em que é especialista, e que a inspirou a fazer seu curso de pós-graduação. Ela também está começando a colaborar com a W3C em alguns workgroups, e além de estudar, ela é desenvolvedora da Ilegra, empresa de Porto Alegre. Em 2010 ela soube da conferência anual da w3c Brasil, a WebBr, e acabou vindo participar no ano seguinte -  momento em que conheceu Reinaldo Ferraz, com quem só falava por Twitter.

O objeto da sua pesquisa é acessibilidade em e-commerces brasileiros. “Sempre tive admiração pelo trabalho da W3C em se empenhar em fazer a web acessível para todas as pessoas. Me identifico com os objetivos“, ela contou quando perguntei como ela se interessou pelos projetos realizados pela organização, cujo trabalho ela conheceu no primeiro ano de faculdade.

Ela foi uma das poucas a encarar o desafio do Bert Bos, e gostou do resultado final do seu projeto. “Comecei no sábado de manhã, e tive pouco tempo para desenvolver. No fim, fazer o tabuleiro em si foi bem rápido e fácil, o desafio estava em colocar graça no visual e fazer as peças – sempre usando as novas features de background. Fiz uma variação de cores para imitar textura de madeira, usando background-color normal com linear-gradient. Não houve grandes problemas com cross-browser, usei somente web-kit. Mesmo usando as coisas mais modernas, segui os padrões recomendados e isso evitou maiores problemas.” No final, seu projeto entrou na galeria do site do evento, e ela nos contou que gostaria de ter feito seu tabuleiro de modo que se ajustasse em outros dispositivos também, aplicado conceitos de responsive design antes de entregar o css, mas não deu tempo.

Quando perguntada como lida com a maioria esmagadora de homens na área, Vanessa respondeu sem pensar duas vezes “Não me sinto intimidada, me sinto estimulada“, declarando que sabe que existe preconceito, mas o encara da melhor forma possível. Ela ainda contou que nos momentos em que se sobressai aos colegas em algum assunto, sempre tenta deixar claro que todos são iguais e um sempre pode aprender com o outro.

Uma das pessoas que serve de inspiração para Vanessa, é a Martha Gabriel. “Conheci ela quando ainda não era popular, em um evento. Queria ser igual a ela, apesar de ela ser da área de social media analysis, eu admirei seu trabalho e o jeito que ela se vestia – muito alternativo em comparação às outras pessoas da área, com aqueles saiões“. Outra que ela citou foi a própria Yasodára Córdova, do W3C Brasil, “Fiquei fascinada com as coisas que ela já fez, é um exemplo a ser seguido“. Além disso, outra mulher da W3C também chama a atenção de Vanessa: Lea Verou. “Vou no Front in Sampa por causa da presença dela, em setembro. Quando a conheci, fiquei pensando em até onde as mulheres poderiam chegar. Gostaria de chegar no nível dela até fazer 30 anos. Haha.“.

No final da entrevista, perguntei para ela qual a mensagem que ela gostaria de deixar para novas desenvolvedoras, que estão chegando na área agora. “Acostume-se com os homens. Somos minoria nessa área, mas ainda vamos conquistar nosso espaço. A web é para todos, inclusive para as mulheres“.

Vanessa Tonini

A Vanessa escreve no MageFront, um blog sobre dicas de desenvolvimento front-end focado em Magento. Ela também mantém seu GitHub com projetos que surgem de vez em quando, e pretende começar a colaborar com seus forks logo.

O post Cobertura WWW2013 – Conversando com Vanessa Tonini apareceu primeiro em .

Simples utilização

# lsof

Listando todos os arquivos abertos com os seguintes campos: Command, PID, USER, FD, TYPE etc.

Visualizando conexões de rede abertas

# lsof -i -n

O comando acima exibe uma lista de todas as conexões de rede abertas.

Somente conexões de rede tcp

# lsof -i tcp -n

Restringindo a saída para apenas conexões UDP:

# lsof -i udp -n

Utilizando juntamente com o grep

# lsof -i -n -P | grep sendmail

Outra forma de utilizar o lsof é especificar o soquete de comunicação que deve ser “pesquisado”. Por exemplo, para verificar qual processo está “escutando” na porta 22, execute:

# lsof -n -P -i:22

Com isso, demos nosso pontapé inicial para dissecarmos e agregarmos conhecimento dessa ferramenta interessante.

Não perca os próximos capítulos, até breve!

O post Exemplos de utilização do comando lsof – Parte 01 apareceu primeiro em .

Muitas pessoas perdem informações importantes devido ao fato de terem apenas copiado o código de acompanhamento do Google Analytics em seu template, perdendo algumas funcionalidades muito interessantes Analytics. Para ajudar os gestores de sites WordPress, a Yoast de  Joost de Valk desenvolveu o plugin Google Analytics para WordPress. Vamos verificar que informações são essas que o plugin pode adicionar ao Google Analytics?

Informações básicas de tráfego

Para quem só deseja informações básicas sobre o tráfego do seu site, o trabalho com esse plugin é mínimo. Veja como é simples interligar o seu Google Analytics ao seu site WordPress com o uso desse plugin:

O plugin oferece a integração através da autenticação do seu login e senha do Google. Já tive alguns sites que apresentaram problemas com essa autenticação, mas a situação é facilmente contornada com a opção “Manualy enter your UA code”, permitindo que você insira manualmente a ID do perfil do Google Analytics que deseja associar.

Existe uma opção que permite ao plugin inserir automaticamente o código de monitoramento do Analytics no cabeçalho de seu template, possibilitando o carregamento do código em todas as páginas do site. Não vejo por que não selecionar essa opção para optar por inserir manualmente esse código, por isso deixe essa opção como default.

Pelo que é dito na documentação, e confirmei pelo código fonte da página, o plugin utiliza as alterações que foram feitas no código de monitoramento para o Google Analytics, permitindo usufruir das novidades da ferramenta nesta última atualização, assim como nas futuras, sem que você precise ficar renovando o código em seu template.

Vamos verificar o restante da configuração, que lhe oferecerá uma série de informações valiosas para a sua gestão de conteúdo, tais como rastreamento de cliques em links internos e externos, downloads de arquivos e variáveis personalizadas que o Google Analytics permite que você defina.

Informações avançadas de tráfego

O Analytics oferece informações detalhadas sobre ações que podem influenciar a sua estratégia de conteúdo, mas para tal é preciso fazer algumas configurações complicadas em seu site, mas que com o uso do Plugin Google Analytics para WordPress da Yoast é tudo muito mais simples. Vejamos:

Track outbound clicks & downloads

Com essa opção ativada, você poderá monitorar com os relatórios do Google Analytics os cliques e os downloads realizados em seu site como eventos.

Onde encontrar esta informação no Analytics: Conteúdo » Eventos

Como usar essa informação: Você pode monitorar os downloads de arquivos como e-books ou ainda monitorar qual é a página que mais atrai clientes às páginas de produtos até a venda em seu site.

Veja abaixo como serão apresentadas as informações ativadas:

Opção “Show advanced settings”

Marque esta opção para ativar as configurações de Variáveis Personalizadas e configurações Avançadas do plugin.

Configuração de Variáveis Personalizadas:

As variáveis personalizadas do Google Analytics lhe permitem visualizar informações adicionais em três níveis: no nível de página, no nível de usuário e no nível de “sessão”. Assim, podemos monitorar essas informações adicionais, juntamente com as informações básicas do Analytics – por exemplo, o nome do autor, possibilitando visão de estatísticas do seu site por autor.

O Google Analytics permite que você defina até cinco variáveis personalizadas. Para acessar essas estatísticas, siga o seguinte caminho no seu perfil do Analytics: Público Alvo > Personalizado > Variáveis personalizadas.

Veja abaixo como o plugin pode ajudar a analisar algumas das variáveis disponíveis:

• Logged in Users: permite identificar o tipo do usuário que está visitando o site (há uma opção avançada para ignorar os usuários de um determinado nível).
  Como usar: para sites que precisam monitorar o tráfego de usuários de diversos níveis de acesso como assinantes, autores, administradores, editores etc., e é muito útil em sites BuddyPress.
• Post Type: permite que você veja as estatísticas separadamente em artigos, páginas ou outro tipo de página que você tenha.
  Como usar: analisar as visitas às páginas de artigos (informação) e às visitas em páginas estáticas (conversão);
• Author Name: permite que você veja as estatísticas por autor.
  Como usar: ideal para quem precisa analisar o tráfego gerado para cada autor de artigos.
• Tags: permite que você veja as estatísticas por tags usando segmentos avançados do Google Analytics.
  Como usar: caso você prefira usar taxonomia para analisar uma determinada preferência de seus visitantes por determinado assunto.
• Publication year: permite que você veja as estatísticas por ano de publicação, mostrando-lhe se os seus artigos antigos ainda no tráfego.
  Como usar: caso você prefira usar categorias para analisar uma determinada preferência de seus visitantes por determinado assunto.
• Single Category: permite que você veja as estatísticas por categoria, funciona melhor quando cada artigo é colocado em uma categoria apenas.
  Como usar: caso você prefira usar categorias para analisar uma determinada preferência de seus visitantes por determinado assunto.
• All Categories: permite que você veja as estatísticas por categoria usando segmentos avançados; deve ser usado quando você utiliza várias categorias por artigo.
  Como usar: caso você prefira usar categorias para analisar uma determinada preferência de seus visitantes por determinado assunto.

Configurações avançadas

Uma opção interessante para filtrar as estatísticas de seu site, ignorando tráfego de administradores, editores, ou até mesmo todos os usuários logados. Quanto ao monitoramento de downloads sobre o qual falamos no início, a configuração “Extensions of files to track as downloads” é onde você informa as extensões dos arquivos que deseja monitorar.

Outra configuração importantes é a ativação do “Track AdSense”, mas para isso você precisa ter vinculadas as contas de Adsense e Analytics. Você pode optar por analisar também o tráfego vindo do Feed do seu site; para tal, basta ativar a opção “Tag links in RSS feed with campaign variables”. Mas, atenção, não marque essa opção caso você utilize o FeedBurner.

Ative a opção “Add tracking to the comment forms”, caso seja relevante controlar o tráfego nos links dos comentários do seu site. Essa informação só será relevante quando você tiver uma grande quantidade de comentários por página. As outras opções não devem ser usadas para monitoramento de sites, exigem conhecimentos avançados e podem gerar uma grande confusão nas estatísticas do seu sites caso algo seja feito de errado.

Conclusão

Se você já analisa o tráfego do seu site com o Google Analytics, agora você sabe como ter mais informações sobre os hábitos dos seus visitantes. Não se esqueça de deixar seus comentários depois que começar a receber informações que permitam que você melhore a estratégia de conteúdo online.

Abraços!

O post Guia definitivo do plugin Google Analytics para WordPress apareceu primeiro em .

O caso é da ZocPrint, uma loja online de impressos e presentes personalizados.

Herbert Fischer, CTO da ZocPrint, nos conta abaixo como usa a nuvem da AWS:

“A Zocprint é uma loja online de impressos e presentes personalizados, desde cartões de visita até capas de smartphones. Temos um catálogo de mais de seis mil designs prontos para o cliente escolher e personalizar. Hoje temos cerca de 30 colaboradores e nossa sede está localizada em São Paulo.

Atualmente, utilizamos AWS para hospedar toda a infraestrutura da loja online e sistemas de backoffice. Antes de migrarmos para o AWS, o site era hospedado num colocation de um provedor americano, onde a prioridade era o custo baixo. Este provedor estava passando por vários problemas de estabilidade em sua rede, ao mesmo tempo que a Zocprint estava buscando melhorar a performance de acesso ao site pelos nossos clientes, problema que poderia ser mitigado com a migração do site para um datacenter no Brasil. Ao tentar aliar esta migração para o Brasil com a preocupação em manter custos, nossa melhor alternativa foi o AWS, onde pudemos trazer o site para o Brasil e utilizar os recursos para crescer ou reduzir a infraestrutura de acordo com a demanda variável de cada dia. Outro ponto importante é que um dos nossos desafios técnicos é a grande quantidade de imagens com que temos que lidar e o uso de storage compartilhado para isso estava se tornando dispendioso no dia-a-dia. Para solucionar este problema, adotamos o S3 com sucesso e hoje não temos mais que nos preocupar com isto.

Eu já possuia alguma experiência com AWS de quando trabalhei em outra empresa e vi o AWS como a oportunidade ideal para startups como a Zocprint. Atualmente, não temos nenhuma outra alternativa além do AWS, que possua datacenter no Brasil, uma API estável, bastante difundida e que possibilite automação e custos acessíveis. Do ponto de vista do negócio, o elemento mais importante foi a melhoria de performance do acesso ao site à um baixo custo, sob demanda e sem custos de aquisição. Do ponto de vista técnico, foi a possibilidade de automatizar quase que todo o processo de manutenção da infraestrutura, termos agilidade para atender picos de tráfego e simplificar a operação do site ao delegar para a AWS a operação de alguns dos componentes da arquitetura.

Atualmente utilizamos os seguintes serviços da Nuvem da Amazon: EC2, EBS, ELB, Route53, RDS, S3, IAM, SES e SNS. Usamos tecnologias como Ubuntu Server Linux, PHP, Puppet, Nginx, Solr, Fabric, Graylog e NewRelic.

A primeira etapa do processo foi definida pelos testes de performance da plataforma sendo executada no AWS. Efetuamos testes com a arquitetura antiga que envolvia o uso de um storage compartilhado. Durante os testes resolvemos adotar o S3 como substituto para o storage compartilhado, implementando uma camada lógica de content-addressable-storage entre a aplicação e o armazenamento dos arquivos, com abstrações para um storage compartilhado e para o S3, desta forma simplificando o processo de migração. Esta alteração na arquitetura do site levou cerca de cinco semanas para ser executada.

Com tal alteração e testes de performance aprovados, iniciamos a etapa de implementação da infraestrutura. Efetuamos todo o mapeamento da instalação e configuração de todos os componentes da arquitetura no Puppet, utilizando um modelo masterless para evitar que um possível servidor puppet seja um ponto único de falha. Também refizemos a automação do processo de deploy para algo compatível com a arquitetura no AWS, utilizando Fabric e Boto. O processo de automação da infraestrutura e migração levou cerca de 5 semanas para ser executada.

Com a utilização do AWS e toda automação envolvida, pude eliminar os gastos com operação terceirizada da infraestrutura e trazer as tarefas remanescentes como parte do trabalho da equipe atual. Economizamos cerca de 80% do custo mensal. Além disso reduzimos o número de problemas e quedas de serviços. Outro ponto que analisamos durante nossa avaliação foi a latência. Considerando-se a comunicação entre nossa solução nos datacenters da AWS em São Paulo e um computador na região de São Paulo, a queda foi de cerca de 170ms, principalmente porque migramos para um datacenter no Brasil”.

E este foi mais um estudo de caso de uso da Nuvem da AWS. Aproveite para também contar sua estória para nós, entre em contato conosco!

O post Estudo de Caso AWS: ZocPrint – Loja online de impressos e presentes personalizados apareceu primeiro em .

Mas quem é o novo consumidor?

O novo consumidor é  um pessoa resultante da convergência entre online e offline. É um “consumidor centauro”, não se considera um e-consumidor, tampouco pode ser classificado como um consumidor tradicional. São pessoas que buscam exclusividade e personalização, mas também compram produtos de prateleiras. Querem interação social, participam de comunidades virtuais, mas não deixam de se encontrar com os amigos em locais físicos. Desejam opções variadas de canais para comprar, têm sede por competitividade de valor e utilizam diferentes meios para obter informações e tomar melhores decisões.

Voltando ao marketing de convergência

Esse novo consumidor, que caminha com pés rápidos nas novas tecnologias mas ainda possui o antigo e imprevisível coração humano, abre várias e novas oportunidades de crescimento, isso porque mercados antes esquecidos ou considerados impossíveis agora são acessíveis, pois não há limite de distância para a Internet.

O marketing de convergência visa à união do online e offline, do emocional com o racional, da comunicação via Web com a física. Por isso, propõe uma nova estrutura do mix de marketing.

• Convergência na customização

O cliente pode participar do planejamento, da elaboração dos produtos, deixando-os customizados, os clientes ainda podem construir seus próprios produtos.

• Convergência de comunidades

O cliente híbrido valoriza relacionamentos interpessoais, tanto no mundo virtual quanto no real, e pode fazer comunidades do modo que mais desejar. As redes sociais são a prova disso.

• Convergência dos canais

Os clientes querem se conectar às empresas em todos os canais, e serem reconhecido por conectarem-se em canais múltiplos.

• Convergência de valor competitivo

É o cliente quem faz a relação valor x preço do produto. Como ele tem esse poder, é preciso ter certeza de que deseja  ter a experiência de compra.

•  Convergência de escolha

As empresas precisam oferecer ferramentas que disponibilizem as informações suficientes para o cliente tomar a decisão de compra.

Esses pontos mostram o que o novo consumidor centauro busca agora com mais poderes e cada vez mais autonomia no processo da compra. Basta a cada empresa se adequar a essas novas exigências ou serem moldadas pelo mercado.

O post O marketing de convergência apareceu primeiro em .

O evento contou com cerca de 500 atividades e todas de que participei foram interessantes e geraram debates produtivos. Na terça-feira, 14 de maio, participei de uma oficina tutorial sobre CSS3 com o Bert Bos, um dos criadores do padrão CSS. Como o conheci pessoalmente, não podia perder a oportunidade de fazer uma entrevista com ele sobre algumas questões sobre as quais tenho curiosidade, como: o contexto que o levou a trabalhar nos primeiros rascunhos do padrão CSS, o que ainda falta ser aprimorado e a sua perspectiva para a evolução do CSS e do HTML em longo prazo.

Confira a entrevista completa abaixo:

Versão em inglês aqui.

1. Quais eram as necessidades específicas e o contexto que o levaram a trabalhar nos primeiros rascunhos do padrão CSS ?

Quando Tim Berners-Lee criou seu primeiro navegador Web, este possuía folhas de estilos, mas apenas para o usuário. A ideia era que o autor especificasse o conteúdo de um documento, mas que o navegador junto com o usuário determinassem como melhor exibi-lo.

Durante certo tempo, esse foi o modelo, afinal de contas, o usuário é quem melhor sabe qual tipo de tela ele tem, de quais cores ele gosta mais, o quão grande são as janelas em seu sistema. Foram criados diversos outros navegadores que permitiam ao usuário configurar a exibição do conteúdo, como o Viola e o Mosaic. Eu mesmo criei também um navegador dessa forma, chamado Argo. As folhas de estilo no meu navegador eram mais poderosas, mas ainda assim apenas para o usuário, e não para o autor.

Os primeiros autores na Web eram em sua maioria cientistas. Eles estavam acostumados a escrever documentos e deixar outra pessoa decidir sua aparência: jornais científicos normalmente fornecem suas próprias folhas de estilo (em LaTeX, por exemplo), assim o HTML se encaixou bem nesse modelo.

Mas conforme a Web se tornava mais popular, designers começaram a se interessar e a opinião deles era de que, por serem designers, eles sabiam com mais propriedade que os usuários como apresentar um documento da melhor forma. Assim como a aparência de um livro lhe informa sobre que tipo de livro se trata, a aparência de um documento deveria também lhe dizer algo sobre seu conteúdo.

Mas, naquela época, em 1994, isso era impossível de se fazer usando HTML. Assim, duas coisas aconteceram: os designers perceberam que o HTML permitia o uso de imagens, e então eles começaram a substituir textos por imagens, porque assim eles tinham total controle. E o Netscape, o primeiro navegador comercial, notando essa demanda dos designers, começou a adicionar extensões proprietárias ao HTML, como atributos de cor e de plano de fundo, um elemento <center>, e elementos de espaçamento.

Os usuários não estavam felizes com isso: você não pode redimensionar imagens ou recortar e colar partes delas, e imagens também não proviam acessibilidade. E os elementos proprietários faziam os documentos ficarem grandes e difíceis de serem mantidos, e mais difíceis para o usuário aplicar estilos. E, assim, pessoas na lista de discussão www-talk@w3.org começaram a procurar soluções.

Se você quiser ler a história completa do que aconteceu naquela época, você pode ler o capítulo relevante no livro que Håkon e eu escrevemos ou a tese de PhD do Håkon. Em suma: diversas pessoas propuseram linguagens de folhas de estilo, algumas vezes versões simplificadas do que já existia no mundo do SGML, por que o HTML foi derivado do SGML. Duas dessas linguagens eram a “Cascading HTML Style Sheets” do Håkon e a minha linguagem “Streaming Style Sheets”.

Quando eu olhei para a linguagem do Håkon, eu vi uma ideia interessante, que era a de que você poderia ter um tipo de negociação entre o que o autor propunha e o que o usuário queria. Nós começamos a trabalhar juntos, combinando as ideias dele e as minhas (por exemplo, seletores contextuais e a aplicação de folhas de estilos para outros tipo de documento além de HTML), nós inventamos uma nova sintaxe e logo nossa proposta (chamada “Cascading Style Sheets” omitindo o “HTML” do nome) se tornou a mais popular, e outras pessoas começaram a contribuir.

Em 1995, o novo grupo de trabalho de HTML assumiu a tarefa, de modo a torná-lo um padrão. E um pouco depois o grupo se separou, formando o grupo de trabalho de CSS existente ainda hoje.

2. Você já considerou aplicar regras de estilo CSS em outros tipos de conteúdo (além de HTML)? Se isso já foi feito, você poderia fornecer um exemplo? Caso contrário, você poderia discutir em que outros conteúdos poderia ser útil o uso de CSS?

Uma das ideias da minha proposta original de folhas de estilo era justamente isto: usar a mesma linguagem de folhas de estilo para uma ampla gama de documentos, não apenas para HTML (meu próprio navegador podia exibir muitos documentos SGML, e HTML era apenas uma subclasse destes).

Naquela época, ainda não existia XML, mas nós pensamos que deveríamos ter uma linguagem de folhas de estilo para SGML simples ou qualquer coisa que tivesse uma estrutura simples de árvore.

Quando o XML foi criado um pouco depois, acabou combinando muito bem com o que tínhamos em mente e assim o CSS pôde ser utilizado com grande parte de documentos XML também.

E o CSS pode ser usado, e está de fato sendo usado, para outras coisas também. Um exemplo é a biblioteca de interfaces gráficas Qt. Ela usa CSS para aplicar estilo aos componentes da interface gráfica.

 3. Quais partes da atual versão da estecificação do CSS você acha que ainda precisa de mais aprimoramentos?

Tem muitas coisas que ainda estão faltando, especialmente agora que editores estão usando CSS fortemente para editoração de livros, tanto em papel quanto para e-books.

Originalmente nós desenhamos o CSS para ser a linguagem de estilos simples, e adicionamos XSL (por exemplo, XSLT + XSL-FO) para as tarefas complexas, como edição de livros. Mas, no momento, o desenvolvimento do XSL parou, e nós não sabemos quando ele irá continuar, e então os editores estão migrando para o CSS.

Apenas para dar alguns exemplos de coisas que estão faltando no CSS: para o tratamento adequado de hipertexto, nós precisamos de elementos colapsantes (veja aqui) ou, de modo geral, uma forma de alternar o estado de elementos (e não apenas ‘checkboxes’) entre dois possíveis estilos. Nós também não temos ainda containers que formem uma pilha de páginas em abas.

E temos *muito* trabalho a ser feito para tudo que envolva texto paginado: notas de rodapé, elementos flutuantes no topo ou no pé da página, texto que se estenda atravessando colunas, divisão de texto em múltiplos fluxos e alinhamento desses fluxos de texto em um template de página baseado em uma grade, referências cruzadas (como “veja página 7″), índices alfabéticos, ‘copyfitting’ (fazer um texto caber exatamente em um espaço alocado), cabeçalhos e rodapés contendo texto bidirecional ou fórmulas matemáticas etc. Eu comecei a colecionar uma lista de requisitos que pode sr vista aqui.

4. Qual é a sua perspectiva para a evolução do CSS e do HTML em longo prazo? Como você acha que essas tecnologias evoluirão nas próximas décadas?

Foi muito bom o HTML4 ter permanecido sem modificações por tanto tempo. Isso nos permitiu compreendê-lo e criar softwares interessantes. Nós esperávamos certos tipos de aplicações, mas algumas vezes levou muitos anos para que as pessoas se tornassem capazes de efetivamente criá-los. Por exemplo, nós esperávamos que algo como os microformatos fosse surgir, mas levou bastante tempo até algumas pessoas de fato descobrirem como fazê-lo corretamente. E algumas coisas foram inesperadas e apenas descobertas depois.

Então, de certa forma, é uma pena que agora nós tenhamos que migrar nossos softwares para o HTML5, mesmo que o HTML5 adicione novas funcionalidades interessantes. Eu estou lentamente migrando meus softwares, mas levará um bom tempo até que eu possa fazer com o HTML5 o que eu posso fazer com o HTML4. Assim, estou esperançoso de que grande parte de tudo o que é o HTML5, ou sua próxima revisão, volte a permanecer estável por 10 ou 15 anos.

Para o CSS, não tenho muita certeza sobre o que quero. Como visto acima, há várias coisas que precisamos adicionar para satisfazer os vários novos usos. Mas o CSS não foi desenhado para tarefas complexas. Ele foi feito para ser usado por usuários comuns para aplicação de estilos simples. Ao contrário do proposto, o CSS está se tornando complexo demais para a maioria das pessoas. Então talvez seja o momento de se recomeçar do zero criando duas novas linguagens: uma simples que todas as pessoas saibam usar, mas que talvez seja limitada na quantidade de controles detalhados que oferece, e uma avançada, adequada até mesmo para editoração complexa de livros e revistas. Mas eu ainda não vi nenhuma proposta que tenha me agradado.

É bom ver diversos pré-processadores de CSS para ajudar os usuários avançados, como o SASS e o LESS. Eu tinha esperança de eles aparecessem mais cedo. Espero que eles se desenvolvam e se tornem ainda melhores. Por outro lado, estou surpreso com o tamanho de algumas folhas de estilo que as pessoas têm criado. As mais complexas que eu mesmo criei têm 10 kbytes, e a maioria é bem menor que isso. Fico me questionando se eles estão fazendo a coisa certa…

Dessa forma, em termos práticos, acho que ainda iremos adicionar novas funcionalidades ao CSS durante os próximos poucos anos. Haverá, sem dúvidas, novos módulos no CSS3, e alguns módulos que já estão finalizados serão provavelmente estendidos ou substituídos por um módulo do CSS4.

Continuaremos mantendo a retrocompatibilidade do CSS, mas isso também significa se tornará gradativamente mais difícil de adicionar novas funcionalidades a ele, e suas sintaxes poderão não ser as mais intuitivas.

Tradução técnica: Felipe Sanches

O post Entrevista com Bert Bos, criador do padrão CSS apareceu primeiro em .

O tratamento de erros vai permitir que o aplicativo lide de forma mais amigável com os erros, exibindo mensagens de erros adequadas em cada situação. O registro de erros permitirá que possamos encontrar e corrigir os erros que ocorreram durante a execução da aplicação.

O que você vai aprender:

• Como adicionar manipulação de erro global para a configuração do aplicativo;
• Como adicionar o tratamento de erros a nível de aplicação, de página e de código;
• Como registrar erros para posterior análise;
• Como exibir mensagens de erro que não comprometam a segurança;
• Como implementar módulos registro de erros e manipuladores (ELMAH) de registro de erros;

Este artigo foi integralmente baseado no artigo original: http://www.asp.net/web-forms/tutorials/aspnet-45/getting-started-with-aspnet-45-web-forms/aspnet-error-handling (com algumas alterações e portado para a linguagem VB .NET).

Conceitos

As aplicações ASP.NET devem ser capaz de lidar com os erros que ocorrem durante a execução de uma forma consistente. A ASP.NET usa o Common Language Runtime (CLR), que fornece uma maneira de notificar as aplicações de erros de uma maneira uniforme. Quando ocorre um erro, uma exceção é lançada. Uma exceção é qualquer erro, condição ou comportamento inesperado que um aplicativo encontra durante sua execução.

Na plataforma .NET, uma exceção é um objeto que herda da classe System.Exception. Uma exceção é lançada a partir de uma área de código onde ocorreu um problema. A exceção é passada para a pilha de chamadas, um lugar onde a aplicação fornece código para manipular a exceção. Se o aplicativo não tratar a exceção, o navegador é forçado a exibir os detalhes do erro.

Como melhor prática, lidamos com os erros ao nível do código usando blocos try/catch /finally dentro do código. Geralmente, colocamos esses blocos de modo que o usuário possa corrigir problemas no contexto em que eles ocorrem. Se os blocos de tratamento de erros estiverem muito longe de onde ocorreu o erro, torna-se mais difícil fornecer aos usuários a informação do que ele precisa para corrigir o problema.

Classe de exceção

A classe Exception é a classe base da qual as exceções herdam. A maioria dos objetos de exceção são instâncias de alguma classe derivada da classe Exception, como a classeSystemException, a classe IndexOutOfRangeException, ou a classe ArgumentNullException. A classe Exception tem propriedades, tais como a propriedade StackTrace, a propriedadeInnerExceptio e a propriedade Message, que fornecem informações específicas sobre o erro que ocorreu.

Hierarquia de herança de exceção

O runtime tem um conjunto base de exceções que derivam da classe SystemException, que ele lança quando uma exceção for encontrada. A maioria das classes que herdam da classe de exceção, como a classe IndexOutOfRangeException e a classe ArgumentNullException, não implementam membros adicionais. Portanto, a informação mais importante para uma exceção pode ser encontrada na hierarquia das exceções, o nome da exceção, e as informações contidas no exceção.

Hierarquia manipulação de exceção

Em uma aplicação ASP.NET Web Forms, exceções podem ser tratadas com base em uma hierarquia de tratamento específico. Uma exceção pode ser tratada nos seguintes níveis:

1. Nível de aplicação;
2. Nível de página;
3. Nível de código.

Quando um aplicativo lida com exceções, informações adicionais sobre a exceção que é herdada da classe Exception muitas vezes podem ser recuperadas e exibidas para o usuário. Além do nível de aplicativo, página e código, você também pode lidar com exceções no nível de módulo HTTP e/ou usando um manipulador personalizado IIS.

Tratamento de erros a nível de aplicação

Você pode lidar com erros padrão no nível do aplicativo, quer seja modificando a configuração de seu aplicativo ou adicionando um manipulador Application_Error no arquivoGlobal.asax de sua aplicação.

Você pode lidar com erros padrão e erros de HTTP adicionando uma seção customErrors no arquivo Web.config. A seção customErrors permite que você especifique uma página padrão para a qual os usuários serão redirecionados quando ocorrer um erro. Ele também permite que você especifique páginas individuais para erros de código específicos de status.

A seguir, temos um exemplo de configuração feita no arquivo web.config que define o tratamento de erro neste escopo:

<configuration>
 <system.web>
 <customErrors mode="On" defaultRedirect="ErrorPage.aspx?handler=customErrors%20section%20-%20Web.config">
 <error statusCode="404" redirect="ErrorPage.aspx?msg=404&amp;handler=customErrors%20section%20-%20Web.config"/>
 </customErrors>
 </system.web>
</configuration>

Infelizmente, quando usamos a configuração para redirecionar o usuário para uma página diferente, não temos os detalhes do erro que ocorreu.No entanto, podemos capturar os erros que ocorrem em qualquer lugar na aplicação, adicionando código para o manipulador Application_Error no arquivo Global.asax, conforme mostra o exemplo a seguir:

Sub Application_Error(ByVal sender As Object, ByVal e As EventArgs)
        ' dispara quando um erro ocorrer
        Dim exc As Exception = Server.GetLastError()

        If TypeOf exc Is HttpUnhandledException Then
            ' Passa o erro para a página de erro.
            Server.Transfer("ErrorPage.aspx?handler=Application_Error%20-%20Global.asax", True)
        End If
    End Sub

Tratamento de erro a nível de página

Um manipulador a nível de página retorna o usuário para a página onde o erro ocorreu, mas como as instâncias dos controles não são mantidas, não haverá mais nada na página. Para fornecer os detalhes do erro para o usuário, devemos escrever especificamente os detalhes do erro na página.

Devemos usar um manipulador de erro a nível de página para registrar erros sem tratamento ou para levar o usuário para uma página que pode exibir informações úteis.

Este exemplo de código mostra um manipulador para o evento de erro em uma página ASP.NET. Este manipulador captura todas as exceções que não estão sendo tratadas dentro do bloco try/catch na página.

Private Sub Page_Error(sender As Object, e As EventArgs)

Dim exc As Exception = Server.GetLastError()
' Trata o erro
If TypeOf exc Is HttpUnhandledException Then
     ErrorMsgTextBox.Text = "Ocorreu um erro nesta página " 
End If
    ' LImpar ao erro a partir do servidor
    Server.ClearError()
End Sub

Depois de tratar um erro, você deve limpá-lo, chamando o método ClearError do objeto Server (classe HttpServerUtility); caso contrário, você vai ver um erro que tenha ocorrido anteriormente.

Tratamento de erro a nível de código

A instrução try-catch consiste em um bloco try seguido de uma ou mais cláusulas de captura, que especificam os manipuladores para exceções diferentes. Quando uma exceção é lançada, o Common Language Runtime (CLR) procura a instrução catch que trata esta exceção.

Se o método atualmente em execução não contém um bloco catch, a CLR olha para o método que chamou o método atual, e assim por diante, até a pilha de chamadas. Se nenhum bloco catch é encontrado, a CLR exibe uma mensagem de exceção não tratada para o usuário e para a execução do programa.

O exemplo de código a seguir mostra uma maneira comum de usar try/catch/finally para manipular erros:

Try
    file.ReadBlock(buffer, index, buffer.Length)
Catch e As FileNotFoundException
    Server.Transfer("NoFileErrorPage.aspx", True)
Catch e As System.IO.IOException
    Server.Transfer("IOErrorPage.aspx", True)
Finally
    If file IsNot Nothing Then
 	file.Close()
   End If
End Try

No código acima, o bloco try contém o código que precisa ser protegido contra uma possível exceção. O bloco é executado até que uma exceção é lançada ou o bloco é concluído com êxito. Se uma excepção FileNotFoundException ou uma exceção IOException ocorre, a execução é transferida para uma página diferente. Em seguida, o código contido no bloco finally é executado, se ocorreu um erro ou não – o código do bloco finally sempre será executado.

Incluindo o suporte ao registro de erros

Antes de adicionar a manipulação de erros em nossa aplicação, vamos adicionar o suporte ao registro de erros, adicionando uma classe ExceptionUtility na pasta de Logic do nosso projeto.

Ao fazer isso, cada vez que o aplicativo tratar um erro, os detalhes do erro serão adicionados ao arquivo de log de erros.

Clique com o botão direito do mouse sobre a pasta Logic e selecione Add -> New Item;

A seguir, selecione Visual Basic -> Code e o template Class e informe o nome ExceptionUtility.vb e clique no botão Add;

A seguir, digite o código abaixo neste arquivo:

Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Web
Imports System.IO

Namespace WingtipToys.Logic
    ' Creia o nosso utilitário de tratamenteo de exceptions
    Public NotInheritable Class ExceptionUtility
        ' Todos os métodos são estativiso 
        Private Sub New()
        End Sub

        ' Registra uma exceção
        Public Shared Sub LogException(exc As Exception, source As String)
            ' Inclui a logica para as registrar as exceções
            ' Pega o caminho absoluto para o arquivo de log
            Dim logFile As String = "App_Data/ErrorLog.txt"
            logFile = HttpContext.Current.Server.MapPath(logFile)

            ' Abre o arquivo de log para acnexar e escrever o log
            Dim sw As New StreamWriter(logFile, True)
            sw.WriteLine("********** {0} **********", DateTime.Now)
            If exc.InnerException IsNot Nothing Then
                sw.Write("Inner Exception Type: ")
                sw.WriteLine(exc.InnerException.[GetType]().ToString())
                sw.Write("Inner Exception: ")
                sw.WriteLine(exc.InnerException.Message)
                sw.Write("Inner Source: ")
                sw.WriteLine(exc.InnerException.Source)
                If exc.InnerException.StackTrace IsNot Nothing Then
                    sw.WriteLine("Inner Stack Trace: ")
                    sw.WriteLine(exc.InnerException.StackTrace)
                End If
            End If
            sw.Write("Exception Type: ")
            sw.WriteLine(exc.[GetType]().ToString())
            sw.WriteLine("Exception: " + exc.Message)
            sw.WriteLine("Source: " + source)
            sw.WriteLine("Stack Trace: ")
            If exc.StackTrace IsNot Nothing Then
                sw.WriteLine(exc.StackTrace)
                sw.WriteLine()
            End If
            sw.Close()
        End Sub
    End Class
End Namespace

Quando ocorre uma exceção, ela pode ser gravada em um arquivo de log de exceção chamando o método LogException. Este método tem dois parâmetros: o objeto da exceção e uma string contendo detalhes sobre a origem da exceção. O log de exceção é gravado no arquivo ErrorLog.txt na pasta App_Data.

Adicionando uma página de erro

Em nossa aplicação usaremos uma página para exibir erros. A página de erro é projetada para mostrar uma mensagem de erro segura para os usuários do site. No entanto, se o usuário for um desenvolvedor fazendo uma solicitação HTTP que está sendo servida localmente na máquina onde reside o código, iremos exibir detalhes de erro adicionais na página de erro que serão vistas apenas pelo desenvolvedor.

Clique com o botão direito do mouse sobre o nome do projeto e selecione Add -> New Item. Selecione Visual Basic -> Web e, a seguir, o template Web Form using Master Page e informe o nome ErrorPage.aspx e clique no botão Add.

Selecione o arquivo Site.Master como a página principal e, em seguida, escolha OK.

A seguir, substitua a marcação existente pelo código a seguir:

<%@ Page Title="" Language="vb" AutoEventWireup="false" MasterPageFile="~/Site.Master" CodeBehind="ErrorPage.aspx.vb" Inherits="WingTipToys.ErrorPage" %>
<asp:Content ID="Content1" ContentPlaceHolderID="HeadContent" runat="server">
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="FeaturedContent" runat="server">
     <h2>Erro:</h2>
    <p></p>
    <asp:Label ID="FriendlyErrorMsg" runat="server" Text="Label" Font-Size="Large" style="color: red"></asp:Label>

    <asp:Panel ID="DetailedErrorPanel" runat="server" Visible="false">
        <p>
            Erro Detalhado:
            <br />
            <asp:Label ID="ErrorDetailedMsg" runat="server" Font-Bold="true" Font-Size="Large" /><br />
        </p>
        <p>
            Tratamento Erro:
            <br />
            <asp:Label ID="ErrorHandler" runat="server" Font-Bold="true" Font-Size="Large" /><br />
        </p>
        <p>
            Mensagem de erro Detalhada:
            <br />
            <asp:Label ID="InnerMessage" runat="server" Font-Bold="true" Font-Size="Large" /><br />
        </p>
        <pre>
            <asp:Label ID="InnerTrace" runat="server"  />
        </pre>
    </asp:Panel>

</asp:Content>
<asp:Content ID="Content3" ContentPlaceHolderID="MainContent" runat="server">
</asp:Content>

No arquivo code-behind ErrorPage.aspx.vb inclua o código abaixo:

Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports WingTipToys.WingtipToys.Logic

Public Class ErrorPage
    Inherits System.Web.UI.Page

    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        ' Cria as mensagens de erro seguras
        Dim generalErrorMsg As String = "Ocorreu um problema na aplicação web. Tente novamente. " + "Se o ocorre persistir contacte o suporte técnico."
        Dim httpErrorMsg As String = "Ocorreu um erro HTTP. Página não encontrada. Tente novamente."
        Dim unhandledErrorMsg As String = "O erro não foi tratado pelo código da aplicação."

        ' exibe as mensagens de erro
        FriendlyErrorMsg.Text = generalErrorMsg

        ' Determina onde o erro foi tratado
        Dim errorHandler__1 As String = Request.QueryString("handler")
        If errorHandler__1 Is Nothing Then
            errorHandler__1 = "Error Page"
        End If

        ' pegao ultimo erro do servidor.
        Dim ex As Exception = Server.GetLastError()

        ' Pega o numero do erro passado como um valor querystring 
        Dim errorMsg As String = Request.QueryString("msg")
        If errorMsg = "404" Then
            ex = New HttpException(404, httpErrorMsg, ex)
            FriendlyErrorMsg.Text = ex.Message
        End If

        'Se a exceção não existe mais, cria uma exceção genérica
        If ex Is Nothing Then
            ex = New Exception(unhandledErrorMsg)
        End If

        ' exibe os detalhes de erro somente para o desenvolvedor.SOMENTE ACESSO LOCAL
        If Request.IsLocal Then
            'mensagem de erro detalhada
            ErrorDetailedMsg.Text = ex.Message

            ' mostra onde o erro foi tratado
            ErrorHandler.Text = errorHandler__1

            ' mostra o acesso local 
            DetailedErrorPanel.Visible = True

            If ex.InnerException IsNot Nothing Then
                InnerMessage.Text = ex.[GetType]().ToString() + "<br/>" + ex.InnerException.Message
                InnerTrace.Text = ex.InnerException.StackTrace
            Else
                InnerMessage.Text = ex.[GetType]().ToString()
                If ex.StackTrace IsNot Nothing Then
                    InnerTrace.Text = ex.StackTrace.ToString().TrimStart()
                End If
            End If
        End If

        ' registra a exceção
        ExceptionUtility.LogException(ex, errorHandler__1)

        ' limpa o erro do servidor
        Server.ClearError()
    End Sub

End Class

Quando a página de erro for exibida, o evento Page_Load é executado. No manipulador Page_Load, o local onde o erro foi primeiro tratado é determinado. Então, o último erro que ocorreu é obtido através do método GetLastError do objeto Server.

Se a exceção não existir mais, uma exceção genérica será criada. Então, se o pedido HTTP foi feita localmente, todos os detalhes do erro serão mostrados. Neste caso, apenas a máquina local executando a aplicação web vai ver esses detalhes do erro. Depois que as informações do erro forem exibidas, o erro é adicionado ao arquivo de log e o erro é eliminado do servidor.

Exibindo mensagens de erro não tratadas para a aplicação

Ao adicionar uma seção customErrors no arquivo Web.config, você pode rapidamente tratar erros simples que ocorrem na aplicação. Você também pode especificar como lidar com erros com base no seu valor de código de status, como 404 – Arquivo não encontrado.

Abra o arquivo web.config da raiz do projeto e inclua a seção customErrors no interior do nó conforme abaixo:

A seção customErrors especifica o modo, o que é definido como “On” (mode=”On”). Também especifica o defaultRedirect, que diz à aplicação para qual página navegar quando ocorrer um erro.

Além disso, adicionamos um elemento de erro específico que define como lidar com um erro 404 quando uma página não for encontrada. Mais adiante, vamos adicionar o tratamento de erro adicional que irá capturar os detalhes de um erro a nível de aplicação.

Testando a aplicação

Execute a aplicação pressionando CTRL+F5 (ou clicando no botão do menu que executa a aplicação). O navegador irá abrir e apresentar a página Default.aspx:

Informe a seguinte URL no navegador para provocar um erro: http://localhost:674846/NoPage.aspx (o número da porta para sua aplicação será diferente).

A página de erro ErrorPage.aspx será exibida conforme a figura a seguir:

Quando você solicita a página NoPage.aspx que não existe, a página de erro irá mostrar a mensagem de erro simples e as informações de erro detalhadas (se detalhes adicionais estiverem disponíveis).

No entanto, se o usuário solicitou uma página inexistente a partir de um local remoto, a página de erro só vai mostrar a mensagem de erro em vermelho.

Incluindo uma exceção para testes

Para verificar como o aplicativo irá funcionar quando ocorre um erro, você pode deliberadamente criar condições de erro. Vamos lançar uma exceção de teste quando a página padrão for carregada para ver o que acontece.

Abra o arquivo code-behind Default.aspx.vb e no evento Load da página inclua o código abaixo:

Public Class _Default
    Inherits Page

    Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs) Handles Me.Load
        Throw New InvalidOperationException("O Erro : InvalidOperationException " + "õcorreu no evento Page_Load ná página Default.aspx.")
    End Sub
End Class

No código acima estamos criando uma exceção do tipo InvalidOperationException, que irá ocorrer quando a página Default.aspx for carregada.

Testando a aplicação

Execute a aplicação novamente pressionando CTRL+F5 (ou clicando no botão do menu que executa a aplicação). O navegador irá abrir e apresentar a página Default.aspx.

A página exibirá a mensagem de erro conforme abaixo:

Adicionando o tratamento de erros a nível de aplicativo

Em vez de capturar a exceção usando a seção customErrors no arquivo Web.config, onde você ganha pouca informação sobre a exceção, você pode interceptar o erro no nível da aplicação e recuperar detalhes do erro.

Abra o arquivo Global.asax e atualize o código do evento Application_Error conforme abaixo:

 Sub Application_Error(ByVal sender As Object, ByVal e As EventArgs)
        ' pega o último erro do servidor
        Dim exc As Exception = Server.GetLastError()

        If TypeOf exc Is HttpUnhandledException Then
            If exc.InnerException IsNot Nothing Then
                exc = New Exception(exc.InnerException.Message)
                Server.Transfer("ErrorPage.aspx?handler=Application_Error%20-%20Global.asax", True)
            End If
        End If

    End Sub

Quando ocorre um erro na aplicação, o manipulador Application_Error é chamado. Nesse manipulador, a última exceção é recuperada e revisada. Se a exceção ocorreu sem um tratamento e a exceção contém detalhes de uma exceção interior (InnerException não é nulo), a aplicação transfere a execução para a página de erro onde os detalhes da exceção são exibidos.

Testando a aplicação

Execute a aplicação novamente pressionando CTRL+F5 (ou clicando no botão do menu que executa a aplicação). O navegador irá abrir e apresentar a página Default.aspx.

A página exibirá a mensagem de erro conforme abaixo:

Adicionando o tratamento de erros a nível de página

Podemos adicionar a manipulação de erros a nível de página para uma página, seja adicionando um atributo ErrorPage na diretiva @Page da página, ou pela adição de um manipulador de eventos Page_Error ao código-behind da página. Vamos adicionar um manipulador de eventos Page_Error que irá transferir a execução para a página ErrorPage.aspx.

Abra o arquivo code-behind Default.aspx.vb e inclua o código para o evento Page_Error() conforme abaixo:

Private Sub Page_Error(sender As Object, e As EventArgs)
        ' pega o ultimo erro do servidor.
        Dim exc As Exception = Server.GetLastError()

        ' trata o erro
        If TypeOf exc Is InvalidOperationException Then
            ' Passa o erro para pagina de erro
            Server.Transfer("ErrorPage.aspx?handler=Page_Error%20-%20Default.aspx", True)
        End If
    End Sub

Quando ocorre um erro na página, o manipulador de eventos Page_Error é chamado. Nesse manipulador, a última exceção é recuperada e revisada. Se um erro do tipo InvalidOperationException ocorrer, o manipulador de eventos Page_Error transfere a execução para a página de erro onde os detalhes da exceção são exibidos.

Testando a aplicação

Execute a aplicação novamente pressionando CTRL+F5 (ou clicando no botão do menu que executa a aplicação). O navegador irá abrir e apresentar a página Default.aspx.

A página exibirá a mensagem de erro conforme abaixo:

Após essa bateria de testes, remova ou comente o código usado no evento Load da página Default.aspx para lançar deliberadamente um erro.

Usando ELMAH

ELMAH (módulos de registro de erros e manipuladores) é uma unidade de registro de erros que você conecta em sua aplicação ASP.NET como um pacote NuGet. A ELMAH oferece os seguintes recursos:

• Registro de exceções não tratadas;
• Uma página da Web para exibir todo o log de exceções não tratadas;
• Uma página da Web para exibir os detalhes de cada exceção logada;
• Uma notificação por e-mail de cada erro no momento em que ocorre;
• Um feed RSS dos últimos 15 erros do registro.

Antes de trabalhar com o ELMAH, temos que instalá-lo. Isto é fácil usando o instalador de pacotes NuGet.

Obs: O NuGet é uma extensão do Visual Studio que faz com que seja fácil de instalar e atualizar bibliotecas de código aberto e ferramentas no Visual Studio.

Com o projeto aberto no Visual Web Developer for Web, clique no menu TOOLS  e a seguir selecione Library Package Manager -> Manage Nuget Packages for Solution.

A janela - Manage Nuget Packages - será exibida. Selecione o item OnLine e digite na caixa de busca a palavra ELMAH. O pacote ELMAH deverá ser exibido no topo da lista de itens encontrados. Clique no botão Install para instalar o pacote ELMAH. A instalação apresentará uma tela solicitando a confirmação para instalar o pacote no projeto. Confirme clicando em OK.

Obs: Você deve estar conectado para poder baixar o pacote.

Se for solicitado, recarregar os arquivos abertos, selecione “Sim para Todos” (Yes to All).

O pacote ELMAH adiciona entradas na seção <modules> do nó <system.webServer> no arquivo Web.config. Se o sistema solicitar se você deseja recarregar o arquivo Web.config modificado, clique em Sim(Yes).

Com essa etapa concluída, estamos pronto para usar o pacote ELMAH.

Visualizando o log ELMAH

Ver o log ELMAH é fácil, mas primeiro vamos criar uma exceção não tratada que será gravada no log ELMAH.

Pressione CTRL + F5 para executar nossa aplicação. A seguir, digite a seguinte URL (usando o seu número de porta) no navegador para provocar uma exceção não tratada no log ELMAH: localhost:64786/NoPage.aspx.

A página de erro será exibida conforme abaixo:

Para visualizar o log de erros ELMAH digite a url no navegador: http://localhost:64786/elmah.axd

O log de erros ELMAH será exibido indicando informações sobre a ocorrência:

Se você clicar no link Details, irá obter os detalhes da exceção:

Atenção!!! Cuidado ao usar o recurso ELMAH, pois qualquer um pode ler o código de erro acessando a página, e existem exploits (um exploit é um programa de computador ou uma sequência de comandos que se aproveita das vulnerabilidades de um sistema) que exploram isso.

• Veja como hackear Elmah aqui.
• Para implementar seguro (não testei): http://haacked.com/archive/2007/07/24/securely-implement-elmah-for-plug-and-play-error-logging.aspx

***

Colaboração de Vitor Hugo.

Neste artigo aprendemos como manipular erros ao nível da aplicação, a nível da página, e do nível de código. Aprendemos também a registrar erros tratados e sem tratamento para posterior análise. Além disso, aprendemos  sobre a importância das mensagens de erro seguras.

E com isso encerramos essa série de tutoriais onde acompanhamos a criação de uma aplicação ASP .NET Web Forms usando o Visual Studio Express For Web 2012.

Embora a aplicação possa ser melhorada em muitos aspectos, o objetivo foi mostrar como podemos criar aplicações dinâmicas com acesso a dados usando recursos integrados do Visual Studio.

Espero que esses artigos tenham contribuído para aguçar o seu desejo em aprender mais sobre a tecnologia ASP .NET, pois o que vimos foi só a ponta do Iceberg.

Bom estudo!!!

O post ASP .NET 4.5 Web Forms – Tratamento de erros e registro de log – Parte 09 apareceu primeiro em .

Seguindo o mesmo padrão de layout aplicado no Razr D3, o Motorola Razr D1 é um smartphone compacto, com preço competitivo e bons recursos. Equipado com TV digital, dois cartões SIM e processador de 1 GHz, o gadget roda o Android 4.1.2 sem muitos engasgos e com desempenho acima da média para a categoria.

Custando 529 reais, o D1 é uma opção mais econômica para quem precisa gerenciar duas linhas e não abre mão de maior velocidade nas tarefas básicas. O processador ARMv7 com um núcleo de 1 GHz, somado à memória RAM de 1 GB, garantiu em nossos testes uma boa experiência de uso. O smartphone rodou os principais aplicativos, como Facebook, Instagram e games sem grandes problemas. Há lentidão em alguns pontos, como na gestão do app de TV digital e com muitos aplicativos abertos simultaneamente, mas nada acima do normal para um smartphone de entrada.

Benchmark Quadrant (em pontos)
Barras maiores indicam melhor desempenho

Benchmark AnTuTu (em pontos)
Barras maiores indicam melhor desempenho

Ao contrário de outros modelos com TV digital, o D1 não possui uma antena retrátil. A sintonia dos canais é feita quando os fones de ouvido estão conectados. Dessa forma, assim como para a sintonia de rádio, o cabo dos fones assume o papel da antena. Na prática isso resulta em uma redução na força de sinal. Em nossos testes, isso não significou perda em qualidade ou recepção de menos canais, mas houve demora na sintonia. O aplicativo de TV exibe guia de programação, grava trechos dos programas direto no cartão microSD e salva capturas de tela. O layout é muito similar ao do Atrix TV Dual, também da Motorola.

Com 3,5 polegadas, a tela do D1 oferece 480 por 320 pixels. O brilho intenso e a fidelidade nas cores compensam a resolução baixa. É possível reparar serrilhados em menus e ícones do sistema. O resultado com vídeos também não é dos melhores. Por outro lado, há precisão nos toques e, no geral, a interface da Motorola, que se aproxima do Android em sua versão pura, causa boa impressão.

Com 5 megapixels, a câmera do Razr D1 faz fotos medianas em boas condições de luz. Durante a noite ou em ambientes pouco iluminados, o excesso de ruído e a falta de flash LED tornam o registro de imagens inviável. Os vídeos são gravados em 480p a 30 quadros por segundo.

Fonte: http://info.abril.com.br/reviews/smartphones/motorola-razr-d1.shtml

O post Aparelho gerencia dois cartões SIM e sintoniza TV Digital no Android 4.1.2 apareceu primeiro em .

Se antes o consumidor que tinha um problema com um produto dependia de um grande veículo de comunicação, agora basta estar conectado à internet para ele possa fazer barulho nas redes sociais. Este é o Prosumer.

Mas as empresas mal se acostumaram a este novo cenário e vem aí a evolução disso tudo que é o Supersumer. É um consumidor bem diferente do que vemos hoje. Ele está conectado 24 horas por dia e quer atendimento a qualquer hora e em qualquer lugar.

É o consumidor que usará Google Glass e outros gadgets que nem conhecemos ainda. Quase um consumidor cibernético que poderá transmitir falhas ou reclamações em tempo real e sua rede de contatos irá reverberar este problema até em alguns casos causar dores fortes de cabeça nos gestores.

Mas como podemos nos preparar para estes novos cenários que virão? Pode parecer clichê mas não vamos resolver novos problemas com soluções antigas. É preciso que os SACs se renovem urgentemente. Sistemas de informação de marketing, BI – Business Inteligence e SAC totalmente integrados farão toda a diferença.

E para um superconsumidor vamos precisar de um SuperSAC que use referenciamento geográfico, dispositivos móveis e vídeo-chamadas. Dei uma palestra recentemente sobre o tema:

E se você acha tudo isso muito utopia dê uma olhada no vídeo abaixo:

O vídeo está em inglês mas basicamente uma consumidora recebe a câmera quebrada, entra em contato com o SAC que já identifica o defeito e fala que irá trocar o produto, porém como a cliente precisa do produto o quanto antes a equipe localiza uma loja que tem a câmera nas imediações da casa da cliente. Pode parecer tudo muito utópico para a realidade brasileira, mas sinto que precisamos pelo menos discutir estas novas relações você não acha?

O post Você conhece o Supersumer? apareceu primeiro em .

Entretanto, muita gente ainda vê o Business Intelligence como algo distante, que só serve para as grandes empresas. Mas essa é uma visão equivocada. Na verdade o BI é uma ferramenta que pode ser adaptada para o tamanho de qualquer empresa.

Uma pesquisa realizada pela ComputerWorld Brasil, em 2010, mostrou que na América Latina foram investidos cerca de us$ 504 milhões em BI, sendo que metade dessa quantia veio para o Brasil. Segundo a consultoria IDC, em pesquisa do mesmo ano, as pequenas e médias empresas já estavam optando por essa solução, mas utilizando versões mais simples. Ou seja, pode-se afirmar que implementação do BI nesSas empresas é apontada como responsável por diversos resultados positivos, entre eles: redução de custos, melhoria de processos e aumento da retenção de clientes.

Mas se ainda assim você não está convencido, proponho que imagine a seguinte situação: uma rede de três mercadinhos que precisa saber quais são os produtos mais vendidos no começo do mês (momento de mais compra pelos consumidores em virtude do recebimento do salário). Essa informação é muito importante e interfere automaticamente no departamento de compras, logística, estoque e até na exposição dos produtos na loja, e o gestor precisa tomar uma decisão rapidamente para atender bem e não ficar sem produtos ou ficar com muitos produtos que não vendem em estoque. E é aí que entra o BI para resolver isso tudo.

Um sistema de Business Intelligence ajuda na tomada de decisão, e as possibilidades são muito maiores do que acabei de citar. Com as métricas e os KPIs corretos, é possível enxergar e entender melhor o cenário de atuação de qualquer empresa, seja grande ou pequena, e como agir de maneira correta e assertiva.

Uma pequena fábrica de sapatos, por exemplo, precisa saber quais são os clientes que mais compram sapatos masculinos bico fino na região Sudeste? Quais os modelos mais vendidos de sandálias para o Nordeste e quanto isso representa das vendas totais da empresa? As respostas dessas perguntas influenciam na elaboração da próxima coleção e, se a empresa não tem isso nas mãos, fica muito complicado decidir e garantir sucesso.

Podem ser perguntas simples, mas difíceis de serem respondidas em um primeiro momento. EsSas informações, no entanto, podem gerar insights valiosíssimos para a sua pequena empresa, capazes de gerar uma economia de tempo e custos. E ainda pode e deve influenciar na estratégia de vendas dos seus produtos ou serviços.

E isso tudo já pode ser acessado pelo tablet ou smartphone do dono da empresa. Com uma ferramenta de BI móvel, é possível acessar, analisar e cruzar dados estando em qualquer lugar.

Enfim, as possibilidades de utilização do Business Intelligence são inúmeras. Será que não é isso o que está faltando para a sua pequena ou média empresa crescer cada vez mais?

O post Business Intelligence para pequenas empresas apareceu primeiro em .