Communicare (((vs)))

Asp.net Timer (C#)

2009-03-24T23:52:00.005-03:00

Este é um exemplo simples de como atualizar automaticamente o conteúdo de um UpdatePanel através de um controle Timer do ASP.NET - nada muito diferente.

Talvez a única observação interessante a acrescentar seja que o timer é definido como sendo um gatilho (trigger) externo ao UpdatePanel. Dessa maneira, o conteúdo do painel é atualizado automaticamente a cada ciclo do timer, sem que o restante da página seja afetado.


‹%@ Page Language="C#" AutoEventWireup="true"
CodeFile="Default.aspx.cs" Inherits="_Default" %›

‹!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"›
‹html xmlns="http://www.w3.org/1999/xhtml"›
‹head runat="server"›
  ‹title›Exemplo: ASP.NET Timer‹/title›
‹/head›
‹body›
  ‹form id="form1" runat="server"›
     ‹!-- necessário para ajax.net --›
     ‹asp:ScriptManager ID="ScriptManager1" runat="server" /›
     ‹div›
         ‹!-- timer que atualiza o updatepanel --›
         ‹asp:Timer ID="timer" runat="server" Interval="1000"
         Enabled="true" OnTick="timer_Tick"›‹/asp:Timer›

         ‹!-- região a ser atualizada --›
         ‹asp:UpdatePanel ID="UpdatePanel1"
         runat="server" UpdateMode="Conditional"›
            ‹Triggers›
               ‹asp:AsyncPostBackTrigger ControlID="timer"/›
            ‹/Triggers›
            ‹ContentTemplate›
               ‹!-- controles afetados --›
               ‹asp:Label ID="Label1" runat="server"›
               ‹/asp:Label›
            ‹/ContentTemplate›
        ‹/asp:UpdatePanel›
     ‹/div›
  ‹/form›
‹/body›
‹/html›

Também é interessante observar que, numa situação mais específica como, por exemplo, UpdatePanels aninhados, alguns comportamentos esdrúxulos podem aparecer. Neste caso, talvez ajude incluir a propriedade RenderMode="Inline" na declaração do UpdatePanel.

E o code behind da página:


using System;
using System.Web.UI;

public partial class _Default : System.Web.UI.Page
{
  protected void Page_Load(object sender, EventArgs e)
  {
     if (!IsPostBack)
        timer.Tick += new EventHandler‹EventArgs›(timer_Tick);
  }

  public void timer_Tick(object sender, EventArgs e)
  {
     Label1.Text = DateTime.Now.ToString();
  }
}

Como o ambiente é naturalmente lento, a frequência de atualização deve ser estimada com cuidado.

Links Python

2009-03-13T23:03:00.002-03:00

Python

The Python Challenge

PyGame

Custom Events em C#

2008-12-11T20:33:00.004-02:00

Segue um exemplo sobre como criar eventos personalizados em C# e usá-los para realizar ações assim que um processamento mais demorado for concluído, deixando a thread principal da aplicação livre para outros trabalhos.

(This is a sample application written in C# that demonstrates how to trigger some action when an expensive function finishes its job.)

Para testar, basta criar uma aplicação do tipo console com o código abaixo:

using System;
using System.Threading;

namespace ConsoleApplication1
{
  class Program
  {
      static void Main(string[] args)
      {
          for (int myNum = 0; myNum ‹ 5; myNum++)
          {
              // Objeto de teste
              CTest ct = new CTest();

              // Método que será executado após o
                // término do processamento demorado.
              ct.TestCompleted += new CTest.TestEventHandler(
                  ct_TestCompleted);

              // Roda o método demorado, liberando
                // a aplicação principal.
              new Thread(new ParameterizedThreadStart(
                  ct.Test)).Start(myNum);
          }
      }

      // Sinaliza o término da tarefa.
      static void ct_TestCompleted(
          object sender, CTest.TestEventArgs e)
      {
          // Os parâmetros estarão no objeto (e)
          Console.WriteLine("Completed: " + e.j);
      }
  }

  class CTest
  {
      // Este é o método demorado.
        // "myNum" Apenas identifica as threads.
      public void Test(object myNum)
      {
          // Sinaliza o início da tarefa
          Console.WriteLine("Starting: " + myNum);

          // Simula um processamento demorado
          Thread.Sleep(3000);
        
          // Dispara o evento ao terminar
          RaiseTestCompleted((int)myNum);
      }

      // Nesta classe são definidos
        // objetos para uso posterior.
      public class TestEventArgs : System.EventArgs
      {
          public int j; // um exemplo
          public TestEventArgs(int j)
          {
              this.j = j;
          }
      }

      // Declaração de um delegate
        // e um evento auxiliares
      public delegate void TestEventHandler(
          object sender, TestEventArgs e);

      public event TestEventHandler TestCompleted;

      // Este método prepara os parâmetros
        // e dispara o evento assíncrono.
      private void RaiseTestCompleted(int j)
      {
          TestEventArgs args = new TestEventArgs(j);
          OnTest(this, args);
      }

      protected virtual void OnTest(
          object sender, TestEventArgs e)
      {
          if (TestCompleted != null)
              TestCompleted(this, e);
      }
  }
}

Em passos gerais, é criada uma classe TestEventArgs com os objetos que serão expostos via argumentos da função executada logo após o término do processamento demorado.

Neste exemplo, disparo 5 threads que demoram alguns segundos. Note que, devido à concorrência do sistema, ocasionalmente elas podem finalizar fora de ordem.

Talvez um pouco confuso à primeira vista, mas muito útil em diversas aplicações.

Deserto Verde

2008-12-04T01:28:00.013-02:00

Relato de uma viagem a serviço de São Carlos/SP a Aracruz/ES, com uma esticada até Teixeira de Freitas/BA - uma brincadeira de 3.600km pelo deserto verde, ou Aracruz Celulose, como preferir.

Eu de Volta

2008-11-20T21:04:00.006-02:00

Limpando as teias das aranhas que andam por aqui...

Resumindo, desde minha evolução da Kaizen Games para a AGX Tecnologia em julho/2008, tenho estado bem ocupado e deixei este blog às traças (não que fosse muito útil).

Saí de Sampa para São Carlos City e me envolvi com sistemas georreferenciados e sistemas embarcados. Tenho usado MapServer e PostgreSQL/PostGIS com C# (sim, é possível), microcontroladores PIC, MPLAB, linguagem C, meus velhos amigos Delphi e Visual Studio, e outras coisas open source.

Quando possível, ainda tento brincar com SDL em C++ e Python (PyGame), estudar redes neurais artificiais, ler Nietzsche, Bertrand Russell e Geraldão, assistir Fudêncio e passar um tempo no Ubuntu.

Continuo ouvindo Clannad, Joy Division, Haggard, Eluveitie, Los Orishas e Raul Seixas, obviamente.

Enfim, pretendo voltar a compartilhar algumas coisas que aprender - porém daqui alguns dias - neste final de semana devo viajar a serviço para Aracruz/ES. A proprósito: a 20km de uma praia de nudismo... hehehe

E os churras continuam os mesmos - ou melhores.

Novos Blogs de Programação

2008-06-01T13:37:00.004-03:00

Enfim tomei coragem (e juízo) para iniciar um novo blog, especializado em programação para Second Life. Chamei-o de Hello, Avatar! por motivos óbvios e é outro blog apenas por organização, pois os demais tópicos varzeados em geral vão continuar por aqui.

Também pretendo, muito em breve, iniciar um outro voltado para a programação de jogos, que chemei de AVE MVNDE (advinhe por quê). Porém, como meus conhecimentos e experiência nesta área ainda são bem limitados, este outro blog será populado com as evoluções dos meus estudos, mas já iniciará com algum conteúdo prático como C++ e SDL, sprites, simulação de física e detecção de colisões. Mais à frente, pretendo abordar também sobre C# e XNA.

A Era dos Videogames

2008-05-27T21:38:00.006-03:00

Já faz um bom tempo que o Discovery Channel disponibilizou uma série sobre a história dos videogames, mas ainda há um link para uma versão interativa do documentário, chamado de A Era do Videogame.

É um trabalho interessante, à altura do Discovery Channel, e divertido, pois o leitor obtém as informações conforme progride em pequenos games. O material abrange desde os primórdios na década de 70 até os dias atuais. Vale ver.

Aproveitando o link, tem um joguinho legal brazuca de corrida com ótimos gráficos: Bucking Fuggy. E para quem quiser relembrar um crássico, aqui tem o Prince Of Persia rodando direto no browser.

Cumprida a obrigação, agora vem a diversão: se der cara, C# (libsecondlife). Se der coroa, C++ (SDL). Coroa venceu.

José Saramago

2008-05-27T21:29:00.004-03:00

"Quero recordar-lhes que, sem vaidade, eu também nasci num lugar pobre, de analfabetos. Em minha infância não tive livros, nem televisão, internet ou playstation, mas quem não tem nada sempre inventa algo. Jamais se aborrece." José Saramago

The Fódest Game

2008-05-15T18:31:00.001-03:00

Mais um joguinho para descontrair: The World's Hardest Game

Não é novidade, mas é legal.

Second Life and the Public Good

2008-05-08T00:09:00.014-03:00

Uma parceria entre a USP e a Kaizen Games resultou em mais uma ilha incluída na Mainland Brasil, destinada a um projeto de e-learning chamado Cidade do Conhecimento. Até aí nada impressionante, embora seja uma boa notícia e de interesse público. Começa a melhorar quando me foi delegada a nobre tarefa de entrar em contato com Tori Horton, da University of Southern California (USC), e conseguir uma cópia de um auditório para o projeto.

Após alguns e-mails, recados na secretária eletrônica, mensagens off-line e outros desencontros como o fuso horário, finalmente nos encontramos in-world. Na ocasião, ela teria um evento iniciando em precisos 7 minutos e não poderia tratar sobre o anfiteatro naquele momento, mas me convidou para participar.

Teletransportei-me então para a International Island, onde Cory Ondrejka, uma das pessoas mais importantes para o desenvolvimento do Second Life na Linden Lab até o ano passado (ao lado do ex-CEO Phillip Rosedale), e Douglas Thomas, professor associado na Annenberg School for Communication da USC, convidavam os residentes a imaginar meios pelos quais os ambientes virtuais como o próprio Second Life poderiam contribuir para com o bem-estar geral da população. Os melhores trabalhos ainda poderão ser patrocinados, como descrito no site do projeto, pela própria Tori Horton, que foi muito atenciosa.

Ao final do evento, ao acionar por descuido meu microfone e despertar interesse em alguns residentes pelo idioma "não identificado", em particular Rhiannon Chatnoir, integrante do The Vesuvius Group, mais um novo e interessante contato estava feito.

Depois disso tudo, alguém ainda poderia perguntar:

- Por quê usar Second Life?

e eu poderia responder simplesmente:

- Porque SL é um ambiente virtual em três dimensões interativo e em tempo real que possui uma infra-estrutura sofisticada, ampla e relativamente simples de aprender e usar. Permite, através de pequenos scripts em alto nível, o uso de recursos como simulação de física ou comunicação web via requisições http.

mas esta experiência me mostrou que o ambiente virtual é realmente intangível e pode ir muito além dessa resposta superficial.

Win32 API Tutorial

2008-05-06T22:04:00.006-03:00

Segue um excelente tutorial online (em inglês) sobre programação para Windows. O texto começa pela criação de uma simples janela, passa pelo tratamento de mensagens (message handling) e evolui até demonstrar os controles visuais mais comuns (como button e textbox).

theForger's Win32 API Tutorial

O site tráz também várias outras informações para complementar o tutorial básico e aprofundar os conhecimentos do leitor (criação de uma aplicação simples, interface de dispositivos gráficos, ferramentas e documentação, apêndices).

Para testes rápidos, tenho usado o Bloodshed Dev-C++ e até o momento ele tem atendido bem as espectativas.

C++ Beginner's Guide

2008-05-05T23:32:00.008-03:00

Livro C++ Beginner's Guide, de Herbert Schildt, disponibilizado para download (17MB) em formato PDF pela Microsoft. Para facilitar, coloquei um zip no zshare. Capítulos do livro:

01 - C++ Fundamentals
02 - Introducing Data Types and Operators
03 - Program Control Statements
04 - Arrays, Strings, and Pointers
05 - Introducing Functions
06 - A Closer Look at Functions
07 - More Data Types and Operators
08 - Classes and Objects
09 - A Closer Look at Classes
10 - Inheritance, Virtual Functions, and Polymorphism
11 - The C++ I/O System
12 - Exceptions, Templates, and Other Advanced Topics

Em inglês, com linguagem bem clara e acessível.

Detecção de Eventos no Windows

2008-04-07T23:16:00.005-03:00

Demonstração em C# de como detectar a ocorrência de eventos do sistema através dos recursos de instrumentação do Windows. Embora este exemplo identifique a abertura ou fechamento de uma aplicação qualquer, os eventos __InstanceCreationEvent e __InstanceDeletionEvent também podem identificar a criação ou exclusão de arquivos, unidades de discos, entre outras coisas.

using System;
using System.Management;

/*
    Desc.: Captura eventos do sistema.
    Prog.: vagnercsousa@yahoo.com.br
    Data.: 2008/04/07/23:00, Osasco

Referência:
http://msdn2.microsoft.com/en-us/library/aa393250(VS.85).aspx
*/

namespace EventosDoSistema
{
 class Program
 {
   static void Main(string[] args)
   {
     MonitoraçãoEventos.Monitorar("calc.exe",
       MonitoraçãoEventos.TipoEvento.Encerrar);

     Console.Read(); // aguarda
   }
 }

 class MonitoraçãoEventos
 {
   static ManagementEventWatcher watcher;

   public static void Monitorar
     (string nmProcesso, TipoEvento tpEvento)
   {
     // qdo aplicação inicia ou encerra
     string evento = (tpEvento == TipoEvento.Iniciar) ?
       "__InstanceCreationEvent" : "__InstanceDeletionEvent";

     // procuro o fechamento de uma aplicação específica
     string condicao = "TargetInstance ISA \"Win32_Process\""
       + " AND TargetInstance.Name = \"" + nmProcesso + "\"";

     // qdo não há provider de eventos explícito
     TimeSpan intervalo = new TimeSpan(0, 0, 1);

     // estrutura a consulta
     WqlEventQuery query = new
       WqlEventQuery(evento, intervalo, condicao);

     // prepara o objeto que fará a detecção
     watcher = new ManagementEventWatcher(query);

     // método para tratar ocorrências do evento
     watcher.EventArrived += new
       EventArrivedEventHandler(watcher_EventArrived);
          
     // inicia monitoração
     watcher.Start();
   }

   static void watcher_EventArrived
     (object sender, EventArrivedEventArgs e)
   {
     // suspende monitoração
     ((ManagementEventWatcher)sender).Stop();

     Console.WriteLine(e.NewEvent);
   }

   public enum TipoEvento
   {
     Iniciar, Encerrar
   }
 }
}

Streets Of Rage e Quake II

2008-04-07T22:41:00.012-03:00

Download do Streets Of Rage, game de ação clássico para consoles Sega, em um remake não-oficial e freeware para PC. Totalmente excelente! Download

Como de costume, economizando posts, segue o link para a versão demo do game Quake II, com códigos-fontes nativo e gerenciado em C++ incluídos.

Ajustar Data-Hora em C#

2008-03-29T01:06:00.008-03:00

Exemplo em C# que demonstra como atualizar a data e hora do sistema utilizando chamadas à API do Windows. Para isso, basta dizer à aplicação que existe uma função externa pronta, onde encontrá-la (a DLL), quais parâmetros recebe e seu tipo de retorno.

using System;
using System.Runtime.InteropServices; // DllImport()
using Microsoft.Win32; // evento TimeChanged()

/*
    Desc.: Ajusta data e hora do sistema.
    Prog.: vagnercsousa@yahoo.com.br
    Data.: 2008/03/29/00:00, Osasco
 
Referências:
// SetSystemTime Function
http://msdn2.microsoft.com/en-us/library/ms724942(VS.85).aspx

// struct SYSTEMTIME
http://msdn2.microsoft.com/en-us/library/ms724950(VS.85).aspx

// exemplo Windows API
http://vsousa.blogspot.com/2008/03/bringtofront.html
*/

namespace SystemFunctionsTeste
{
class Program
{
 static void Main(string[] args)
 {
     SystemTime.Testar();
 }
}

class SystemTime
{
 /* Estrutura (unmanaged) no arquivo WinBase.h:

        typedef struct _SYSTEMTIME {
            WORD wYear;
            WORD wMonth;
            WORD wDayOfWeek;
            WORD wDay;
            WORD wHour;
            WORD wMinute;
            WORD wSecond;
            WORD wMilliseconds;
        } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
    */

   // Declaração da estrutura necessária
 [StructLayout(LayoutKind.Sequential)]
 public struct SYSTEMTIME
 {
     public ushort wYear;
     public ushort wMonth;
     public ushort wDayOfWeek;
     public ushort wDay;
     public ushort wHour;
     public ushort wMinute;
     public ushort wSecond;
     public ushort wMilliseconds;
 }

 [DllImport("Kernel32.dll")]
 static extern bool SetSystemTime(ref SYSTEMTIME pST);
 // BOOL WINAPI SetSystemTime
   //     (__in const SYSTEMTIME* lpSystemTime);

 [DllImport("Kernel32.dll")]
 static extern void GetSystemTime(ref SYSTEMTIME pST);
 // void WINAPI GetSystemTime
   //     (__out LPSYSTEMTIME lpSystemTime);

   // Objeto do tipo da estrutura criada
 static SYSTEMTIME pST = new SYSTEMTIME();

 public static void Testar()
 {
     // handler para evento (usar tecla TAB)
     SystemEvents.TimeChanged += new
         EventHandler(SystemEvents_TimeChanged);

     // Função externa que obtém dados
     GetSystemTime(ref pST);

     Exibe(pST); // apenas lista

     pST.wDay = 13; // alteração de exemplo
     pST.wMonth = 6;
     pST.wYear = 2009;

     // Função externa que atualiza
     SetSystemTime(ref pST);

     Exibe(pST); // lista novamente

     // Aguarda evento TimeChanged
     System.Threading.Thread.Sleep(1000);
 }

 static void Exibe(SYSTEMTIME pST)
 {
     Console.WriteLine("wDay " + pST.wDay);
     Console.WriteLine("wDayOfWeek " + pST.wDayOfWeek);
     Console.WriteLine("wHour " + pST.wHour);
     Console.WriteLine("wMillisec " + pST.wMilliseconds);
     Console.WriteLine("wMinute " + pST.wMinute);
     Console.WriteLine("wMonth " + pST.wMonth);
     Console.WriteLine("wSecond " + pST.wSecond);
     Console.WriteLine("wYear " + pST.wYear);
 }

 static void SystemEvents_TimeChanged
     (object sender, EventArgs e)
 {
     Console.WriteLine("Data atualizada.");
 }
}
}

Um detalhe que merece atenção especial é o tipo de dados na declaração dos membros da estrutura (WORD neste exemplo) que representa um valor de 16 bits e, por isso, os membros da estrutura gerenciada foram declarados como uint, também de capacidade igual 16 bits. Da mesma forma, caso houvesse algum membro declarado como DWORD (32 bits), usaríamos o tipo gerenciado int de 32 bits. Isto garante que a exportação do código gerenciado para o não-gerenciado seja coerente e não gere resultados inesperados.

Leis de Murphy

2008-03-25T22:54:00.006-03:00

"If something can go wrong, it will."

Algumas leis militares de Murphy:

"A coisa mais perigosa na zona de combate é um oficial com um mapa."
"O problema em usar a saída mais fácil é que ela já foi minada pelo inimigo."
"O companheirismo é essencial à sobrevivência. Ele dá ao inimigo outra pessoa em quem atirar."

Algumas leis de Murphy para a Programação:

"Todo programa, quando acabado, estará obsoleto."
"Se um programa é útil, ele deve ser modificado."
"Se um programa é inútil, ele deve ser documentado."
"A complexidade de um programa cresce até exceder a capacidade do programador que deve mantê-lo."

Variantes relativas a projetos:

"As falhas de projetos andam sempre em grupos."
"Errar é humano, mas para fazer coisas realmente idiotas é necessário um computador."
"Consultores são pessoas místicas que perguntam algo à empresa e depois dizem a mesma coisa de volta para ela." Lei de MacDonald
"Se os engenheiros construíssem prédios como os programadores escrevem programas, um único picapau seria capaz de destruir a civilização." Lei de Weinberg
"Nada é impossível para o homem que não tem que fazer por conta própria." Lei de Weiler
"Nunca programe e beba cerveja ao mesmo tempo." Lei de Woltman
"Sempre existe mais um bug." Lei de Lubersky da Entomologia Cibernética

Variantes diversas:

"Para cada ação existe uma crítica igual e no sentido contrário." Postulado de Harrison
"Se um objeto está em movimento, ele está indo na direção errada. Se um objeto está parado, ele está no lugar errado." Lei de Gerrold das dinâmicas infernais
"Um contrato verbal é aquele que não vale o papel em que seria escrito." Lei dos contratos de Goldwin
"É um erro deixar qualquer objeto mecânico perceber que você está com pressa." Observação de Ralph
"Um contribuinte é alguém que não tem que fazer um concurso para trabalhar para o governo." Observação de Krueger
"Tudo depende." Lei de Langsam

Trechos (selecionados e reordenados) de documento de autoria desconhecida (2002, traduzido por José Barreto Júnior), obtido no site eBooksBrasil.com no formato Rocket eBook alguns anos atrás (velhos arquivos-fantasmas assombrando meu sussego).

Envio de KeyStrokes em C#

2008-03-19T22:59:00.009-03:00

No post anterior, minha extensão da classe System.Diagnostics.Process implementou um método capaz de trazer a janela associada a um processo qualquer para o primeiro plano da área de trabalho. Neste post, segue a implementação que efetivamente envia keystrokes para a aplicação, como se as teclas fossem normalmente digitadas pelo teclado. O que fazer com isso? Lembra do bambú? Bom... envia por keystrokes!

Criei uma nova classe chamada Stroker com um método público responsável por dar uma "cutucada" na aplicação. Este estímulo será enviado somente aos processos que, dentre a listas de todos os processos em execução, correspondam ao especificado pelo parâmetro formal do método.

O estímulo à aplicação que se tornou a janela ativa é realizado por uma thread parametrizada, empregada para garantir um certo grau de isolamento entre o funcionamento geral da ferramenta e o envio de uma série de keystrokes específica. É minha solução atual e possivelmente será aperfeiçoada (mas funfa muito bem).

using System;
using System.Windows.Forms; // para SendKeys
using System.Diagnostics; // para processos
using System.Threading;

namespace KeyStroker
{
class Stroker
{
 static public void Cutucada(string processo)
 {
     Process[] processos = Process.GetProcesses();

     foreach (Process p in processos)
     {
         // cada programa em execução
         if (p.ProcessName.IndexOf(processo) != -1)
         {
             // DLL do post anterior
             Processo.Processo.Mostrar(p);

             Cutucar("A"); // teclas a enviar
         }
     }
 }

 private static void Cutucar(string param)
 {
     Thread t = new Thread(new
         ParameterizedThreadStart(bg_SendKey));

     t.Start(param);
     t.Join(new TimeSpan(0, 0, 4));

     if (t.IsAlive)
         t.Abort();
 }

 static void bg_SendKey(object param)
 {
     Thread.Sleep(new TimeSpan(0, 0, 2));
     SendKeys.SendWait((string)param);
 }
}
}

A thread leva como parâmetro real a tecla "pressionada" e, após disparada, paralisa a thread principal da ferramenta (através do método Thread.Join()) até que seu trabalho seja concluído ou o tempo limite especificado exceda em caso de algum problema. Neste caso, a thread será forçada a abortar sua execução.

Finalizando, a thread "filha" aguarda algum tempo (2 segundos no exemplo) para garantir que a janela já tenha se tornado ativa, e efetivamente envia o keystroke fornecido pelo parâmetro.

Obs.1: nesta implementação, a classe percorre todos os processos que atendam ao nome fornecido, alternando entre as janelas e enviando os keystrokes para cada uma delas.

Obs.2: O exemplo ainda não está completo, falta uma aplicação qualquer que "use" a classe criada, mas postar isso já seria demais.

Útil? Para mim foi...

Process.BringToFront() em C#

2008-03-19T01:35:00.011-03:00

Após algum tempo de dedicação quase que exclusiva ao metaverso Forterra OLIVE, surgiu a necessidade de criar uma ferramenta capaz de enviar key strokes para uma aplicação específica que pode, inclusive, ter várias instâncias simultâneas.

Simples, basta obter uma lista de processos, executar algum método BringToFront() e então aplicar os key strokes. Fudéos! Não há um método mágico destes (que eu conheça), mas há uma gambiarra salvadora. Os key strokes ficarão para a próxima, focarei no método ausente.

A idéia é relativamente simples. Não há o método mágico que traz uma aplicação para primeiro plano, mas há a propriedade IntPtr Process.MainWindowHandle, que retorna um número identificador para a janela principal associada ao processo (ou zero se o processo não possuir GUI - interface gráfica).

Com este identificador (handle) em mãos, podemos apelar para o velho Windão e suas magníficas bibliotecas dinâmicas (DLL's). Neste caso, foram usadas as funções SetForegroundWindow() e ShowWindow(), ambas implementadas na DLL User32.dll, daí o atributo System.Runtime.InteropServices.DllImport().

Agora basta juntar estas tralhas, especificar a ação que a janela executará (detalhes no arquivo-cabeçalho winuser.h), e está pronto.

Um pulo-do-gato interessante é extender a classe System.Diagnostics.Process num projeto do tipo class library (em que o assembly produzido é uma DLL) e incluir esta brincadeira, como fiz no exemplo a seguir.

using System;
using System.Diagnostics; // classe Process
using System.Runtime.InteropServices; // atributo DllImport

/*
Desc.: Biblioteca para complementar classe Process
Prog.: vagnercsousa@yahoo.com.br
Data.: 2008/03/18/23:00, Osasco
*/

namespace Processo
{
public class Processo : Process
{
[DllImport("User32.dll")]
static extern IntPtr SetForegroundWindow(IntPtr hWnd);

[DllImport("User32.dll")]
static extern IntPtr ShowWindow
 (IntPtr hWnd, int nCmdShow);

public void Mostrar()
{
   Mostrar(this, SW_Modos.SW_RESTORE);
}

public void Mostrar(SW_Modos sw)
{
   Mostrar(this, sw);
}

public static void Mostrar(Process p)
{
   Mostrar(p, SW_Modos.SW_RESTORE);
}

public static void Mostrar(Process p, SW_Modos sw)
{
   IntPtr wptr = p.MainWindowHandle;

   if ((int)wptr != 0) // 0 se não possui GUI
   {
       SetForegroundWindow(wptr);
       ShowWindow(wptr, (int)sw);
   }
}

public enum SW_Modos
{
   SW_HIDE = 0,
   SW_SHOWNORMAL = 1,
   SW_NORMAL = 1,
   SW_SHOWMINIMIZED = 2,
   SW_SHOWMAXIMIZED = 3,
   SW_MAXIMIZE = 3,
   SW_SHOWNOACTIVATE = 4,
   SW_SHOW = 5,
   SW_MINIMIZE = 6,
   SW_SHOWMINNOACTIVE = 7,
   SW_SHOWNA = 8,
   SW_RESTORE = 9,
   SW_SHOWDEFAULT = 10,
   SW_FORCEMINIMIZE = 11,
   SW_MAX = 11
}
}
}

Pronto. Agora sempre que precisar trazer uma aplicação para primeiro plano, basta referenciar a DLL gerada, usar a nova classe Processo e executar o método Mostrar() conforme as regras de negócio do projeto. Em execução:

[OFF] Geraldão

2008-03-05T17:56:00.009-03:00

Quem se lembra do Geraldão, personagem clássico do Glauco? Para relembrar os bãos tempos:

Aproveitando o post, o show do Iron Maiden em SP foi espetacular.

Algumas (péssimas) fotos. Up the Irons!!

Project Management Intro

2008-02-18T15:31:00.003-03:00

Não costumo repassar notícias ou artigos, mas alguns são relevantes.

"(...)IT projects fail at the beginning — not the end — due to a lack of sufficient planning. An IT organization must consider the resources it needs to devote to a project, the skills required and the people who need to be involved, and realistically consider the time it will take to create, test and implement the project deliverables. Otherwise, the project will be a mess. The IT organization will never complete it on time, on budget or with the required functionality, which are three common factors for project success.(...)"

Fonte: An Introduction to IT Project Management

Jogo de Lógica em LSL e C#

2008-01-28T10:21:00.004-02:00

Aí está. Deu trampo, mas saiu.

Minha versão em LSL de um jogo de raciocínio citado no livro "Dominando Visual Studio .net com C#", do Fábio Camara.

Por pura preguiça, não vou postar o exemplo todo aqui, apenas o link para o artigo, que saiu no Linha de Código. Aí estão umas imagens do meu cenário para o jogo.

Imagem 1:

Imagem 2:

Bem sugestivo.

AlcoholicException

2008-01-07T09:38:00.006-02:00

Decidi disponibilizar o código-fonte que rege aproximadamente 98% do meu comportamento.

// vagner's main behaviour

void Main(Cerva c)
{
  try
 {
    while (true) { ++c.bebe; }
 }
  catch (AlcoholicException e)
 {
   myFígado.Dispose();
 }
  finally
 {
   Main(new Cerva(-4.5));
 }
}

Desconsiderando algumas inicializações de rotina, isso roda que é uma beleza. Inclusive, acho que vou fazer uma versão 2.0 multi-thread, empregando também a classe Whisky.

Rumo Aos Metaversos

2008-01-04T18:51:00.000-02:00

Os metaversos serão, nos próximos anos, o que a internet representa hoje. O que começou como uma ferramenta militar, tornou-se um meio de comunicação acessível e cotidiano. Ela passou do modo texto para o conteúdo estático e então evoluiu para o dinâmico.

Mas nossa ambição não pára por aí. Do que era a foto de um produto num site qualquer, agora podemos tocá-lo e realizar interações como se aquilo estivesse em nossas mãos. Definitivamente, isto não é uma moda passageira e sim a direção pela qual o futuro vem se aproximando. Segue o que assim me faz acreditar.

É claro que os passos são tímidos, e devem ser cautelosos, embora os números apontem os brasileiros como a segunda maior comunidade de "secondlifeanos" no mundo. No entanto, ainda temos uma participação pouco ativa. Este cenário torna-se paradoxal ao considerar que o envolvimento com o mundo virtual não impõe custo algum aos seus residentes e que investe apenas:

1. Quem desejar (preferencialmente com uma boa estratégia na agulha, assim como em qualquer negócio).

Redobrando a característica pessoal deste texto, acredito que devemos deslocar nosso espectro de costumes usuais e pensar como habitantes de um metaverso. Em outras palavras, imagine entrar em uma casa virtual e, ao invés de móveis convencionais, ela lhe propiciar experiências limitadas no mundo real. Esta "casa" pode ser qualquer espaço e as experiências podem ser tanto profissionais como de entretenimento. Particularmente, eu adoraria ver a Chapada Diamantina em tempo real numa parede e ler Bertrand Russell em outra, enquanto participo de uma conferência com o avatar do meu chefe.

Indo ainda mais longe, talvez até demais e além do que o Second Life pode oferecer atualmente, esta mesma conferência virtual poderia ser transmitida dentro do metaverso por uma espécie de holograma. Isto já seria um mundo virtual elevado ao quadrado, mas evitaria transpor uma limitação física humana para o avatar. Confuso, mas da mesma forma que uma pessoa não é capaz de se teletransportar no mundo real (por enquanto e desconsiderando a possibilidade de conversão de massa em energia à velocidade da luz como defendido por Einstein na Teoria da Relatividade), impor que um avatar deva fazê-lo no virtual para interagir com outro torna-se contraditório. Mas isso já é viajar longe em uma bola de neve.

O fato é que os metaversos são a tendência para a web que conhecemos, além de fascinantes, e estão aí para serem desbravados. Coragem, homens!

Game Design Documents

2008-01-03T17:21:00.004-02:00

(Esse é sério, não outra tira!)

Seguem alguns links para design documents aplicados a jogos:

The Art of Computer Game Design, Chris Crawford

2D Game Design Documents, Vários documentos/autores

Game Biz Advice, Tom Sloper

Introdução ao Game Design, Ricardo Vladimiro

É isso.

Prims Rezzing em LSL

2007-12-19T20:51:00.005-02:00

Segue um rápido exemplo sobre programação para Second Life em Linden Scripting Language.

Trata-se de uma demonstração simples e interessante sobre como criar novas instâncias de objetos via código, além de obter um efeito visualmente interessante.

Para este exemplo e utilizando uma primitiva com dimensões de, digamos, 10 x 2 x 0.1 metros, teremos o seguinte resultado:

Para tanto, é necessário apenas que o script a seguir e uma cópia do objeto a ser replicado sejam colocados no inventário da primitiva principal. Esta mesma primitiva fará cópias do objeto, sendo que as novas instâncias são posicionadas estrategicamente, resultando numa forma mais atraente regida por um padrão de comportamento específico.

Neste caso, as cópias terão um deslocamento vertical para cima composto com uma pequena rotação em torno do eixo Z, de maneira que a altura da figura como um todo não ultrapasse 10 metros e que a resultante desses incrementos de rotação complete uma volta de giro.

Na verdade, o código é mais simples do que a explicação, mas, de qualquer forma, o que nos interessa é, principalmente, as equações para determinar a posição e a rotação.

- Para a posição, basta acrescentar à altura do último objeto o incremento desejado, que neste exemplo é a relação entre a altura máxima pretendida o número total de objetos. Outra maneira, mais conveniente em termos de programação, é acrescentar à posição da primitiva principal o produto entre o número da cópia atual e o incremento, resultando também no offset desejado. Por fim, a posição será dada por, simplesmente,

llGetPos() + <0,>

- Para a rotação, um raciocínio análogo é aplicado. Desejamos que cada objeto tenha uma pequena rotação em relação ao anterior, mas que entre o primeiro e o último objeto, tenhamos completado uma volta de giro. Como uma volta completa são 360 graus ou 2*PI radianos, nosso incremento angular será dado pela razão entre 360º e o número total de objetos. Em relação à primitiva root, o offset angular para cada objeto será dado por, também simplesmente e utilizando a notação de Euler,

<0,>

Daí, o restante do código apenas executa as iterações necessárias para criação das cópias, como pode ser visto completamentamente a seguir:

default
{
 state_entry()
 {
   llSay(0, "Ola, avatar! " +
     "Toque no objeto para ver o resultado.");
 }

 touch_start(integer total_number)
 {
   integer objetos = 30;
   integer atual;

   for (atual = 1; atual <= objetos; ++atual)     {       float incremento = 10.0 / objetos;       vector pos = llGetPos() + <0,>;

     float incAngular = atual * TWO_PI / objetos;
     rotation rot = llEuler2Rot(<0,>);

     llRezObject("Object", pos, ZERO_VECTOR, rot, 0);
   }
 }
}

Como sempre, a matemática nos ajudando. Daí para uma auto-montável-árvore de natal basta um pulo. E o objeto inicial era apenas uma tábua de madeira:

FileSystemWatcher Síncrono

2007-12-18T18:34:00.002-02:00

Exemplo prático de recursividade utilizando a classe FileSystemWatcher de maneira síncrona.

O contexto é, superficialmente, uma aplicação que deve identificar o recebimento de um arquivo específico dentro de um determinado prazo. Sem muita conversa, segue o código:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace FSWRecursivo
{
class FSWRecursivo
{
    static FileSystemWatcher fsw =
        new FileSystemWatcher(@"C:\Teste", "*.*");

    public static void Main()
    {
        string nomeArquivo =
            "Novo(a) Documento de texto (2).txt";

        esperar(nomeArquivo, 30000);
    }

    static void esperar(string arqEsperado, int mstimeout)
    {
        TimeSpan t = DateTime.Now.TimeOfDay;

        WaitForChangedResult cr =
            fsw.WaitForChanged(
              WatcherChangeTypes.Created, mstimeout);

        if (!cr.TimedOut)
        {
            if (cr.Name == arqEsperado)
            {
                resposta(arqEsperado);
            }
            else
            {
                mstimeout =
                    (int)DateTime.Now.TimeOfDay.Subtract(
                      t).TotalMilliseconds;

                esperar(arqEsperado, mstimeout);
            }
        }
        else
        {
            semResposta(arqEsperado);
        }
    }

    static void resposta(string arqEsperado)
    {
        Console.WriteLine
            ("Arquivo esperado recebido.");
    }

    static void semResposta(string arqEsperado)
    {
        Console.WriteLine
            ("Arquivo esperado não recebido no prazo.");
    }
}
}

Resumindo, a lógica é a seguinte: ao receber um arquivo, a aplicação verifica se é o esperado. Caso não seja, contabiliza o tempo restante e continua esperando, até que o arquivo esperado seja recebido ou o tempo-limite seja excedido.

Design Document (Tira)

2007-11-30T10:50:00.001-02:00

Essa merece...

Achei num fórum tuga de desenvolvimento de jogos.

Dispensa qualquer comentário.

Personagens Autônomos

2007-11-30T09:36:00.001-02:00

Há alguns dias, enquanto programava os peixes da ilha MLBR Portal e conversava com o Emiliano (diretor de marketing da Kaizen Games), ele me passou um link muito interessante. Trata-se de soluções para movimentação de personagens autônomos, dotados de um certo grau de "inteligência", como nos jogos.

Steering Behaviors For Autonomous Characters

Isso no Second Life possibilita novas maneiras de popular ilhas com objetos mais atraentes. Permite, por exemplo, simular o comportamente de animais em grupo, um cardume de peixes em movimento, etc.

Link interessante, merece ser visto por programadores.

LSL Brasil

2007-11-13T13:30:00.002-02:00

Hoje, 13/11/07, criei o grupo de discussão LSL Brasil, com o seguinte propósito:

"LSL, ou Linden Scripting Language, é a linguagem de programação do metaverso Second Life. Esta comunidade pretende divulgar, discutir, informar, relatar problemas conhecidos e suas soluções.

O objetivo é suprir a falta de documentação técnica de qualidade, principalmente em língua portuguesa, contribuindo assim para o aperfeiçoamento das produções brasileiras no escopo da interatividade."

e convido a todos os programadores, profissionais ou hobbistas, que têm prazer em compartilhar conhecimento, a participar.

Clique para entrar no grupo LSL Brasil

Fontes ROTT e Duke3D

2007-11-06T10:03:00.002-02:00

Já faz um bom tempo desde 20 de dezembro de 2002, mas vale lembrar que a 3D Realms disponibilizou o código-fonte do game de tiro em primeira pessoa Rise Of The Triad, sob a GNU General Public License.

Isto foi de certa forma uma homenagem a William Scarboro, um dos primeiros programadores, que morreu em dezembro do mesmo ano, como comentado por Joe Siegler neste trecho publicado no readme.txt:

"Furthermore, the release of the Rise of the Triad source code is dedicated to our late friend and cohort, William Scarboro. William was one of the original Rise of the Triad programmers, and he unfortunately died of an asthma attack on August 9, 2002."

Rise of the Triad Source Code

O demo para quem quiser conhecer o game: Rise of the Triad Shareware Episode

E de quebra, em abril de 2003 a 3D Realms também divulgou o código-fonte do Duke Nukem 3D.

Duke Nukem 3D Atomic Edition Source Code

E o demo: Duke Nukem 3D Shareware Episode

Dá para se divertir por horas.

Bolha Second Life

2007-10-18T10:29:00.000-02:00

Muito se fala, muitos especulam, e por fim milhares fazem assombrosos comentários sobre um possível "recesso" no famoso metaverso Second Life. Há afirmações de que o mundo virtual da Linden Lab está estagnado, sendo abandonado e tendo seu lugar tomado por outros universos digitais. Eis aqui minha análise e opinião pessoal.

Primeiramente, SL não é um jogo e sim um metaverso. Em segundo lugar, o que fazer nele, seja você uma pessoa, uma empresa ou um animal de estimação super-dotado (e por quê não, afinal o cachorro do Jim Carrey no filme Todo Poderoso lia no banheiro)?

Pessoas geralmente estão à procura de diversão. Conhecer outros avatares, visitar lugares, participar de eventos ou até fazer sexo virtual - sou particularmente conservador, prefiro à moda antiga.

Empresas buscam lucros. Querem vender, sejam produtos ou serviços.

Há uma incompatibilidade de interesses nesta história. É claro que o Second Life possibilita grandes oportunidades de negócios, mas são necessárias estratégias consistentes e adequadas às suas peculiaridades. Investir para apenas "estar" no SL como estão fazendo muitas empresas, é fracasso certo.

Obviamente existem interesses comuns à ambas as partes. Para quem busca informação e bom conteúdo, há muitos lugares para conhecer. Por exemplo a Cidade do Conhecimento, com parceria da Kaizen Games. SEBRAE, Vestibular Brasil, Bradesco, Porto Portugal, e por aí vai. Opções não faltam, basta procurar. Aproveite e dê uma passada também pelo Morro do Canta Bala, a primeira favela do Second Life, ou conheça a réplica do grande navio Titanic.

Para justificar melhor: uma matéria foi publicada no Los Angeles Times, comentada no jornal Estadão por Lucas Pretti em 17/07/2007 e então transcrita por Paulo Ferraz em seu livro Second Life para Empreendedores, de onde extraí o trecho que segue (ufa!):

"O SL deveria ser o paraíso do consumismo. Mas com o tempo percebeu-se que é tão difícil vender produtos lá quanto em qualquer outro lugar."

É lógico. Até a Pantera Cor-de-rosa já deveria ter desconfiado disso, afinal, a tão falada moeda virtual Linden Dollar é obtida de Reais, Dólares, Euros, Yens ou de algumas outras moedas convencionais. Portanto, ninguém vai sair pelo Second Life torrando centenas de milhares de lindens se isto custa alguns milhares de reais.

O comércio virtual existe e é promissor, mas como no tradicional, nada cai do céu. Uma boa estratégia é fundamental para qualquer que seja o modelo de negócio adotado. Por enquanto, minha sugestão é que as empresas tentem aproveitar o SL não apenas para obter lucros diretos, mas também como uma forma de contornar limitações do mundo real e, quem sabe, até reduzir custos. Enquanto isso ganham tempo e fôlego para definir exatamente como pretendem atuar no mundo virtual.

Para finalizar, uma coisa é certa. Os mundos virtuais em 3D são a tendência para a web que conhecemos. Neles, além de textos e imagens, há mais imersão e interação. Tudo é presencial e as possibilidades são infinitas.

E para não perder o costume: se algo não vai bem no SL, já que este não age por si só, nós é que precisamos pensar melhor sobre o que e como fazer por lá. Se um conteúdo não é bom no SL, ele também não será bom em metaverso algum. A web tradicional também passou por esse período de cabeçadas na parede no final da década de 90 e então amadureceu para o que vemos hoje. O Second Life também passará por este período de amadurecimento.

How To Solve It, G. Polya

2007-10-05T09:09:00.003-03:00

Para variar um pouco, segue uma excelente indicação de leitura.

Na minha opinição, um dos melhores livros já escritos. Trata-se do "A arte de resolver problemas" de George Polya, publicado em 1945 sob o título "How to solve it". E é impressionante como ainda se manterá atual por séculos.

Nele, Polya descreve formas de organizar o raciocínio para facilitar e otimizar a solução de problemas. Trás por exemplo, simulações de diálogos professor-aluno que induzem o leitor a encontrar caminhos para solucionar um problema qualquer por si só.

Ensina como analisar o problema e encará-lo como uma variação de outro caso já conhecido ou análogo. Também lista passos para identificar e relacionar todas as variáveis e informações fornecidas no enunciado, e então traçar um plano para atingir o resultado esperado.

Simplesmente excelente. Para adoradores das exatas é imperdível. São 40 pratas muito bem investidas.

Esse vale a pena conferir.

Figuras sobrepostas por Texto

2007-06-22T18:40:00.001-03:00

Um rápido exemplo de como gerar figuras sobrepostas por caracteres em C#.

Pode ser usado para fazer as famosas confirmações de que o usuário é uma pessoa e não um web-robô cadastrando-se automaticamente em algum site.


using System.Drawing;
using System.Drawing.Text;

protected void Page_Load(object sender, EventArgs e)
{
Bitmap imgBmp = new Bitmap(600, 100);
Graphics superfDesen = Graphics.FromImage(imgBmp);

superfDesen.Clear(Color.DarkBlue);

Font fonte = new Font("Verdana", 20);

string txt = "Título com AntiAlias";

superfDesen.TextRenderingHint =
TextRenderingHint.AntiAlias;

superfDesen.DrawString
(txt, fonte, Brushes.White, 10, 10);

txt = "Breve descrição com System.Default";
superfDesen.TextRenderingHint =
TextRenderingHint.SystemDefault;

superfDesen.DrawString
(txt, new Font("Times", 14), Brushes.Cyan, 20, 60);

imgBmp.Save(Response.OutputStream, ImageFormat.Jpeg);
}

Resumindo, é isso.

Recursividade com Torres de Hanoi

2007-05-17T20:15:00.000-03:00

A recursividade é um artifício capaz de simplificar a solução de muitos problemas através de funções definidas em termos de um caso mais simples de si mesmas.
Por exemplo, o fatorial de um número inteiro positivo n é definido como o produto de todos os inteiros entre n e 1, conforme o código a seguir:

int fatorial (int n)
{
  int p = 1;
  for (int x = n; x > 0; x--)
    p *= x;
}

Note que a função fatorial de n pode ser definida em termos de si mesma, pois é igual a n * (n - 1)! para todo n > 0. Como 0! é definido como 1, uma função fatorial poderá chamar a si mesma juntamente com um valor n - 1 até que n = 0. Esta será uma solução recursiva para calcular n!.


int fatorial (int n)
{
    return n == 0 ? 1 : n * fatorial (n – 1);
}

As Torres de Hanoi

O problema das Torres de Hanoi consiste de três estacas onde podem ser colocados n discos de diferentes tamanhos, empilhados, de modo que um disco menor sempre esteja sobre um disco maior. O objetivo é mover todos os discos, um por vez, para uma estaca destino usando outra estaca como auxiliar, sem que um disco maior seja colocado por cima de outro menor.

Supondo que para n discos podemos obter uma solução para n - 1 discos, temos uma solução recursiva, pois subtraindo 1 continuamente até que n = 1, teremos apenas um disco na torre, bastando movê-lo para outra. Podemos, então, definir uma estratégia para mover os discos de uma torre A para outra torre C, usando B como auxiliar.

1. Se n = 1, desloque o disco de A para C e pare
2. Desloque os n - 1 primeiros discos de A para B usando C como auxiliar
3. Desloque o último disco de A para C
4. Mova os n - 1 discos de B para C, usando A como auxiliar

Observe que nas chamadas recursivas, os discos serão movidos de A para B usado C (passo 2) ou de B para C usando A (passo 4). Devemos, então, incluir mais três parâmetros na função, além do número de discos n. Os parâmetros correspondem às estacas de onde tiramos os discos, para qual ele será movido e a estaca auxiliar, respectivamente. Observe que os parâmetros de uma função sempre devem ter correspondência exata em relação a tipo, número e ordem.


static void torres_hanoi(int n, char Origem, char Destino, char Auxiliar)
{
  if (n == 1)
{
    Console.WriteLine("Mover o disco 1 da estaca " + Origem +
    " para a estaca " + Destino);

    return;
}

  //move os n-1 primeiros discos de A para B usando C
torres_hanoi(n - 1, Origem, Auxiliar, Destino);

  //move o último disco de A para C
  Console.WriteLine("Mover o disco " + (n - 1) +
  " da estaca " + Origem + " para " + Destino);

  //move n - 1 discos de B para C usando A
  torres_hanoi(n - 1, Auxiliar, Destino, Origem);
}

Finalizando, a quantidade mínima de movimentos será dada por 2 elevado ao número de discos, menos um.


    número de movimentos necessários = 2^n - 1

Estabilidade de Sistemas Lineares em Matlab

2007-04-26T01:38:00.001-03:00

Agora sim, diversão de verdade. Vamos comprovar a brincadeira anterior (e serve de introdução ao Matlab).

O Matlab, cuja versão para estudo pode ser obtida no site da MathWorks, permite a simulação de muitos tipos de sistemas.

Ao iniciá-lo, criar um novo projeto em File, New, Model. A área de trabalho e a biblioteca de componentes para simulação serão apresentados.

Para a demonstração, serão necessários os seguintes componentes da biblioteca Simulink:

- Da categoria Sources, uma entrada em degrau (Step) e um temporizador (Clock);

Esta entrada em degrau será a excitação do nosso sistema, podendo representar por exemplo, uma chave liga/desliga de 0/220V, como um interruptor.

O clock servirá para levar o tempo da simulação para o gráfico de resposta, no eixo x, já que o comportamento (saída) do sistema depende (é função) do tempo t.

- Da Math, um somador (Sum) e um Ganho (Gain);

O somador compõe o sinal de referência (entrada do sistema em degrau) com o sinal de realimentação proveniente da saída do sistema. Isto caracteriza um sistema em Malha Fechada, já que o sinal de saída retorna e influencia no comportamento do sistema.

O ganho será o ajuste 'manual' do controlador, que definirá a forma da resposta em regime permanente, podendo tornar o sistema estável ou instável, dependendo do valor adotado. Este é o K determinado pelo critério de Routh.

- Da Continous, um integrador (Integrator) e duas funções de transferência (Transfer fcn);

O integrador é o tipo de controlador escolhido para "buscar" o valor de referência. É característico o erro nulo em regime permanente, porém com resposta lenta.

A função de transferência é a relação matemática que relaciona a saída com a entrada de um sistema. Conhecendo-se a FT do sistema, para qualquer entrada é possível determinar a saída.

- Da Signals & Systems, um multiplexador (Mux);

O multiplexador irá sobrepor os sinais de entrada e saída, para que sejam visualizados no gráfico da forma de resposta do sistema.

- Da Sinks, um osciloscópio (Scope) e dois blocos (To Workspace).

O osciloscópio irá plotar a saída correspondente à entrada em função do tempo, descrevendo graficamente o comportamento do sistema.

Os blocos To Workspace tornam os dados da simulação disponíveis no workspace principal do Matlab.

Em seguida, ligar os blocos conforme a figura, dando especial atenção aos polinômios da função de transferência. Notar a realimentação unitária do sistema H(s) = 1.

Editar os parâmetros onde necessário, conforme valores dados no problema anterior. Por exemplo, para a função da planta do sistema G2(s) = 1/((s+2)*(s^2 + 2s + 2)), abrir a caixa 'Block parameters' do bloco 'Transfer fcn' e informar apenas os coeficientes dos polinômios do numerador e do denominador.

No menu Simulation, Parameters, ajustar o Stop time para 30 segundos. Daí já é possível simular o sistema de controle. Basta clicar em Start Simulation e, com um clique duplo sobre o scope, abrir o gráfico da resposta. Clicar em Autoscale (um binóculo).

Note que, para o ganho integral zero, a resposta para uma entrada em degrau de por exemplo, 20V, é constante e zero. Claro, afinal a função do controlador G1(s) = k/s, em que k = 0, multiplica a função G2(s) da planta (por exemplo uma estufa).

Aumentando-se o ganho integral k e repetindo o procedimento de simulação, é visível que este sistema em particular é superamortecido para ganhos inferiores a 1 (um) e subamortecido para ganhos k maior que 1, onde há ultrapassagem (overshot) da referência.

É interessante notar que, em regime permanente (em torno de 30 segundos para este caso), a grandeza controlada tente a atingir e permanecer muito próxima à referência. Lembrando que regime permanente é um tempo relativo e particular para cada sistema, que corresponde ao tempo para que a saída estabilize ou passe a apresentar algum padrão de comportamento. Regime permanente é considerado um tempo infinito.

Aumentando-se o ganho k até ultrapassar o valor 5, será visível o comportamento oscilatório instável do sistema, comprovando a faixa k entre zero e cinco obtida pelo método de Routh. Nota-se pelo gráfico, que a grandeza controlada fica cada vez mais distante da referência desejada conforme passa o tempo.

O limiar para sistema sub, super, ou criticamente amortecido (neste caso particular igual a 1) pode também ser determinado matematicamente, mas em outro capítulo da novela.

Isso sim é diversão!

A metrópole: URU/SP

2007-04-25T18:56:00.001-03:00

Não poderia faltar... a grande cidade de Uru-SP.

Tem até na wikipedia.

Critério de Estabilidade de Routh

2007-04-24T23:13:00.003-03:00

Um pouco de diversão...

Sendo a função de transferência FT de um sistema qualquer

--- entrada X(s) ---| função de transferência F(s) |--- saída Y(s) ---

dada por

F(s) = Y(s) / X(s)

onde (s) indica que a função foi afetada pela transformação de Laplace, ou seja, que foi transportada do domínio do tempo (t) para o domínio da freqüência (s), a equação obtida fazendo-se

X(s) = 0

descreve o comportamento do sistema desconsiderando-se qualquer condição inicial, e é chamada de Equação Característica do Sistema. As raízes desta equação definem a forma de resposta do sistema descrito por F(s) e são chamadas de Pólos de F(s).

Decompondo em frações parciais um sistema cujas raízes de Q(s) sejam os pólos p1, p2, ..., pn, este mesmo polinômio Q(s) pode ser escrito como

Q(s) = (s - p1) * (s - p2) * ... * (s - pn)

e, daí, um sistema qualquer

F(s) = Y(s) / X(s) = P(s) / Q(s)

pode ser escrito como

Y(s) = ( P(s) / ( (s - p1) * (s - p2) * ... * (s - pn) ) ) * X(s)

Decompondo-o, fica:

Y(s) = A1/(s - p1) + A2/(s - p2) + ... + An/(s - pn) + B/s

em que B/s corresponde à componente de resposta em regime permanente para uma entrada em degrau unitário

X(s) = 1/s.

Retornando esta equação para o domínio do tempo, fica:

y(t) = A1 * exp(p1 * t) + A2 * exp(p2 * t) + ... + An * exp(pn * t) + B

em que Ai * exp(pi * t) somados corresponde à resposta de regime transitório em função do tempo (t).

Para que esta componente transitória possa chegar à zero e, portanto, tornar o sistema ESTÁVEL, é necessário que os pólos pi sejam reais e negativos ou complexos com parte real negativa.

Para determinar a estabilidade de um sistema sem calcular suas raízes, basta analisá-lo usando o método de Routh. A primeira condição a ser satisfeita é que todos os coeficientes ai do polinômio característico

a0 * s^n + a1 * s^(n-1) + ... + a(n-1) * s + an

tenham o mesmo sinal entre si.

Montando o tabelamento de Routh para o polinômio acima:

s^(n-0) | a0 | a2 | a4 | a6 | ...
s^(n-1) | a1 | a3 | a5 | a7 | ...
s^(n-2) | b1 | b2 | b3 | ...
s^(n-3) | c1 | c2 | c3 | ...
...
s^1
s^0

sendo as duas primeiras linhas os coeficientes do polinômio (ai) e as demais linhas coeficientes (bi e ci) determinados em função dos coeficientes do polinômio conforme relações como:

b1 = (a1 * a2 - a0 * a3) / a1
b2 = (a1 * a4 - a0 * a5) / a1
b3 = (a1 * a6 - a0 * a7) / a1

c1 = (b1 * a3 - a1 * b2) / b1
c2 = (b1 * a5 - a1 * b3) / b1

e assim por diante.

O sistema será estável se não ouver qualquer inversão de sinal na primeira coluna, o que indicaria a presenta de uma raíz positiva. Caso apareça algum zero na primeira coluna, basta substituí-lo por E (muito pequeno, porém maior que zero) e continuar a análise.

Considerando-se agora um sistema qualquer em malha fechada

R(s) ---| G1(s) |---| G2(s) |--- C(s)
---| H(s) |---

e chamando de G(s) o produto G1(s) * G2(s), obtemos a FT na forma canônica:

FT = C(s) / R(s) = G(s) / ( 1 + G(s) * H(s) )

Exemplo prático: Determinar a faixa de valores de k para que o sistema seja estável.

Sistema:
entrada --- controlador integral --- planta --- saída
--- realimentação ---

Modelo matemático:
R(s) ---| k/s |---| 1 / (s^2 + 2s + 2)(s + 2) |---| C(s)
---| 1 |---

A função de transferência é

FT = C(s) / R(s) = (k/s) * ( 1 / (s^2 + 2s + 2)(s + 2) )

Mas, na forma canônica,

FT = G(s) / ( 1 + G(s) * H(s) )

em que G(s) = (k/s)( 1 / (s^2 + 2s + 2)(s + 2) )
e H(s) = 1 (realimentação com ganho unitário)

Daí vem que a função de transferência

FT = [ (k/s) * ( 1 / (s^2 + 2s + 2)(s + 2) ) ] / { 1 + [ (k/s)( 1 / (s^2 + 2s + 2)(s + 2) ) ] * 1 }

e a equação característica do sistema

denominador(FT) = 0. Daí

1 + (k/s) * ( 1 / (s^2 + 2s + 2)(s + 2) ) = 0

manipulando a equação acima, vem que:

s(s^2 + 2s + 2)(s + 2) + k = 0
s^4 + 4s^3 + 6s^2 + 4s + k = 0

Aplicando o critério de Routh:

s^4 | 1 | 6 | k
s^3 | 4 | 4 | 0
s^2 |b1?|b2?|
s^1 |c1?|
s^0 |

b1 = (4*6 - 1*4)/4 = 5
b2 = (4*k - 1*0)/4 = k
c1 = (5*4 - 4*k)/5 = (20 - 4k)/5

Para que um sistema seja estável, não pode haver inversão de sinal na primeira coluna. Portanto, para este sistema em particular, c1 deve ser positivo.

c1 = (20 - 4k)/5 maior q 0
20 maior q 4k
k menor q 5

Concluindo, k deve estar entre 0 e 5.

Em breve, o melhor da novela... cenas do próximo capítulo: a demonstração em MatLab.

Timer em C#

2007-04-24T22:29:00.001-03:00

Segue um exemplo simples sobre timers em C#.


class TimerSimples
{
  static void Main(string[] args)
{
 System.Timers.Timer t = new
   System.Timers.Timer(3000);

 t.Elapsed += new
   System.Timers.ElapsedEventHandler
   (myMétodoPeriódico);//usar TAB 2x

 t.Enabled = true;
 t.Start();

  Console.ReadLine();
}

  static void myMétodoPeriódico
(object sender, System.Timers.ElapsedEventArgs e)
{
 ((System.Timers.Timer)sender).Stop();

 // faz alguma coisa...
 Console.WriteLine
   ("TimerElapsed @ " + e.SignalTime.TimeOfDay);

 ((System.Timers.Timer)sender).Start();
}
}

Simples. Cerveja pros músicos!!

Sexta-feira 13

2007-04-14T23:37:00.001-03:00

Acabei de descobrir que a sexta-feira 13 também é conhecida como Paraskevidekatriaphobia. Melhor do que isso, só mesmo saber que as baleias evoluíram dos cachorros.

Muito, muito interessante.

E ainda encontrei a origem do termo: The word "paraskevidekatriaphobia" was devised by Dr. Donald Dossey who told his patients that "when you learn to pronounce it, you're cured!"

Em caso de dúvida, consultar o dicionário médico.

Trabalho sobre Latim básico

2007-04-14T13:28:00.002-03:00

Fluindo a inspiração deste dia, segue outro link interessante. Um excelente trabalho sobre Latim Básico feito pelo Prof. Dr. Miguel Barbosa do Rosário.

Outros links interessantes: DireitoNet, CE Ismael, Multcarpo, Univ. Colorado: Theory for communication

Carl Orff - Carmina Burana (Canções de Beuren)

2007-04-14T12:43:00.003-03:00

Vasculhando a net, eis o que encontro:

Carmina Burana - "É uma obra coral baseada em poemas profanos escritos em latim e alemão medievais. Os temas-chave destes poemas são a exaltação que fazem ao jogo, ao amor e ao vinho. Os Carmina Burana (canções de Beuren), primeiro elemento de uma trilogia composta por Carl Orff, obtiveram um dos maiores êxitos internacionais da música contemporânea, sendo considerados uma das obras corais e instrumentais mais importantes do século XX. Nasceram da descoberta de um rolo de pergaminho, no Convento Beneditino de Benediktbeuren, num Mosteiro da Ordem de São Bento, na Baviera, mais precisamente no sudoeste da Alemanha, em 1837. Foram extraídos dessa coleção de poemas e canções profanas medievais, provavelmente escritos entre os séculos XII e XIII."

Carl Orff - "Nascido em 10 de julho de 1895, em Munique, onde veio a falecer a 29 de março de 1982, filho de antiga família de eruditos e militares de Munique, interessou-se , ainda jovem, pelo estudo de obras medievais. Anos mais tarde, cursa a Escola de Humanismo onde completa seu curso de estudos humanísticos. Sua verdadeira vocação, porém, aquela que o cativou foi a música."

Trecho de artigo escrito por Eliana da Cunha Lopes (FGS/ PELPL-USS) e retirado do site Círculo Fluminense de Estudos Filológicos e Lingüísticos. O texto completo trás explicações e traduções sobre esta excelente obra.

Outros links encontrados: Nautilus, Rabisco, Classical Net, Spectrum Gothic.

Criptografar web.config no .NET

2007-04-05T11:55:00.001-03:00

Implementação passo-a-passo de uma DLL (Windows e web) para proteger os arquivos app e web.config.

Criptografia, do Grego kryptós, "escondido", e gráphein, "escrever".

Referência: aspAlliance

Um arquivo de configuração de uma aplicação ASP.NET é um arquivo XML bem-definido cujo elemento raiz é a tag configuration. Nele são armazenadas informações críticas como credenciais de usuários, nomes de servidores e bases de dados. Daí a necessidade de ser protegido, ou criptografado, fortalecendo a segurança nativa do ASP.NET contra "curiosos".

O arquivo de configuração é chamado app.config em aplicações Windows, e web.config para aplicações web.

Como exemplo prático, vamos implementar uma biblioteca capaz de proteger e desproteger o conteúdo dos arquivos de configuração, tanto para web como Windows. Esta DLL terá apenas dois métodos públicos, sendo eles Encriptar e Decriptar.

1. Criar um novo projeto do tipo Class Library, semelhante à figura:

2. Incluir referência para os namespaces System.Configuration, System.Web.Configuration e System.Windows.Forms no arquivo de code-behind (*.cs) após adicioná-los em References:

O ASP.NET possui dois provedores de configuração protegida que podem ser usados para encriptar seções de um arquivo .config, sendo eles RSAProtectedConfigurationProvider e DPAPIProtectedConfigurationProvider.

A maioria das seções do .config podem ser encriptadas, inclusive as definidas pelo usuário e connectionString. Apenas as usadas pelo IIS como a tag HttpRuntime não podem ser protegidas.

Como os passos para web e Windows são semelhantes, mudando apenas o método que abre o arquivo de configuração (web.config ou app.config), incluí um método privado comum para abrir arquivos. Este método, mostrado abaixo, testa o contexto Http atual que, sendo nulo, pode indicar que se trata de uma aplicação Windows.

A propriedade que efetivamente testa o contexto Http para determinar se a aplicação é web ou Windows é listada abaixo. Não poderia faltar uma gambiarra, claro. Senão dá azar.

Finalmente, segue o método para criptografar a seção appsettings do arquivo .config, transformando-a em algo ilegível. Isto poderá ser confirmado ao abrir-se o arquivo.

E o método para decifrar o .config, se este estiver criptografado.

Obs.: O programador deve certificar-se de que a conta do processo ASP.NET worker tem permissão suficiente para modificar o .config da aplicação.

Finalizando o exemplo, criar um novo projeto. Pode ser tanto Windows, Console ou Web, lembrando apenas que este é um recurso exclusivo do ASP.NET Framework 2.0.

Neste novo projeto, referenciar a DLL criada acima (que deve ter sido compilada, é claro) e adicionar dois botões na tela de teste, por exemplo, btnCifrar e btnDecifrar. Nos eventos onClick destes botões, chamar os métodos Criptografia.Encriptar() e Criptografia.Decriptar(). Testar a aplicação e visualizar os resultados.

Note como os métodos acima foram ajustados a uma classe e, portanto, a uma DLL reutilizável.

As simple as possible.

Monitoração com FileSystemWatcher

2007-04-04T23:40:00.001-03:00

A classe FileSystemWatcher permite detetar quando algum arquivo foi, por exemplo, criado ou alterado em uma determinada pasta. Resumindo, os passos principais:

// incluir
using System.IO;

string caminhoPasta = Environment.CurrentDirectory;
// local onde os arquivos serão gravados

string filtro = "*.bmp";
// tipo dos arquivos de interesse

FileSystemWatcher CãoFarejador = new FileSystemWatcher(caminhoPasta, filtro);
// objeto watcher q fará a monitoração

CãoFarejador.Created += new FileSystemEventHandler(ArquivoCriado);
//Ocorre qdo um arq/pasta é criado

CãoFarejador.EnableRaisingEvents = true;
// Ativa o componente

// restante do método...

private void ArquivoCriado(object sender, FileSystemEventArgs e)
{
// um arquivo foi gravado, faz o q for necessário
}

Threads parametrizadas no VS2005

2007-04-04T23:15:00.000-03:00

Threads são um recurso conveniente para realizar processamentos isolados de forma assíncrona, evitando que a aplicação "pare de responder" temporariamente até que uma operação seja concluída, propiciando uma experiência mais agradável para o usuário. São relativamente simples de implementar, bastando basicamente, instanciar uma nova thread apontando-a para algum método e, em seguida, dispará-la.

// incluir o namespace
using System.Threading;

Thread myThread = new Thread(new ParameterizedThreadStart(Processa_AlgumaCoisa));
// faz método rodar em 2º plano

myThread.Priority = ThreadPriority.AboveNormal;
// Definir a prioridade da thread conforme necessário ajuda a otimizar o uso de CPU

object _param = "nomeArquivo";
// apenas um parâmetro de exemplo, mostrando que podemos passar
// parâmetros para a thread parametrizada. Este parâmetro pode ser
// um arranjo de objetos

myThread.Start(_param);
// inicia a execução do método apontado acima

/* Join paralisa a aplicação (na verdade a thread pai) enquanto
esta thread trabalha. A aplicação fica suspensa até q esta
thread termine sua tarefa ou o tempo no overload exceda. */

myThread.Join();
// retorna true se terminou a tarefa ou false se o tempo foi excedido

private Processa_AlgumaCoisa(object _param)

{

string nomeArquivo = (string)_param;

// faz o q tiver q fazer em background...

}

Outra forma de saber se a thread concluiu sua tarefa é pela propriedade myThread.IsAlive, que retorna true se ainda está trabalhando.

“Gerundismo” de Ricardo Freire

2007-04-03T12:53:00.001-03:00

Conforme prometido:

“Aqui vai a última flor do Lácio: Este artigo foi feito especialmente para que você possa estar recortando e possa estar deixando discretamente sobre a mesa de alguém que não consiga estar falando sem estar espalhando essa praga terrível da comunicação moderna, o gerundismo. Você pode também estar passando por fax, estar mandando pelo correio ou estar enviando pela Internet.
O importante é estar garantindo que a pessoa em questão vá estar recebendo esta ,mensagem, de modo que ela possa estar lendo e, quem sabe, consiga até mesmo estar se dando conta da maneira como tudo o que ela costuma estar falando deve estar soando nos ouvidos de quem precisa estar escutando. (...) Deus, o que a gente pode tá fazendo pra que as pessoas tejam entendendo o que esse negócio pode tá provocando no cérebro das novas gerações?
A única solução vai estar sendo submeter o gerundismo à mesma campanha de desmoralização à qual precisaram estar sendo expostos seus coleguinhas contagiosos, como o “a nível de”, o “enquanto”, o “pra se ter uma idéia” e outros menos votados.
A nível de linguagem, enquanto pessoa, o que você acha de tá insistindo em tá falando desse jeito?”

(O Estado de S.Paulo, coluna “Xongas”, trecho do texto “Gerundismo” de Ricardo Freire)

Quem mal lê, mal se comunica!

2007-04-03T10:22:00.001-03:00

Excelente artigo sobre comunicação, por Henrique Costa Pereira.

Tenho um ótimo sobre "gerundismo". Pretendo "estar postando" aqui em breve.

Visões de projeto

2007-04-02T17:27:00.001-03:00

Esta é uma excelente representação de fases críticas no desenvolvimento de projetos.
Descreve perfeitamente como o processo de engenharia de software é concebido na maioria das empresas. E ainda dizem que a culpa é dos programadores.

Nota perfeita em Engenharia de Software

2007-04-02T14:00:00.001-03:00

"(...) a maior dificuldade na construção de um software é decidir precisamente o que construir. Nenhuma outra parte do trabalho conceitual é mais difícil quanto estabelecer detalhadamente os requisitos técnicos. Nenhuma outra parte é mais difícil de ser corrigida tardiamente [6]."

[6] Berry, Daniel; Lawrence, Brian. Guest Editors’ Introduction - Requirements Engineering. IEEE Software. 1998. pp 26-29.

Conjunto de instruções do PIC

2007-03-28T00:37:00.000-03:00

f qualquer local de memória
W registo de trabalho
b posição de bit no registo 'f'
d registo de destino
label grupo de oito caracteres que marca o início de uma parte do programa (rótulo)
TOS cimo da pilha
[] opcional
<> grupo de bits num registo

*1 Se o porto de entrada/saída for o operando origem, é lido o estado dos pinos do microcontrolador.
*2 Se esta instrução for executada no registo TMR0 e se d=1, o prescaler atribuído a esse temporizador é automaticamente limpo.
*3 Se o PC for modificado ou se resultado do teste for verdadeiro, a instrução é executada em dois ciclos.

Erro abrindo projeto no VS2003

2007-03-28T00:06:00.000-03:00

"Visual Studio.Net cannot create or open the application because the current user account is not a member of the VS Developers group on the Web server computer"

No Painel de Controle, Ferramentas administrativas, Gerenciamento do computador, Usuários e grupos locais, Usuários. Nas propriedades do seu usuário, guia "Membro de", adicione o grupo VS Developers.

Link para artigo da MSDN:

Developing Software in Visual Studio .NET with Non-Administrative Privileges

Summary: Members of the local Administrators group have privileges to perform any action on a machine. This causes both a risk to the user performing actions in that environment and to the software that they develop. This article explains how to productively develop software while logged on with non-administrative privileges. (14 printed pages)

Depurar serviços no Visual Studio

2007-03-27T08:48:00.001-03:00

1. Compilar em DEBUG, inclusive DLLs, se necessário depurá-las também;
2. Instalar E iniciar serviço;
3. No VS, em Debug, Attach to Process...;
4. Em Available Processes, selecionar o processo;
5. Attach;

6. Em Debug, Detach All para finalizar.

Arquivos *.bat podem auxiliar na instalação e remoção de serviços:

Arquivo InstalServ.bat:

@echo off
rem Linha abaixo em uma única linha:
c:\windows\microsoft.net\framework\v2.0.50727\installutil -i D:\Projects\myServicos\myServico1\bin\Release\myServico1.exe

Arquivo RemovServ.bat:

@echo off
rem Linha abaixo em uma única linha:
c:\windows\microsoft.net\framework\v2.0.50727\installutil -u D:\Projects\myServicos\myServico1\bin\Release\myServico1.exe

ANTES DE INSTALAR OU REMOVER O SERVIÇO: Pará-lo se estiver em execução.

Titan: o filho + novo

2007-03-25T11:59:00.001-03:00

Algumas unidades práticas de Engenharia

2007-03-25T01:49:00.001-03:00

GC - Garbage Collector (C#)

2007-03-25T01:43:00.000-03:00

O método Collect do objeto GC (Garbage Collector) força a ocorrencia da coleta de lixo e consequentemente liberação de memória.

Porém este método deve ser evitado, pois é preferível deixarmos o próprio Garbage Collector decidir quando deve ser feita a coleta de lixo.

Mas quando realmente precisarmos realizar a coleta de lixo através do GC devemos tomar cuidado com a forma correta de chamar o método Collect, o que não é uma simples chamada de método. Veja :

- Chamamos o método Collect
- Precisamos esperar que todos os finalizes sejam rodados, liberando recursos
- Chamamos novamente o método Collect, pois a execução do finalize gera novas instancias a serem liberadas

Veja como fica :

GC.Collect
GC.WaitForPendingFinalizers()
GC.Collect

Porquê o frango atravessou a rua?

2007-03-25T01:39:00.002-03:00

RESPOSTAS:

PROFESSORA PRIMÁRIA
Porque o frango queria chegar ao outro lado da estrada.

CRIANÇA
Porque sim.

PLATÃO
Porque buscava alcançar o Bem.

ARISTÓTELES
É da natureza do frango cruzar a estrada.

MARX
O atual estágio das forças produtivas exigia uma nova classe de frangos capazes de cruzar a estrada.

MARTIN LUTHER KING
Eu tive um sonho. Vi um mundo no qual todos os frangos serão livres para cruzar a estrada sem que sejam questionados seus motivos.

FREUD
A preocupação com o fato de o frango ter cruzado a estrada é um sintoma de insegurança sexual.

DARWIN
Ao longo de grandes períodos de tempo, os frangos têm sido selecionados naturalmente, de modo que, agora, têm uma predisposição genética a cruzar estradas.

EINSTEIN
Se o frango cruzou a estrada ou a estrada se moveu sob o frango, depende do ponto de vista. Tudo é relativo.

MACONHEIRO
Foi uma viagem...

HELOISA HELENA
A culpa é das elites estelionatárias, caucasianas e aristocráticas que usurpam a população de frangos e mostra a sua capacidade de luta em defesa dos seus direitos.

SEVERINO CAVALCANTI
Desafio alguém que possa provar que o frango atravessou a estrada... É mentira... É tudo mentira.

ZECA PAGODINHO
Porque do outro lado da rua tinha uma Brahma gelada.

AMIR KLINK
Para ir aonde nenhum frango jamais esteve.

NELSON RODRIGUES
Porque viu sua cunhada, uma galinha sedutora, do outro lado.

FEMINISTAS
Para humilhar a franga, num gesto exibicionista, tipicamente machista, tentando, além disso, convencê-la de que, enquanto franga, jamais terá habilidade suficiente para cruzar a estrada.

DATENA
É uma pouca vergonha... Uma Barbaridade... Põe no ar... Põe no ar aí as imagens do frango atravessando a estrada.

FERNANDO HENRIQUE CARDOSO
Por que ele atravessou a estrada, não vem ao caso. O importante é que, com o Plano Real, o povo está comendo mais frango.

PAULO MALUF
O meu governo foi o que construiu mais passarelas para frangos. Quando for eleito novamente vou construir galinheiros deste lado para o frango não ter mais que atravessar a estrada.

CAETANO VELOSO
O frango é amaro, é lindo, uma coisa assim amara. Ele atravessou, atravessa e atravessará a estrada porque Narciso, filho de D.Canô, quisera comê-lo...ou não!!

E PARA FINALIZAR.........

LUIZ INÁCIO LULA DA SILVA
Porque queria se juntar aos outros mamíferos.

WebService assíncrono (em C# ASP.NET)

2007-03-25T01:21:00.000-03:00

Considere um método qualquer do webservice:

[WebMethod()]

public void myMetodo(ref  object parametros)
//declarando por referência disponibilizará
//os  parâmetros qdo o método terminar

{

    //lógica do webservice

}

O método assíncrono é chamado usando, por exemplo,

         myWebService.myMetodoAsync(parametros);
//o método assíncrono já  é gerado pelo webservice, basta usá-lo

        //o restante do código continua a ser  executado normalmente.

Vc pode adicionar um handler (no lado cliente) para disparar o método Completed correspondente ao método assíncronopara qdo ele terminar sua tarefa. Por exemplo:

        myWebService.myMetodoCompleted +=  new myMetodoCompletedEventHandler(myMetodoAsync_Terminou);    //use TAB  aqui

Em seguida, crie o novo método indicado no handler (repare q o intelli sense pode gerar o método abaixo usando TAB na linha acima:

protected void  myMetodoAsync_Terminou(object sender, System.ComponentModel.AsyncCompletedEventArgs  e)

{

        //aqui vc coloca o código a ser  executado qdo o método assíncrono terminar

        //obs: repare q no parâmetro 'e' vc tem  disponíveis os parâmetros

//q foram declarados por referência. Por exemplo, poderíamos ter:

                    Console.WriteLine(e.parametros); 

}

Bom, é basicamente isso, mas ainda há muito a explorar.

Rápida introdução à linguagem JAVA

2007-03-25T01:07:00.001-03:00

Java é uma linguagem portável orientada a objetos desenvolvida pela Sun Microsystems. Do código-fonte é gerado o byte-code, que será interpretado pela máquina virtual adequada à plataforma.

As aplicações podem ser escritas em editores ASCII puro como vi, emacs ou Bloco de notas. Por exemplo:

class HelloWorld
{
public static void main (String args[])
{
System.out.println ("Hello World!");
}
}

O byte-code é gerado por bin/javac HelloWorld.java e executado por bin/java HelloWorld. Para isso é necessário o compilador instalado, que pode ser obtido no site da Sun .

As Applets são aplicações Java adaptadas para rodarem dentro de páginas HTML e, portanto, apresentadas num browser. Por exemplo:

import java.awt.Graphics;

public class HelloWorldApplet extends java.applet.Applet
{
public void paint (Graphics g)
{
g.drawString ("Hello World!",5,25);
}
}

O byte-code será gerado por bin/javac HelloWorldApplet.java,
porém executado dentro de uma página HTML. Por exemplo:

<HTML>
<HEAD><TITLE>Exemplo de Applet Java: Hello World!</TITLE></HEAD>
<BODY>
<APPLET CODE="HelloWorldApplet.class" WIDTH="300" HEIGHT="100">
</APPLET>
</BODY>
</HTML>

ou poderá ser visualizado por bin/appletviewer HelloWorldApplet.html

Engenheiro contando a história dos 3 porquinhos

2007-03-25T00:49:00.002-03:00

Era uma vez três porquinhos genéricos, P1, P2 e P3 e um Lobo Mau, por definição, LM, que vivia os atormentando.

P1 era sabido e fazia Engenharia de Automação e já era formado em Civil. P2 era arquiteto e vivia em fúteis devaneios estéticos absolutamente desprovidos de cálculos rigorosos. P3 fazia Comunicação e Expressão Visual na UFSC.

LM, na Escola Oficial da ABNT, para medição da Maldade (EOMM) era Mau nível 8,75 (arredondando a partir da 3a casa decimal para cima). LM tbm era um mega-investidor imobiliário sem escrúpulos e cobiçava a propriedade que pertencia aos Pn (onde "n" é um número natural e varia entre 1 e 3, inclusive), visto que era de boa conformidade geológica e configuração topográfica, e ficava perto do Shopping Beira-Mar.

Mas nesse promissor perímetro P1 construiu uma casa de tijolos, sensata e logicamente planejada, toda protegida com mecanismos automáticos. Ja P2 montou uma casa de blocos articulados feitos de mogno que mais parecia um castelo lego-tresloucado. Enquanto P3 planejou no AutoCad e montou ele mesmo, com barbantes e isopor como fundamentos, uma cabana de palha com teto solar, e achava aquilo "o máximo".

Um dia, LM foi ate a propriedade dos suínos e disse, encontrando P3:

- Uahahhahaha, corra, P3, pq vou gritar, e vou gritar e chamar o Conselho de Engenharia e Construcao Civil para denunciar sua casa de palha projetada por um formando em Comunicação e Expressão Visual!

Ao que P3 correu para sua amada cabana, mas qdo chegou lá os fiscais do Conselho ja haviam posto tudo abaixo. Então P3 correu para a casa de P2. Mas quando chegou lá, encontrou LM à porta, batendo com força e gritando:

- Abra essa porta, P2, ou vou gritar, gritar e gritar e chamar o GreenPeace, para denunciar que vc usou madeira nobre de aréas não-reflorestadas e areia de praia para misturar no cimento.

Antes que P2 alcançasse a porta, esta foi posta a baixo por uma multidão ensandecida de eco-chatos que invadiram o ambiente, vandalizaram tudo e ocuparam os destroços, pixando e entoando palavras de ordem. Ao que P3 ergue P2 e os dois correm para a casa de P1. Quando chegaram na casa de P1, este os recebe e os dois caem ofegantes na sala de entrada.

P1: O que houve?

P2: LM, lobo mau por definicao, nível 8.75, destruiu nossas casas e desapropriou os terrenos.

P3: Não temos para onde ir. E agora, que eu farei? Sou apenas um formando em Comunicação e Expressão Visual!

Tum-tum-tum-tum-tuuummm!!!! (batidas à porta)

LM: P1, abra essa porta e assine este contrato de transferência de posse de imóvel, ou eu vou gritar e gritar e chamar os fiscais do Conselho de Engenharia de Santa Catarina em cima de vc!!!

Como P1 não abria (apesar da insistência covarde do porco arquiteto e do.. do... "comunicador e expressivo visual"?) LM chamou os fiscais, e estes fizeram testes de robustez do projeto, inspeções sanitárias, projeções geomorfológicas, exames de agentes físico-estressores, cálculos com muitas integrais, matrizes, e geometria analítica avançada, e nada acharam de errado.

Entao LM gritou e gritou pela segunda vez, e veio o GreenPeace, mas todo o projeto e implementação da casa de P1 era ecologicamente correta. Cansado e esbaforido, o vilão lupino resolveu agir de forma irracional (porém super-comum nos contos de fada): ele pessoalmente escalou a casa de P1 pela parede, subiu ate a chaminé e resolveu entrar por esta, para invadir.

Mas quando ele pulou para dentro da chamine, um dispositivo mecatrônico instalado por P1 captou sua presença por um sensor térmico e ativou uma catapulta que impulsionou com uma força de 33300 N (Newtons) LM para cima. Este subiu aos céus, numa trajetória parabólica estreita, alcançando o ápice, onde sua velocidade chegou a zero, a 200 metros do chão.

Agora calcule, admitindo que a gravidade vale 9,78 m/s2:

a) a massa de LM
b) o deslocamento no eixo "x", tomando como referencial a chaminé.
c) a velocidade de queda de LM qdo este tocou o chão e
d) o susto que o Lobo Mau tomou.

Principium est?

2007-03-16T00:56:00.000-03:00

"Tantum homo habet de scientia quantum operatur. (O conhecimento que o homem possui é só aquele que aplica.)" São Francisco