Quando instalei a minha nova máquina considerei a hipótese de instalar o Windows Server 2008 com Hyper-V. Mas esta é a minha máquina pessoal e não o meu servidor e eu gosto de coisas mais desktopy na minha máquina pessoal e não tenho necessidade de ter máquinas virtuais sempre a correr, pensei que o Windows Vista com Virtual PC 2007 (embora ter suporte para máquinas vituais x64 fosse bom) seria a escolha certa.
Ontem estava a experimentar a Developer Interface da InnerWorkings e não conseguia porque o Internet Explorer teimava em lançar erros de Internet Explorer Enhanced Security Configuration a partir do add-in da InnerWorkings para o Visual Studio que bloquava o Visual Studio.
Eu sei que o Rui usa o Windows Server 2008 como sistema operativo do seu laptop (assim como o António) e lembrei-me de perguntar ao Rui como é que me podia livrar da Internet Explorer Enhanced Security Configuration. O Rui indicou-me as seguintes entradas de blogues:
Passando pela série de entradas do blogue da Systweak acerca do Windows Server 2008 Desktop (ver abaixo) quase me fez arrepender ter instaldo o Windows Vista em vez do Windows Server 2008. Mas o meu próximo laptop vai correr Windows Server 2008.
Windows Server 2008 Desktop
Ontem escrevi acerca da causa da lentidão dos validadores e sumário de validadores do ASP.NET.
Naquele momento não tinha conhecimento da existência da configuração de conformidade XHTML (obrigado Nuno).
Com a configuração de conformidade XHTML definida como Legacy, a tradução das propriedades dos controlos para o documento HTML é feita como no ASP.NET 1.1.
Quando se desenvolvem páginas ASP.NET, se se usarem muitos validadores e sumários de validadores, as páginas podem-se tornar muito lentas. Já se perguntaram porquê?
Vamos construír uma página simples com alguns validadores. Algo deste género:
A página é composta por:
O ASP.NET traduz o ValidationSummary para um DIV e cada validador para um SPAN usando expando attributes para adicionar propriedades aos elementos.
De acordo com a documentação, os expando attributes são definidos dinamicamente em JavaScript para preservar a compatibilidade com o XHTML.
O problema é que todo esse JavaScript faz com que o documento HTML fique maior e mais lento de executar do que se as propriedades tivessem sido traduzidas para HTML como atributos dos elementos.
Para uma página tão pequena, a diferença aproxima-se dos 2k bytes. Se se adisionarem umas dúzias de validadores à página, a lentidão fica mais evidente.
Sou totalmente a favor de normas rigorosas e o cumpirmento das mesmas, mas, neste caso, era bom que o XHTML permitisse atributos aribtrários.
O Mehfuz tem vindo a desenvolver uma ferramenta para criar provedores de LINQ e está no CodePlex: LINQExtender
Ele até o usou para desenvolver um provedor e LINQ para o flickr: LINQ.Flickr
No próximo de 21 de Junho de 2008 (sábado) vai ter lugar, no auditório da Microsoft Portugal, o 4º Seminário De Tecnologias Móveis PocketPT.
Inscrevam-se antes que acabem as inscrições.
O Nuno Filipe Godinho, MVP de ASP.NET, está a apresentar uma série de seminários avançados sobre vários temas na Actual Training.
A selecção de assuntos e o seu conteúdo pareceu-me muito interessante.
O desenvolvimento de software é ainda uma tarefa muito orientada ao humano. As linguagens de programação de alto nível ainda são uma forma de linguagem para ser lida por humanos.
Por isso, mais cedo ou mais tarde, vai ser necessário comparar ficheiros.
Esta é uma lista de ferramentas de comparação de ficheiros e pastas com que tive contacto.
WinDiff
O WindDiff é uma ferramenta gratuita da Microsoft que acompanha as ferramentas de suporte e software development kits.
É antiga e não tem muitas funcionalidades, mas consegue comparar ficheiros e pastas.
WinMerge
Também gratuito, o WinMerge tem mais algumas funcionalidades que o WinDiff.
KDIff3
O KDiff3 também é gratuito e pode lidar com dois ou três ficheiros ou pastas.
Ao contrário das anteriores , O KDiff3 é uma ferramenta multi plataforma.
Compare It!
O Compare It!, da Grig Software, não é gratuito (a não ser que se possua uma licença do ApexSQL Diff), mas não é caro. Esta ferramenta reconhece vários formatos de ficheiro como MS Word, Excel, PDF e RTF e tem coloração de sintaxe para C++, Java, C#, Delphi e HTML.
Araxis Merge
O Merge, da Araxis, é, na minha opinião, a melhor ferramenta de comparação de ficheiros e pastas existente no mercado. Imaginem que até compara imagens. Tem um Virtual File System (VFS) API e é fornecido com plugins para Perforce e Visual SourceSafe (falta um plugin para o TFS).
Não é gratuita, mas a lista de funcionalidades é muito rica.
O espaço das ferramentas para arquitectura de software em vindo a crescer. Têm vindo a aparecer novas ferramentas e as já existentes continuam a ser melhoradas.
Framework Design Studio
No passado mês de Abril, o Krzysztof Cwalina da Microsoft lançou o seu Framework Design Studio na MSDN Code Gallery.
A ferramenta permite comparar duas versões de uma assembly para identificar diferenças na API: adições e remoções. Comparar duas versões de APIs é muito útil durante o processo de desenho da API. Frequentemente é necesário garantir que não sejam removidas coisas acidentalmente (o que pode causar incompatibilidades), e quando as APIs crescem, é necessário efectuar uma revisão às APIs adicionadas sem que se tenha de rever APIs que já foram revistas. A ferramenta, chamada Framework Design Studio (FDS) suporta estes cenários. - da entrada no blog do Krzysztof's
Lattix
A Lattix continua a melhorar o seu Architecture Management System composto por duas ferramentas:
-
-
Lattix LDV para equipas de desenvolvimento e de qualidade
As ferramentas da Lattix podem ser usadas nos seguinte ambientes:
O sítio tem muitos recursos na secção Getting Started que podem ser usados para avaliação prévia das ferramentas:
- Descarregar uma versão ensaio do Lattix LDM
- Percorrer as funcionalidades da ferramenta
- Assistir a uma demonstração ao vivo
- Avaliar a utilização da ferramenta
- Testar um projecto de arranque
A última versão (Lattix 4.1) foi lançada a 21 de Abril de 2008.
NDepend
O NDepend, do meu colega MVP de C# Patrick Smacchia, pode apenas ser usado na .NET Framework (fiquem atentos para novidades neste campo) também está em contínuo melhoramento. A sua UI é mais familiar para utilizadores do Microsoft Visual Studio e do Microsoft Office que a do Lattix e tem uma funcionalidade espectacular:
-
Code Query Language (CQL) que permite que o código seja considerado uma base de dados que pode ser questionada para verificar asserções
O sítio tem muitos vídeos (tanto na página Home como na página Getting Started) e documentação sobre todos os conceitos usados pela ferramenta.
A última versão (NDepend 2.8.1) foi lançada a 26 de Abril de 2008.
ApexSQL Enforce
O ApexSQL Enforce, da ApexSQL, é para ser usada em bases de dados SQL Server e permite:
-
Froçar a adesão aos padrões de desenho em "tempo real"
-
Facilitar migrações para novas versões de SQL Server indentificando potenciais problemas de conversão antes da base de dados ser transferida
-
Reverter ou corrigir automaticamente violações detectadas usando scripts "FixSQL" gerados
-
Forçar o cumprimento de convenções de nomenclatura e garantir que palavras reservadas de SQL e caracteres especiais não são usados
O sítio tem muita informação sobre o produto:
A última versão (2008.02) foi lançada a 26 de Março de 2008.
Nota: Código em itálico não corresponde à sintaxe do C# 3.0.
Inferência do tipo de variáveis locais
O C# 3.0 trouxe-nos a possibilidade da inferência do tipo de uma variável local, cujo principal objectivo foi suportar o LINQ. O resultado de uma consulta (query) pode ser uma implementação de IEnumerable<T> ou IQueryable<T> uma instância de T onde T pode ser uma projecção, o que implica que T é um tipo anónimo.
Tomemos a consulta seguinte como exemplo:
from p in persons
select new { Name = p.FirstName + " " + p.LastName, Age = p.Age };
Se persons for uma implementação de IEnumerable<Person>, o resultado da consulta será uma implementação de IEnumerable<T> onde T é um tipo anónimo.
Coloca-se então uma questão: Como é que declaramos uma variável para receber o resultado da consulta?
A solução encontrada foi a introdição da nova palavra-chave var que instrui o compilador para determinar o tipo do resultado da consulta. Sendo assim, tudo é que é ncessário para declarar uma variável para receber resultado da consulta é:
var q =
from p in persons
select new { Name = p.FirstName + " " + p.LastName, Age = p.Age };
Uma vez que o compilador consegue inferir o tipo de algo que arece tão complexo, é óbvio que será capaz de inferir o tipo de algo tão simples directo como:
var v = new Dictionary<Point, Stack<Person>>();
Obviamente, é o mesmo que:
Dictionary<Point, Stack<Person>> v = new Dictionary<Point, Stack<Person>>();
com menos digitação e menor margem para erros de digitação.
Inferência do tipo de campos
A mesma técnica poderia ser aplicada à inferência do tipo de campos:
class Class
{
private someDicionary = new Dictionary<string, List<string>>();
// ...
}
com os mesmos benefícios de menos digitação e menor margem para erros de digitação.
Se a inferência do tipo de campos fosse aplicada a campos públicos, deveria ser aplicado o seguinte constrangimento: o tipo inferido não pode ser ou ter como parâmtero um tipo anónimo.
Mas eu não recomendaria o seu uso porque facilmente uma simples modificação na inicialização do campo poderia trazer alterações menos óbvias à interface pública da classe.
Inferência do tipo de parâmetros e retorno de métodos
Dado que a inferência de tipos seria possível fora de métodos, deveria ser permitida em parâmetros e valores de retorno? Algo como isto:
class SomeClass
{
private listOfStuff = new List<Stuff>();
public void DoIt()
{
if (CreateList(out this.listOfStuff))
{
ProcessList(ref this.listOfStuff);
this.listOfStuff = TransformList(this.listOfStuff);
}
}
private bool CreateList(var out list)
{
list = new List<Stuff>();
return true;
}
private void ProcessList(var ref list)
{
// ...
}
private var TransformList(var list)
{
return list;
}
}
que tem um aspecto algo estranho e confuso, no mínimo. Não deveríamos ir por aí.
Inferência de construtores
Desde o meu primeiro contacto com a inferência do tipo de variaveis locais que tenho a sensação de que se poderia ter ido mais longe.
Olhemos para este conjunto hipotético de declarações:
Dictionary<Point, Stack<Person>> v = new();
Point p = new(1, 2);
Será fácil, tanto para o compilador como para um humano que leia o código, determinar que é o mesmo que:
Dictionary<Point, Stack<Person>> v = new Dictionary<Point, Stack<Person>>();
Point p = new Point(1, 2);
E isto pode ser mais poderoso que a inferência do tipo de variáveis locais e usado em mais cenários:
class Class
{
private Dictionary<string, List<string>> someDicionary = new();
private Point p;
public Class()
{
this.p = new(1, 1);
}
public void SomeMethod()
{
AnotherMethod(new());
}
private void AnotherMethod(List<string> arg)
{
// ...
}
}
Onde parar?
O compilador poderia com igual facilidade inferir o tipo da variável local neste caso:
public void SomeMethod()
{
var v = new();
AnotherMethod(v);
}
Queremos ir por aí? Não me parece.
Ambiguidades
O C# 3.0 trouxe-nos também inicializadores de objectos. Em vez disto:
XmlReaderSettings settings = new XmlReaderSettings();
settings.CheckCharacters = false;
settings.IgnoreWhitespace = true;
XmlReader reader = XmlReader.Create("someURI", settings);
podemos apenas escrever isto:
XmlReaderSettings settings = new XmlReaderSettings() { CheckCharacters = false, IgnoreWhitespace = true };
XmlReader reader = XmlReader.Create("someURI", settings);
ou isto:
XmlReader reader = XmlReader.Create("someURI", new XmlReaderSettings() { CheckCharacters = false, IgnoreWhitespace = true });
Não seria bom escrever apenas isto?
XmlReaderSettings settings = new() { CheckCharacters = false, IgnoreWhitespace = true };
Os inicializadores de objectos do C# 3.0 também permitem omitr os parentesis do construtor:
XmlReaderSettings settings = new XmlReaderSettings { CheckCharacters = false, IgnoreWhitespace = true };
que levaria a:
XmlReaderSettings settings = new { CheckCharacters = false, IgnoreWhitespace = true };
que tem a mesma forma que a criação de um objecto de um tipo anónimo e poderia causar algumas ambiguidades.
Mas seria bom escrever apenas isto:
XmlReader reader = XmlReader.Create("someURI", new { settings.CheckCharacters = false, settings.IgnoreWhitespace = true });
Não seria?
Deparei-me com isto hoje:
Framework Design Studio é um conjunto de feramentas para desenvolvimento de bibliotecas reutilizáveis. O pacote contem uma ferramenta GUI para visualizar, rever e comparar versões de APIs managed. Também contem uma ferramenta de linha de comando para gerar relatórios de diferenças entre APIs.
Parece ser um grande ferramenta para verificar se a nova versão da nossa plataforma não vai quebrar alguma API disponibilzada anteriormente.
Apesar de se honrar as APIs anteriormente disponibilizadas, a nova versão da nossa plataforma pode intorduzir alguns efeitos colaterais, e para o descobrir terá de ser utilizada outra ferramenta: o NDepend.
Recentemente, questionaram-me (relacionado com os meus artigos [^] [^] sobre compressão HTTP) se seria possível comprimir o conteúdo da chamada a um web service.
O modo como a compressão HTTP funciona (tanto quanto sei) é através do cliente anunciar ao servidor (usando o header HTTP accept-encondig) quais os métodos de compressão que é capaz de descomprimir.
Se o servidor for capaz de usar um dos métodos de compressão aceites pelo cliente, comprime a resposta e especifica o método de compressão usado (usando o header HTTP content-encoding).
Geralmente o cliente não sabe se o servidor aceitará qualquer tipo de compressão, por isso não lhe deve impor qualquer compressão.
Uma forma de possibilitar a compressão do pedido HTTP seria enviar o pedido comprimido (especificando o método usado no header HTTP content-encoding) que seria tratado pelo servidor no evento BeginRequest através de um filtro (HttpResponse.Filter) capaz de descomprimir o pedido. Deste modo seria transparente o tratamento do pedido.
NOTA: Não testei isto.
Enquanto tentava instalar o Visual Studio 2008 Team Suite na minha máquina com Windows XP Professional, a instalação falhava sempre ao instalar o Visual Studio porque não encontrava o Web Authoring Component (após o ter instalado com sucesso).
Procurei pela ocorrência deste problema, mas não encontrei ninguém a queixar-se do mesmo.
Tentei instalar manualmente o Web Authoring Component (encontra-se no DVD - \WCU\WebDesignerCore\WebDesignerCore.EXE) antes, mas a instalação falhava sempre no mesmo ponto e pela mesma razão que anteriormente. E, mais estranho ainda, aoós a tentativa o Web Authoring Component já não estava instalado.
Ao consultar o registo da instalação (%temp%\dd_depcheck_VS_VSTS_90.txt) encontrei isto:
Microsoft Visual Studio Web Authoring Component ==
This component uses the FileRegVerCheck version check method. It will compare a given version against the version of a regkey on your machine.
Registry key being interrogated: HKLM,SOFTWARE\Microsoft\Web Designer Tools\1033; Value: InstalledVersion; Version: 12.0.4518.1066.
Version on user's machine: 12.0.4518.1064
Version to be installed: 12.0.4518.1066
Microsoft Visual Studio Web Authoring Component == Component to be installed.
Instalei novamente o Web Authoring Component e alterei no registry o valor da versão instalada para aquela que o instalador do Visual Studio esperava. Depois instalei o Visual Studio sem mais problemas. Parece estar tudo a funcionar bem.
O que eu acho mais estranho não é o facto de o Web Authoring Component que vem no DVD ter a versão errada. O que eu acho mais estranho é o facto de eu já ter instalado anteriormente o Visual Studio usando o mesmo DVD e sem qualquer problema.
| Sistema Bom |
Sistema Mau |
| Windows Vista Ultimate 64bit with SP1 (instalação de raíz) |
Windows XP Professional with SP2 |
| Office 2007 with SP1 (instalação de raíz) |
Office 2007 with SP1 (actualização do Office 2003) |
| |
Visual Studio 2003 |
| |
Visual Studio 2005 with SP1 |
| |
Expression Web |
O instalador do Web Authoring Component usa um wrapper do Office 2007. Será isto a origem do problema?
Durante o TechDays Portugal 2008 a Microsoft Portugal e a JP Sá Couto S.A., através da sua marca Tsunami, lançaram o primeiro equipamento Português com o Windows Home Server instalado: o Tsunami Tidal.
Para assinalar o evento, a Tsunami levou a cabo um concurso em que oferecia um equipamento destes a quem apresentasse a melhor frase para caracterizar o equipamento.
Quando se fala de Web 2.0, Enterprise 2.0, Life 2.0 e num evento que apelava a um World 2.0, a frase que me veio de imediato à mente foi: Para a Família 2.0.
E foi com esta frase que ganhei o concurso.
Como no momento da cerimónia de apresentação e entrega do prémio me encontrava a apresentar a minha sessão, a Tsunami gentilmente acedeu a que eu pudesse receber o prémio via proxy, no caso, o meu amigo Nuno Gomes.
Vejam os vídeos e as fotos do evento.
Foi encontrado no recinto do TechDays um conjunto de vários suportes electrónicos de dados que serão entregues a quem provar que lhe pertencem.