Tradução do texto “10 ways to continuously improve your intranet” disponível em http://www.steptwo.com.au/papers/kmc_continuousimprovement

A quantidade de trabalho envolvida na criação ou na reestruturação de uma intranet é menor se comparado ao tempo necessário para manter uma intranet eficaz em longo prazo. De fato, é comum que a excitação inicial de uma nova intranet desapareça com o passar dos dias. Assim os desafios de melhorar a intranet se tornam aparentes.

Por esta razão, as intranets tendem a tomar dois caminhos após o lançamento: Estagnar, tendo poucos novos recursos adicionados ao longo do tempo ou tornar-se uma massa de conteúdo não-estruturado, tendo funcionalidades criadas de forma aleatória. Isso normalmente continua até que a próxima reestruturação seja anunciada.

Será que isso significa que um projeto de reestruturação é a única forma de melhorar substancialmente uma intranet? É esta a única vez que as atividades de projeto centradas no usuário, tais como entrevistas com a equipe e os testes de usabilidade, podem ser realizadas? Se um projeto de reestruturação não é planejado, como pode a equipe de intranet eventualmente encontrar tempo para melhorá-la e ao mesmo tempo, cumprir o prazo de manutenção do dia-a-dia?

Este artigo descreve 10 maneiras práticas que uma intranet pode ser melhorada de forma incremental, sem, contudo ter que reestruturá-la num novo projeto. Embora alguns dos métodos possam exigir mini-projetos a serem criados internamente pela equipe da intranet, muitos deles podem ser aplicados juntamente com as atividades da equipe de manutenção.

1. Adote uma atitude correta

O maior obstáculo para a criação de uma intranet eficaz é a crença de que uma intranet pode ser, ou deve ser criada de uma só vez. Um projeto de reestruturação nunca pode satisfazer as necessidades de toda a organização de uma só vez. Atender essas necessidades leva tempo, assim como é necessário um esforço contínuo para tornar a intranet uma ferramenta valiosa para o negócio.

Lembre-se que as melhorias incrementais fazem a diferença, e que cada melhoria se baseia conquistas anteriores. Seja paciente e eduque seus usuários e interessados, mostrando que a intranet exige uma melhoria contínua para permanecer relevante e eficaz. Com esta atitude você estará pronto para embarcar em algumas das idéias contidas neste artigo.

2. Aprenda continuamente sobre as necessidades das equipes

A criação ou reestruturação da intranet envolverá atividades para determinar as necessidades que as equipes têm dentro de uma intranet. No entanto, as necessidades dessas equipes continuam mudando ao longo do tempo. Muitas vezes, o início da intranet faz com que as equipes vejam de outra maneira como a intranet pode ajudá-los. Para melhorar continuamente a intranet, é importante aprender continuamente sobre as necessidades dessas equipes.

Aproveite todas as oportunidades para aprender sobre o que sua equipe precisa. Há uma variedade de maneiras de fazer isso informalmente, não exigindo um longo programa de pesquisa.

Ouça

Aprenda habilidades de escutar ativamente e técnicas de entrevista – isto irá ajudá-lo a compreender melhor as necessidades da intranet. Ouça e pense em tudo o que você escuta sobre a intranet. Se você escutar algo que não parece verdade (“Eu nunca consigo achar meu contracheques”), não ignore. Siga o problema até você entender porque as pessoas estão fazendo estes comentários.

Não responda perguntas, faça perguntas

Sempre que alguém pergunta onde encontrar algo na intranet, aproveite a oportunidade para aprender mais. Descubra o contexto que envolve essa pergunta. O que a pessoa está fazendo para chegar nessa questão? Que passos ela já tomou? Onde ela achava que a informação deveria estar? Isso vai começar a construir o conhecimento de que os funcionários estão realmente tentando fazer com a intranet e fornecer idéias de como ela aborda as funcionalidades.

Diga “me mostre como” sempre que possível

Leve as pessoas a trabalhar com o que deu errado para elas. Não critique ou diga que elas deveriam estar fazendo de outro jeito, basta observá-las e aprender. Os dados adquiridos ao ver alguém usando a intranet serão muito mais valiosos do que apenas dizer-lhe a resposta.

Sempre procure feedback

Não confie em um formulário online para feedback, pois as pessoas só vão procurá-lo quando estiverem frustradas com alguma coisa. Procure por feedback:

• Com colegas, pedindo que eles pensem em uma nova funcionalidade;
• Perguntando às pessoas em workshops internos sobre suas experiências com a intranet;
• Contatando novatos e perguntando a eles quais questões eles têm sobre a intranet;
• Conversando com o pessoal de helpdesk para descobrir se há algum problema que as pessoas tendo com freqüência;
• Identificando os problemas reais.

Se você ouvir críticas sobre a intranet, não as leve para o lado superficial. Aprofunde-se para determinar qual é o real problema e o que você pode fazer para resolvê-lo. Por exemplo, muitas vezes as pessoas dizem coisas como “a busca nunca funciona”. Não há detalhes suficientes neste comentário para que você possa fazer melhorias, por isso você precisa aprender mais. Execute um teste de usabilidade ou faça alguma investigação para descobrir informações suficientes para resolver o problema.

3. Realize testes regulares de usabilidade

O teste de usabilidade é freqüentemente realizado no final de um projeto de intranet. No entanto, é muito útil realizar estes testes ao longo da vida da intranet.

Durante a criação ou reestruturação nem toda parte da intranet será coberta por um teste de usabilidade. Também é pouco prático realizar um teste de usabilidade a cada nova melhoria da intranet. Um programa regular de teste de usabilidade permite que você acompanhe o quão bem a intranet está apoiando funcionalidades essenciais e identificar novos problemas de usabilidade.

Prepare um conjunto de cenários que possam ser usados em cada teste de usabilidade – estes lhe permitem analisar o quanto a intranet está sendo eficiente ao longo do tempo. Para cada série de testes de usabilidade, crie um conjunto de cenários que visem explorar áreas não testadas da intranet ou funcionalidades específicas. Isto lhe permitirá garantir que a intranet é útil para uma vasta gama dessas funcionalidades.

Após cada teste de usabilidade, escreva os resultados e torne-os disponíveis na própria intranet. Mostre ao pessoal o que você tem feito para melhorá-la e destaque as áreas onde a intranet tem melhorado.

4. Alinhe com as estratégias da empresa

Uma intranet eficaz é aquela que apóia as estratégias do negócio, comunicando essas estratégias e fornecendo ferramentas e conteúdo para permitir que elas sejam implementadas e difundidas em toda a organização.

Ao invés de focar apenas em funcionalidades administrativas, gaste um tempo para compreender as estratégias fundamentais de sua organização, quer se trate de reduzir os custos de uma área ou melhorar o nível de satisfação dos seus clientes externos. Pense em maneiras que a intranet pode apoiar estas estratégias, tais como:

• Crie uma seção na Intranet para comunicar o andamento das principais iniciativas estratégicas. Inclua o que cada iniciativa está destinada a alcançar, quem está liderando a iniciativa, os resultados alcançados até o momento e com quem falar para obter mais informações. Ao fornecer essas informações na intranet, os funcionários terão a oportunidade de manter-se atualizado com o foco estratégico da organização.
• Identifique o conteúdo ou funcionalidades que podem ajudar a alcançar um objetivo estratégico fundamental. Por exemplo, se o foco está na redução dos custos de helpdesk, investigue se a intranet pode fornecer acesso rápido aos produtos e serviços de informação que irá ajudar a reduzir os tempos dos chamados.

5. Apóie a colaboração existente

Muitas vezes, nós assumimos que as soluções criadas em uma organização estão diretamente ligadas a estrutura organizacional, isto é, trabalho concluído em pequenas equipes independentes. Na verdade, grande parte do trabalho de qualidade em uma organização envolve muitas áreas da empresa. Sendo assim, pessoas de equipes diferentes compartilham experiências e juntas criam melhores resultados.

Uma intranet que suporta este modo de trabalho irá fornecer muito mais valor para a organização e seus funcionários. A intranet pode apoiar esta forma de trabalhar em uma série de maneiras, incluindo:

• Ajudando pessoas se encontrarem. Funcionários precisam ser capazes de se reunir com as pessoas certas e contatar pessoas com experiências semelhantes.
• Ajudando a equipe a fim de evitar re-inventar a roda, permitindo que elas compartilhem projetos atuais ou anteriores.
  Permitindo que o pessoal compartilhe seus conhecimentos e experiências com mais facilidade.

6. Melhorar a intranet parte por parte

Um dos métodos mais práticos e executáveis para melhorar uma intranet é trabalhar em uma seção por vez. Isso permite à equipe da intranet se concentrar em uma área de conteúdo definido e definir metas e prazos razoáveis para o seu trabalho.
Considere alguns dos seguintes métodos:

Melhorar uma funcionalidade de cada vez

Selecione uma ou mais tarefas que são normalmente realizadas por funcionários ou executados em momentos críticos para a organização. Por exemplo, preenchimento de planilhas ou a conclusão as avaliações de desempenho. Concentre-se em melhorar a forma como a intranet suporta tais funcionalidades. Sente-se com alguns funcionários que estão familiarizados com a tarefa, ou tenham necessidade de realizar a tarefa no futuro, e veja os tentar concluir a tarefa na intranet. Peça para que eles pensem alto e anote todos os problemas que são identificados na tentativa.

Trabalhar com uma unidade de negócio ou equipe

Identifique uma equipe que está empenhada em melhorar seus conteúdos e funcionalidades na intranet, ou uma equipe que não tem atualmente presença na intranet. Trabalhe com os membros dessa equipe para entendê-los executando tarefas usando suas informações. Usando os resultados da análise das funcionalidades, atualize o conteúdo e faça ajustes na arquitetura da informação da intranet. Garanta que as alterações melhorem a capacidade do usuário para executar as tarefas em questão.

7. Melhorar a rastreabilidade

Pegue uma funcionalidade qualquer, e veja como é fácil encontrar a informação utilizando o motor de busca e a interface da intranet. Pegue palavras chave que comumente são usadas na busca. Se você tiver acesso aos funcionários, organize 10-15 minutos do seu tempo e veja como eles tentam encontrar o conteúdo da sua lista.

Assim que os problemas de rastreabilidade forem descobertos, reveja os metadados do conteúdo. Com essa abordagem também é provável que se descubra lacunas no conteúdo. Anote essas lacunas e decida a melhor forma de preenchê-las. Esta pode ser uma conversa com o proprietário do conteúdo relevante para responder o que você tenha encontrado.

Outra ótima maneira de melhorar a rastreabilidade do conteúdo da intranet é criar um relatório de falha na pesquisa. Este relatório lista todas as palavras ou frases inseridas pelos usuários e que trazem nenhum resultado. Execute o relatório de cada mês e procure os termos que os usuários estão entrando regularmente. Investigue se as procuras falharam por causa de metadados incompletos ou porque o conteúdo não existe.

8. Use dados existentes

Uma série de dados podem já existir e você pode utilizá-los para saber mais sobre o uso da intranet. Por exemplo:

• Sistemas de estatísticas de site fornecem informações sobre quais páginas estão sendo visitadas e como isso muda ao longo do tempo. Isso pode dar idéias sobre as áreas mais populares da intranet e quais funcionalidades são mais usadas.
• Helpdesks geralmente capturam informações sobre problemas. Esta informação pode fornecer idéias para melhorias no conteúdo ou formas que a intranet poderia apoiar as pessoas, tais como uma melhor informação de ajuda para instalar um sistema de criptografia para e-mail.
• Relatórios de pesquisa incluem consultas digitadas no mecanismo de busca interno. Eles podem destacar os temas mais populares e como eles mudam ao longo do tempo. Os relatórios de pesquisa são também uma fonte valiosa de como os funcionários descrevem a informação que eles estão procurando, e pode ser usada para melhorar os rótulos utilizados na navegação. Analisar regularmente os relatórios a partir destas fontes vai te atualizar do que está acontecendo em sua intranet.

9. Implemente a intranet com conteúdo colaborativo

Autores de conteúdo são um dos mais importantes, se não o mais importante aspecto que contribui para a utilidade da intranet. Eles são especialistas em suas áreas e sem eles você não tem uma intranet. No entanto, os autores nem sempre tem técnicas efetivas de escrita para comunicar eficazmente a sua experiência e conhecimento.

Esta é a hora que a equipe de intranet pode desempenhar um papel fundamental, ajudando a os autores a identificar o conteúdo certo para publicar e escrever o conteúdo que responda a perguntas comuns.

Crie uma comunidade de prática

Se você ainda não tem uma comunidade de prática para a intranet, considere a criação de uma logo. Uma comunidade de prática na intranet é um grupo de interessados na intranet (autores, editores, revisores e da equipe central da intranet), que dividem a responsabilidade de manter e melhorar a intranet. A comunidade reúne-se em uma base regular para estabelecer normas e aprender novas e melhores maneiras de fazer as coisas. Os Autores incentivam a participar da comunidade e utilizar alguns dos encontros para executar habilidades de escrita ou a repassar suas técnicas de autoria para criar um conteúdo mais útil e utilizável.

Conduza seções de coaching individuais

Criar sessões individuais de coaching com os autores interessados em ajudar a construir os seus conteúdos de planejamento e escrita. Coaching é o processo de trabalhar com pessoas para ajudá-los a alcançar suas metas, evitando transformar em um processo de treinamento. Em vez de isso trabalhar com o autor em um pedaço de conteúdo que eles estão atualmente planejando ou escrevendo. Até ao final de uma ou duas sessões de coaching, o autor deve ser capaz de apontar para uma parte do trabalho publicado que vocês concluíram juntos.

Ao trabalhar com autores, leve tempo aprendendo sobre seu domínio de conhecimento. Isto não só irá ganhar o respeito dos autores, mas também ajudar a equipe da intranet saber mais sobre a organização.

10. Criar how-tos para autores

Autores de conteúdo freqüentemente batalham com os sistemas de gerenciamento de conteúdo (CMS) que são complicados de usar. Isso resulta em uma mudança brusca de foco, que era criação de conteúdo, para aprender a dominar o CMS.

A maioria das organizações tenta resolver este problema de aprendizado, apoiando-se em um manual de treinamento ou uma seção na Intranet com as orientações para o autor. Essa abordagem funciona, exceto quando o manual de formação ou conjunto de orientações não responde a perguntas reais dos autores. Por exemplo, uma orientação sobre como carregar uma imagem para o CMS pode dizer ao autor quais botões clicar e o que entrar nos campos relevantes, no entanto se não for dito os “macetes” que usuários experientes já aprenderam, ela não tem muito valor.

Uma intranet pode ser melhorada ao longo do tempo através da construção de um repositório de bem pensado de how-tos para os autores. Em vez de apressar-se para escrever um conjunto de orientações, construa o repositório um por um. Considere o uso de uma intranet da comunidade de prática para as reuniões de brainstorm alguns how-tos.

Ao escrever how-tos, garanta que eles realmente respondem a perguntas dos autores. Siga estas dicas:

• Fale com autores experientes e descubra o que é sempre perguntado por seus colegas menos experientes.
• Fale com novos autores e descubra o que lhes causou a maior dor quando utilizou o CMS, pela primeira vez.
• Ao escrever how-tos pense em todas as coisas que podem dar errado no caminho. Que perguntas você faria se você estivesse fazendo uma atividade particular, pela primeira vez.
• Não limite os how-tos com o que os autores precisam fazer no CMS. Responda às perguntas que eles possam vir a ter sobre todo o processo. Por exemplo, no caso das imagens, como eles as criaram? Quais ferramentas estão disponíveis para manipular imagens? Como eles nomes de arquivos de imagem?
• Incentive a utilização do how-tos, e refira-se a eles quando os autores pedirem ajuda. Se um autor disser que um how-to não abrange a sua pergunta, atualize-o para que outro autor não passe pelo mesmo problema.

Conclusão

A intranet verdadeiramente eficaz não é criada por um projeto único ou redesenho do projeto. A maioria do trabalho na criação de uma intranet eficaz ocorre muito depois de seu lançamento. Para melhorar continuamente a sua intranet, é importante aprender continuamente sobre as necessidades do usuário, certificando-se que a intranet permanece alinhada com as estratégias de negócios e prestação de apoio contínuo aos autores.

Links Externos

• http://www.steptwo.com.au/papers/kmc_continuousimprovement
• http://www.steptwo.com.au/papers/cmb_corebusiness
• http://www.steptwo.com.au/papers/cmb_taskbytask
• http://www.steptwo.com.au/papers/cmb_intranetcop

Fala galera,

Recentemente estamos trabalhando em um projeto que lida com uma massa de dados muito grande. Estamos utilizando EF4 e SQL Server 2008.

Fazemos uma média de 300 inserts.. e alguns bons Selects junto a cada 5 segundos. Está funcionando muito bem!

Mas.. como nem tudo é um mar de rosas..

Temos um processador de log que faz esses inserts e selects, por questões de optimização, e um outro processador.. que faz uma análise mais detalhada dos dados.

O segundo processador utiliza uma Flag, que tem o default value “1″ no banco de dados, para tirar alguns resultados.

Um belo dia, após a implantação do campo em produção, os resultados oriundos desse segundo processador começaram a aparecer com uma incidência muito maior do que deveria.

Alguma coisa estava errada, certo?

Sim.. lembram do primeiro processador? Então.. ele não estava preenchendo o valor para o campo da flag via código, ou seja, ele deveria estar pegando o Default value do banco..

Ai que está nosso problema.. o Entity não mapeia esses valores padrão do banco de dados.. ele assume um valor para ele lá.. no caso do tipo BIT ele aparentemente sempre assume que o valor padrão é “false”.

Então.. quando você tem um campo com default value “true” e o ORM mapeia como “false” o que acontece?

—> M-E-R-D-A

Bom, é isso ai.. espero que isso seja útil como aviso para quem ainda não sabe sobre esse problema.. e que isso seja resolvido num update do Framework :/

Abraços,

Yan (@yanborowski)

Fala galera! Hoje vim mostrar como fazer um CRUD (Create, Retrive, Update and Delete) com o Entity Framework e ASP.NET MVC 2. Espero que seja útil! Primeiramente, criem um novo projeto ASP.NET MVC 2 Web Application. Agora, vamos lá!

[Parte 1] Modelo com o Entity Framework 4

Bom.. primeiramente vamos criar nosso modelo de dados. Clique com o botão direito em cima da pasta de models e mande adicionar um novo objeto (ADO.NET Entity Data Model). Vamos dar o nome de “EntidadesAgenda.edmx”.

Feito isso, clique no “Add”. A janela do wizard aparecerá perguntando se você deseja criar o modelo baseado em um  banco de dados existente ou começar de um modelo vazio. Marque o “Empty Model” e clique no “Finish”.

Agora nós vamos criar uma entidade “Contato”. Clique com o botão direito na janela em branco do edmx vá em “Add” >> “Entity”. Preencha o campo “Entity Name” com “Contato”. Após preencher o entity name, o campo “Entity Set” estará como “Contatoes”.. troque para “Contatos” e dê ok. Agora você já deve estar vendo a entidade básica, contato, na tela do edmx.

Vamos adicionar mais três propriedades (nome, telefone e celular). Clique com o botão direito na área de Propriedades da entidade e mande adicionar uma nova “Add” >> “Scalar Property”

Após adicionadas as novas propriedades teremos uma entidade como esta:

Agora, clique com o botão direito na área do edmx e clique em “Generate Database from Model”. Siga os passos que o Visual Studio vai gerar o script para o banco no final do processo. Crie o banco e rode o script. Nosso trabalho no model está pronto. Depois irei melhorar algumas coisas aqui.. como tamanhos de campo, etc.

[Parte 2] Views

Bom.. vou utilizar um recurso bem legal do MVC que é o strongly-typed view. Com este recurso podemos criar páginas baseadas em uma classe do modelo. Ao mandar adicionar uma nova View na sua solução vc deve selecionar a classe e, em seguida, indicar qual tipo de tela você deseja: Create, Edit, List, Details ou uma vazia (Empty).

Se você mandar criar a view e não aparecer nada na combo “View Data Class”, feche o diálogo e dê um rebuild na solução, logo em seguida, mande adicionar a view novamente.. a classe estará lá.. “Agenda.Models.Contato” Feito isso.. tcharãã!! Olha nossa view com a grid e prontinha para você dar um F5 e ver como ficou! Certo? Nooot! Temos que criar o controler, oras bolas!

[Parte 3] Controllers

Agora vamos criar o controller para a nossa classe de contatos!

using System.Linq;
using System.Web.Mvc;
using Agenda.Models;

namespace Agenda.Controllers
{
 public class ContatoController : Controller
 {
   EntidadesAgendaContainer model = new EntidadesAgendaContainer();

   public ActionResult List()
   {
     var contatos = model.Contatos.AsEnumerable();

     return View(contatos);
   }
 }
}

Agora >> F5 e vá em “http://localhost:xxxx/Contato/List/”. O que temos lá?! Nossa tela de list funcionando 100%! Faça um teste.. adicione um registro diretamente no banco e atualize a tela. Lá está nosso registro! Vamos agora adicionar o restante das views: New(tipo Create), Edit (tipo Edit) e Show (tipo Details). Nosso controller agora vai ficar assim:

<div id="_mcePaste">using System.Linq;
using System.Web.Mvc;
using Agenda.Models;

namespace Agenda.Controllers
{
    public class ContatoController : Controller
    {
        private readonly EntidadesAgendaContainer model = new EntidadesAgendaContainer();

        public ActionResult List()
        {
            var contatos = model.Contatos.AsEnumerable();

            return View(contatos);
        }

        public ActionResult Show(int id)
        {
            var contato = model.Contatos.AsEnumerable().Where(c => c.Id == id).FirstOrDefault();
            if(contato != null)
            {
                return View(contato);
            }
            return RedirectToAction("List");
        }

        public ActionResult New()
        {
            return View();
        }

        [AcceptVerbs(HttpVerbs.Post)]
        public ActionResult New(string nome, string telefone, string celular)
        {
            var contato = model.CreateObject();
            contato.Nome = nome;
            contato.Telefone = telefone;
            contato.Celular = celular;
            model.AddToContatos(contato);

            model.SaveChanges();

            return RedirectToAction("Show", new {id = contato.Id});
        }

        public ActionResult Edit(int id)
        {
            var contato = model.Contatos.AsEnumerable().Where(c => c.Id == id).FirstOrDefault();
            if (contato != null)
            {
                return View(contato);
            }
            return RedirectToAction("List");
        }

        [AcceptVerbs(HttpVerbs.Post)]
        public ActionResult Edit(int id, string nome, string telefone, string celular)
        {
            var contato = model.Contatos.AsEnumerable().Where(c => c.Id == id).FirstOrDefault();
            if(contato != null)
            {
                contato.Nome = nome;
                contato.Telefone = telefone;
                contato.Celular = celular;

                model.ApplyCurrentValues("Contatos", contato);
                model.SaveChanges();

                return RedirectToAction("Show", new {id = contato.Id});
            }

            return RedirectToAction("List");
        }

        public ActionResult Delete(int id)
        {
            var contato = model.Contatos.AsEnumerable().Where(c => c.Id == id).FirstOrDefault();
            if (contato != null)
            {
                model.DeleteObject(contato);
                model.SaveChanges();
            }

            return RedirectToAction("List");
        }
    }
}

Levei, no total, 30 minutos para fazer esse CRUD (com folga). Podemos ver com isso que o ASP.NET MVC é algo altamente produtivo.

Vocês podem fazer download da solução aqui. Quem baixar a minha solução, deve lembrar de trocar a connection string do Web.config… e não, não deixei meu servidor e minha senha lá, há!

Vou fazer uma segunda parte, onde adicionarei uma tabela com um relacionamento com esta entidade Contato. Espero que essa primeira parte seja útil!

Abraços!

Esse é o primeiro de uma série de posts relacionados ao aprendizado de JQuery que estou desenvolvendo durante algum tempo.
Pra começar uma dúvida que bateu na minha cabeça bem no comecinho, quando ainda estava iniciando com esse framework mágico e confuso. Qual o escopo do this em Javascript?

Vejamos o exemplo:

$(document).ready( function() {
    $('.chBotao').click( function() {
        $(this).addClass('clicado');
        setTimeout( function() {
            $(this).removeClass('clicado');
        }, 1000 );
     });
});

Problema
No exemplo acima a classe clicado é adicionada ao clicar no botão, mas nunca é removida. A intenção era remover depois de 1 segundo através do código inserido dentro da função setTimeout. Mas por que esse código não funciona?

Solução
Salvar o this numa variável antes de chamá-lo no setTimeout:

$(document).ready( function() {
    $('.chBotao').click( function() {
        $elemento = $(this);
        $elemento.addClass('clicado');
        setTimeout( function() {
            $elemento.removeClass('clicado');
        }, 1000 );
     });
});

Porque agora funciona?
O que é o $(this) e por que ele não funciona sempre? É mais fácil entender se separarmos o $(this) em duas partes: $() e this.

O $() parece misterioso, mas não é. Ele é simplesmente uma chamada de função. $ é uma referência para a função jQuery, então é uma forma abreviada de escrever jQuery. É simplesmente uma função que retorna um objeto jQuery.

O this é uma das mais confusas funcionalidades no JavaScipt, porque ele é usada para muitas coisas diferentes. Em Javascript na programação orientada a objetos this é utilizado nos métodos do objeto para referenciar ao próprio objeto.

function Homem( nome) {
    this.nome = nome;
}
Homem.prototype.digaOi = function() {
    alert( "Oi, meu nome é " + this.value + "!" );
};
var joe = new Homem( 'Joe' );
joe.digaOi();  // Oi, meu nome é Joe!

No código de uma chamada de evento, this se refere ao elemento que está recebendo o evento. Mas somente na função diretamente chamada, não na função dentro da função.

<a href="#" id="botao">botao</a>

document.getElementById('botao').onclick = function()
{
    alert(this.id); //botao
    function subFuncao()
    {
        alert(this.id); //undefined
        alert(this === window); //true (OQUE!!!)
    } subFuncao();
}

Como assim no terceiro alert(), o this é um objeto do tipo window?
Por razões históricas, window é o objeto padrão para this quando está dentro de uma função chamada diretamente.
É por isso que no nosso exemplo inicial a função $.removeClass dentro do setTimeout não funciona. Porque o this dentro dela está apontando para window. Dessa forma quando criamos $elemento do lado de fora e armazenamos $(this) nele, permitimos que o this que está do lado de fora da função setTimeout seja usado dentro dela.

[Referência: Alguns trechos são transcrições do livro JQuery Cookbook - Editora O’Reilly Media, Inc. - 2010, pg. 88 a 90]

* ter o despertador avisar a hora de ir dormir, e não a hora de acordar;
* ter uma diéta a base de café, Coca-Cola e RedBull;
* ter fones de ouvidos quase implantados na sua cabeça;
* tomar café da manhã, almoço e janta ao mesmo tempo;
* ter os amigos dizerem “Que bonito isso!” mas não entenderem o conceito;
* refazer um job pois ninguém entendeu o conceito;
* ter mais fotos de coisas do que de sua família;
* saber usar o Photoshop, Illustrator, InDesign e Dreamweaver mas não entender como rodar o Excel;
* comprar revistas de R$ 50 mas não ter tempo de ler;
* não conseguir olhar para qualquer coisa gráfica sem tentar melhorá-la na sua cabeça;
* não conseguir andar pelo shopping sem criticar embalagens de produtos;
* ouvir sua vó lhe apresentar orgulhosamente como “artista” para amigos;
* sua mãe achar que você trabalha com computadores;
* ser confundido como “técnico em informática” pois “você passa muito tempo na frente daquele tal computador”;
* cobrar o cliente constantemente o briefing e materiais para não estourar o cronograma;
* cliente demorar para enviar o briefing e materiais e depois reclamar que você está estourando o cronograma;
* terminar o projeto após 3 meses e 20 rodadas de aprovação para o cliente dizer “não sei…acho que não ficou muito legal”;
* passar metade do projeto convencendo o cliente que você sabe o que está fazendo;
* passar a outra metade do projeto explicando ao cliente que você está cobrando pelo seu conhecimento;
* ter alguém dizer “Meu sobrinho também faz dizáin“. E quando questionado sobre em qual período ele se encontra, escutar um “Tá terminando o Ensino Médio”;
* acordar se sentido um “garoto de programa” pensando em duas coisas: 1) você precisa parar com isso. 2) você precisa cobrar mais caro por isso;
* passar metade da vida falando pra todo mundo que “logomarca” não existe;
* desistir de ensinar a todo mundo que “logomarca” não existe;
* estranhar aquela luz amarela no céu quando você finalmente sai de casa durante o dia;
* ter que explicar a um cliente que uma gráfica não imprime uma imagem JPG com resolução de 72dpi e em RGB para fazer um outdoor;
* ter que explicar ao cliente o que é JPG, dpi, RGB e “cêmique“;
* ter que explicar que Pantone não é aquele pão com frutas cristalizadas que vendem no natal;
* acordar dia após dia, sabendo que essas coisas nunca vão mudar e mesmo assim pensar: “Eu não me vejo fazendo nada melhor na vida. Amo tudo isso”

Fonte: Design Blog

Olá amigos!
Hoje estava modificando o Sistema de Gerenciamento de Processos da empresa e esbarrei com um problema. Precisava dispor dados em uma tabela html mas uma das colunas tinha texto que em determinados momentos poderia ser muito grande. Foi nessa que eu decidi por usar reticências nessa coluna, quando o conteúdo do texto na caber. Eu lembro que há uns três anos atrás precisei em outra situação usar reticências e o único browser que havia implementado de alguma forma essa funcionalidade era o Internet Explorer 6+ através da propriedade csstext-overflow.

Essa propriedade foi incorporada no CSS3 pelo W3C:

Nome	text-overflow
Valor	clip | ellipsis | ellipsis-word
Inicial	clip
Aplicável a	todos elementos display:block
Herda do pai	não

A maioria dos browsers já implementaram essa funcionalidade. O IE6+ e os que utilizam webkit (Safari 1.2+ e Chrome) com a propriedade css text-overflow e o Opera 8.54+ com a propriedade css -o-text-overflow. Infelizmente o Firefox ainda não implementou essa propriedade. Nesse link pode-se votar para essa ser uma das próximas features do Firefox.

Enquanto isso não acontece, existe um plugin de jquery que simula essa propriedade. Você pode ler mais sobre ele aqui, ver um exemplo aqui, e fazer o download do plugin aqui.

Implementando

Para que funcione em todos os browsers é necessário que o elemento tenha largura fixa, tenha a propriedade white-space:nowrap e overflow:hidden. O código abaixo demonstra um exemplo de como deve ser feito em CSS e javascript presumindo-se que o jquery já está carregado na página:

CSS

.ellipsis{
  text-overflow: ellipsis;
  -o-text-overflow: ellipsis;

  width: 350px;
  white-space: nowrap;
  overflow: hidden;
}

Javascript

$(document).ready( function()
{
    $('.ellipsis').ellipsis();
});

Bom é isso aí. No final de tudo acabou que eu não precisei usar as reticências na tabela porque decidi que ia ser multilinha. Mas tá aprendido e espero que a dica seja útil para outras pessoas.

Todo programador web que se preze precisa manter atualizado pelo menos mais de um website, com isso vem o grande problema de tempo que essa atividade consome para manter todos eles com o código mais atualizado, seja ambiente de produção ou ambiente de testes.
Para essa atividade todos sabem que o Visual Studio nunca forneceu uma ferramenta boa para publicar os arquivos necessários (talvez somente os alterados) diretamente no servidor.

É um verdadeiro pé-no-saco, além de tempo perdido, ter que sincronizar os arquivos locais e os arquivos do servidor de um website de médio/grande porte e no final descobrir que você, executando manualmente essa tarefa, esqueceu de enviar/apagar ou atualizar um arquivo no lado do servidor que era peça crucial para funcionamento do site e quem descobre isso é o seu chefe (lei de Murphy), não é?

Por muito tempo eu me perguntei se outro desenvolvedor com o mesmo problema que eu não teria feito um software capaz de fazer esse trabalho automaticamente de forma eficaz, já cheguei a analisar alguns outros sincronizadores de FTP que não me foram úteis. Quando estava prestes a desenvolver uma solução para meus problemas (um builder-publisher em Python mesmo para rodar num micro de build), encontrei o Dispatch for ASP.NET que após algumas horas de testes com essa ferramenta me fez ver que outro desenvolvedor cansado de esperar por uma solução integrada do Visual Studio já teve os mesmo problemas que o meu.

A configuração é simples, bastando apenas algumas informações de acesso FTP.

Dispatch funciona como um add-on para o Visual Studio, fica em uma janela que você visualiza toda a estrutura do site parecida com a janela de Solution Explorer. Para sincronizar os arquivos basta selecionar os arquivos que deseja e clicar num botão para sincronizar com o servidor.

Conforme você vai editando os arquivos localmente o Dispatch já detecta a alteração e coloca o arquivo na fila para upload posterior.

Além de tudo isso, se você trabalha com um ambiente de teste e um ambiente de produção vai se surpreender com a funcionalidade de “Deployment Modes” onde com apenas um combobox você pode alterar o ambiente que deseja publicar, inclusive em servidores diferentes.
Em cada ambiente você pode fazer vários ajustes como por exemplo:
- Alterar a string de conexão do web.config quando quiser que ela aponte para um banco de dados de produção usando o String Replacement.
- Alterar o modo debug para “false” quando for publicar em produção.

Apesar de essas funções serem muito úteis eu ainda sinto falta de poder utilizar expressão regular na função de String Replacement, o que agilizaria bastante o trabalho. Outro problema é não ter uma forma simples de usar o Dispatch via linha de comando, se tivesse eu poderia fazer um script de build onde não seria feito a publicação somente se eu apertasse o botão de publicar e sim sob outras condições como “Commit” por exemplo… Mas quem sabe em outras atualizações do software…

Espero que essa dica ajude você que, assim como eu, gastou muito do seu tempo de programador com sincronização de arquivos.

A ferramenta possui uma versão de avaliação que pode ser usada por 30 dias, a versão paga não chega aos U$ 30,00 dólares, diga a seu chefe que essa ferramenta vai se pagar em menos de 1 dia com a economia de tempo que vai te trazer, além de eliminar a grande possibilidade de fazer bobeira ao publicar manualmente.

Dispatch for ASP.NET

Depois de alguns dias, a equipe definitivamente tomou uma atitude e parou para tirar uma foto para postar aqui no blog. Não, não somos tão velhos assim. Nossa equipe com sangue novo correndo atrás das soluções aqui da empresa todos os dias. Tendo que enfrentar um Bad Sever aqui, um problema de navegação ali… enfim, gostamos do que fazemos. Esse é o primeiro passo para se “viver” bem no trabalho. Nosso blog tem como objetivo divulgar nossas ideias, pesquisas e problemas que acontece em nosso dia a dia.

Olá Javascript Coders,

Recentemente aqui na empresa precisei fazer um plugin de jQuery que guardasse ações para que fossem chamadas mais tarde, seja por bind de eventos ou seja por ações registradas no histórico do navegador (esse plugin será publicado aqui no site em breve). O resultado foi um plugin cheio de métodos externos auxiliares que utilizava um outro plugin (jquery.history) para fazer o trabalho. Resolvi chamar esse plugin de jquery.actionbox em homenagem ao @carloshbaia.

Ontem tive um tempo livre e pensei: “porque não refatorar esse plugin e colocar os métodos externos pra dentro dele como métodos privados?” Foi nessa que eu esbarrei numa das limitações do javascript no que diz respeito a orientação a objetos. Métodos privados em javascript? Será que tem? Pesquisando no google achei uma forma interessante de fazer essa implementação.

Vamos supor que precisamos de uma classe chamada Person que tem os métodos getName() e setName() públicas, e o método think() e a propriedade name privados. Como seria essa implementação? Eis a solução proposta:

function Person()
{
    /*private*/
    var name = '';
    var think = function()
    {
        return;
    };

    /*public*/
    return
    {
        setNome: function(newName)
        {
            name = newName;
        },
        getName: function()
        {
            think();
            return name;
        }
    }
}

Nessa implementação, conseguimos ter métodos privados dentro de uma classe, sendo que precisam ser declarados dentro do objeto de retorno. Tudo que estiver fora do return será considerado privado, ou seja, não pode ser chamado do lado de fora da classe, mas pode ser chamado pelos métodos públicos.

Bom é isso aí pessoal, espero que tenha sido útil e até a próxima…

Fonte:
JQuery HowTo

Opa! Boa noite pessoal!

Estava aqui pela internet quando li um post do Otávio Pecego sobre utilização de templates T4 do DotNet para montar um gerador de código. É possível? Sim, é! =)

Fiz um exemplo bobinho (e bem cru) só para ver se era simples de montar uma Classe usando um template. Dá para melhorar isso muito mais, como eu falei isso é só um exemplo de laboratório.

A saída dos templates é feita através da primeira linha

<#@ template language="C#" #>

Essa saída pode ser modificada. Estou usando c# pq estou gerando uma Classe, okay? =)

Tudo que é escrito no template é escrito diretamente no arquivo de saída. O que está entre ” <# code #> ” é interpretado e não vai para o arquivo de saída. O que é escrito em “<#= #>” é interpretado como uma variável (e seu valor é impresso na saída do template).

Depois da visão geral, vamos ao primeiro passo:

ClassTemplate.tt

Aqui eu criei um template para a estrutura das Classes. Existe uma variável “NameSpace” e outra “ClassName” (elas serão alteradas no template seguinte, calma!) . Declarei uma matriz onde eu adicionei as propriedades da classe nas linhas e seu valores nas colunas de cada linha(nome / tipo).

<#@ template language="C#" #>
using System;

namespace <#=this.NameSpace #>
{
	public class <#=this.ClassName #>
	{
      <#
      for(int x=0; x < Properties.GetLength(0); x++)
      {
	  string newProperty = "public ";
	  for(int y=0; y < 2; y++)
	  {
	  	newProperty += Properties[x,y];
	  }
	  #>
	  	<#=newProperty + @" {get; set;} " #>
	  <#
      }
      #>

	}
}

<#+
string ClassName = "MyClass";
string NameSpace = "Generated.Classes";
string[,] Properties = new string[0,0];
#>

Próximo Passo:

ClassPerson.tt

Aqui está o pulo do gato. Neste template eu preencho as variáveis que foram declaradas no ClassTemplate.tt e logo depois dou um Include no mesmo para que os valores das variáveis sejam sobrescritos e o interpretador gere o ClassPerson.cs

<#
	this.ClassName = "Person";

	this.Properties = new string[3,2];
	this.Properties[0,0] = " int ";
	this.Properties[0,1] = " Id ";

	this.Properties[1,0] = " string ";
	this.Properties[1,1] = " Name ";

	this.Properties[2,0] = " int ";
	this.Properties[2,1] = " Age ";
#>
<#@ include file="ClassTemplate.tt" #>

A saída do ClassPerson.tt é a seguinte:

using System;

namespace Generated.Classes
{
	public class Person
	{

	  	public  int  Id  {get; set;}

	  	public  string  Name  {get; set;}

	  	public  int  Age  {get; set;}

	}
}

Logo depois que o template foi interpretado, a classe já está disponível para utlização no restante do projeto (basta adicionar o namespace)

using System;
using Generated.Classes;

namespace Gerador
{
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person();

        }
    }
}

O resultado pode ser baixado aqui.

O exemplo ficou bem basicão.. mas essa era a idéia. Aproveitem e tornem isso algo utilizável na vida de vocês

Abraços,

Yan Borowski (@yanborowski)