Qual é a sua Meta?

Nunca fui fã de livros de administração. Não gosto daqueles textos enfadonhos que, ou falam o óbvio, ou alguma coisa que nunca entenderei direito. Mas tem um livro muito famoso que estava na minha lista há tempos: “A META” de Eliyahu M. Goldratt e Jeff Cox.

Sabe aqueles livros que todo mundo fala que você tem que ler, mas que você fica com um pé atrás, achando que vai se arrepender? Deste eu não me arrependo não. Ele não é bom só porque aborda gerencia e administração através de um Romance, com ele eu aprendi coisas realmente interessantes. E é perfeitamente possível traçar um paralelo entre os problemas tratados na história do livro (que foca uma indústria), com problemas de empresas de desenvolvimento de Software.

Vamos a um breve resumo para eu iniciar meu raciocínio: A Meta conta a história de Alex Rogo, um gerente de uma fábrica de uma cidadezinha do interior dos EUA. A Fábrica está literalmente numa pior, com muitos pedidos atrasados, clientes reclamando, problemas vindos de todos os lados, pressão de diretores, e por aí vai. Alex tem três meses para reverter a situação, senão a fábrica fecha. E para piorar um pouco, a mulher está a ponto de abandoná-lo, pois ele não tem mais tempo para a família.

A história começa apresentando este cenário, e vai mostrando como o Alex vai conseguindo conquistar melhorias, tanto na vida profissional, quanto na pessoal, com a ajuda de um velho conhecido chamado Jonah.

A partir daí, se você se interessou, sugiro que leia o livro. Vale à pena, pode acreditar. Abaixo vou acabar colocando alguns spoilers, mas nada que inviabilize a leitura. (mesmo assim, se você não quiser saber mais detalhes da história, pare de ler por aqui).

A primeira tarefa do Alex para sair do buraco é descobrir qual é a verdadeira META da sua fábrica, ou melhor: Qual é a verdadeira meta de qualquer organização?

No começo eu achei essa questão muito óbvia, e não entendia porque o Alex demorou e sofreu tanto para achar a resposta. Até que eu refiz essa pergunta da seguinte forma: Qual é a META de um departamento de desenvolvimento de software?

Aí eu entendi a dificuldade. Pare aí um minuto para pensar, você que trabalha com desenvolvimento de software. Qual é a verdadeira META que a sua empresa, ou o seu departamento deve seguir?

As respostas mais comuns são:

- Criar software de qualidade;
- Atender às necessidades dos usuários;
- Cumprir os Requisitos no prazo combinado;
- Fazer Software para Durar (essa é a preferida dos Arquitetos);
- Criar Software reutilizável;
- Zero Bug! (preferida dos adeptos do TDD);
- Entregar um produto de qualidade, que agregue valor e sinergia aos processos de negócio dos nossos clientes (é sério, tem gente que fala desse jeito);
- etc.

Enfim, nenhuma dessas é a resposta correta. A verdadeira META de uma empresa é GANHAR DINHEIRO! É óbvio, e provavelmente você já chegou a essa resposta lá atrás.

Mas e quando falamos especificamente de um departamento de desenvolvimento de software, de uma empresa que não comercializa software? A resposta é a mesma. Se a Meta de qualquer empresa é o Ganho, todos os departamentos dessa empresa devem seguir a Meta. Ou seja, o software que fazemos, direta ou indiretamente, deve levar a organização em direção ao Ganho. Pense um pouco, o software que o seu departamento faz, ajuda a empresa a alcançar sua Meta? Direta ou indiretamente é o que deveria acontecer.

O fato é que quando estamos muito envolvidos nos processos operacionais do nosso trabalho, é difícil enxergar que tudo o que fazemos, no final das contas tem o único objetivo de se converter em Dinheiro.

E se a META de uma organização é ganhar DINHEIRO, a produtividade dessa organização só pode ser medida com relação a este GANHO.

Então, a próxima pergunta que eu lhe faço é: Você, como desenvolvedor de software, é produtivo com relação à META da sua empresa? As tarefas que você executa diariamente estão especificadas e priorizadas para atender a verdadeira META da organização onde você trabalha?

Essa visão pode parecer capitalista demais, mas é assim que as coisas funcionam. O primeiro passo para sermos mais produtivos, é admitir qual é a verdadeira META do nosso Trabalho.

É claro que não para por aí. Essa foi a primeira lição que o Alex aprendeu na história. Existem muitas outras questões que aprimoram e evoluem essa idéia, e o livro trata delas de uma forma muito ilustrativa, sempre deixando uma questão no ar: Será que estamos no caminho certo?

Na media do possível vou tentar explorar mais sobre essas questões aqui neste Blog. A Teoria das Restrições (TOC – Theory of Constraints), com o processo de melhoria contínua, é particularmente interessante, e podemos aplicá-la no desenvolvimento de software. Mas se você não quiser esperar meu próximo post, leia o livro!

Agora, se você faz software e não ganha dinheiro (direta ou indiretamente), você provavelmente possuí outro emprego e software é apenas um hobby, já é milionário e não sabe o que fazer com o tempo livre, é sustentado pelos seus pais ou cônjuge, ou mora num país verdadeiramente comunista. :)

Grande Abraço e até a próxima!

CRUD no ADO.NET

Nós que trabalhamos na borda da tecnologia, sempre procurando por novidades, avaliando versões betas, ctps, etc, acabamos esquecendo um pouco das coisas simples e básicas. Notei isso recentemente quando algumas pessoas que estão começando a aprender C# me pediram por um exemplo simples de rotinas de inclusão, alteração, exclusão e consulta de registros em uma tabela de um banco de dados SQL Server. Me assustei quando notei que não tinha tal exemplo pronto, para poder enviar.

É em nome da simplicidade, e para que sempre que possível, possa ajudar quem tem interesse em aprender C#, que vou começar a postar aqui alguns exemplos e conceitos básicos. Começando hoje com um exemplo de CRUD, usando os recursos mais simples do ADO.NET.

Para quem não é familiarizado com a sigla, CRUD é o acrônimo de: Create, Read, Update e Delete. Referencia às quatro operações básicas de qualquer banco de dados.

O código deste exemplo que vou mostrar aqui, pode ser executado em um aplicação do tipo Console Application, e precisa do database Northwind da Microsoft. É claro que você deve adaptá-lo para que funcione no seu banco de dados e no tipo de aplicação que deseja: ASP.NET, Windows Forms, WPF, Silverlight, etc.

Comecemos então com o código necessário para abrir a conexão com o banco de dados. Veja na Listagem abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Data;
using System.Data.SqlClient;

namespace Algorama.Exemplos.CRUDSimples.AppConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            string ConnString =
            "Data Source=(local);Initial Catalog=Northwind; Integrated Security=True";
            SqlConnection Conn  = new SqlConnection(ConnString);
            try
            {
                Conn.Open();
                InsertShippers(Conn, "ALGOARAMA", "123456");
                //UpdateShippers(Conn, "ALGORAMA - ALTERADO", "55555555", 4);
                //DeleteShippers(Conn, 4);
                SelectShippers(Conn);
                Console.ReadKey();            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                Console.ReadKey();
            }
            finally
            {
                Conn.Close();
            }
        }
    }
}

Note nas linhas 6 e 7, que precisamos importar os namespaces System.Data e System.Data.SqlClient, para que possamos utilizar os recursos do ADO.NET para SQL Server. Em seguida dentro do método Main (que é executado quando rodamos uma aplicação console), veja que estamos criando um objeto da classe SqlConnection (linha 17), através de uma ConnectionString (linha 16), que possuí as credenciais para acessar o banco de dados no servidor.

Quando vamos abrir uma conexão com um banco de dados, precisamos garantir que o nosso código vá fechá-la corretamente, depois de usada. É por isso que usamos a estrutura try/catch/finally. Com ela, mesmo que ocorra um erro durante o acesso ao banco, estamos garantindo que a linha 33 sempre será executada, fechando a conexão.

Depois que abrimos a conexão com o banco, na linha 20, note que temos a chamada de 4 métodos. Esses são os métodos correspondentes às quatro operações CRUD. Alguns estão comentados, pois para efeito de testes, é interessante que você execute um por vez. Vamos então ao código de cada um destes métodos, a começar pelo Insert.

private static void InsertShippers(
    SqlConnection Conn, 
    string Name, string Phone)
{
      SqlCommand Comm = new SqlCommand();
           
      Comm.CommandText =
      "INSERT INTO Shippers( CompanyName, Phone ) Values(@Name, @Phone)";
      Comm.Parameters.Add(new SqlParameter("@Name", Name));
      Comm.Parameters.Add(new SqlParameter("@Phone", Phone));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Inserido(s)",
            nroReg.ToString());
}

Todos os quatro métodos recebem como parâmetro o objeto de conexão aberto no método Main. Com este objeto, no método Insert podemos criar um objeto da classe SqlCommand (linha 5), e definir um comando no formato texto (linha 7). É claro que você poderia estar usando uma stored procedure aqui.

Veja que nas linhas 9 e 10, estamos alimentando os parâmetros do comando que será executado. Essa prática garante que nossa aplicação esteja segura quanto a possíveis ataques de SQL Injection. Por fim o comando é executado e uma mensagem exibida na console.

Note que para que você utilize essa rotina em uma aplicação Windows Forms ou ASP.NET, poucas adaptações devem ser feitas. A essência da operação de inclusão não muda.

O próximo método que segue na Listagem abaixo, é o método que faz a operação de Select. Veja que também usamos um SqlCommand, porém, neste caso o SqlCommand é executado por um SqlDataAdapter (linha 11), que é usado para preencher um DataSet (linha 13).

private static void SelectShippers(
    SqlConnection Conn)
{
      SqlCommand Comm = new SqlCommand();

      Comm.CommandText = "SELECT * FROM Shippers";
      Comm.CommandType = CommandType.Text;
      Comm.Connection  = Conn;

      DataSet ds = new DataSet();
      SqlDataAdapter da = new SqlDataAdapter();
      da.SelectCommand = Comm;
      da.Fill(ds);

      Console.WriteLine(
          "Total de: {0} registros",
          ds.Tables[0].Rows.Count);

      foreach (DataRow item in ds.Tables[0].Rows)
      {
          Console.WriteLine(
                    "Id: {0} - Name: {1} - Phone: {2}",
                    item["ShipperID"],
                    item["CompanyName"],
                    item["Phone"]);
      }
}

O dataset é uma representação em memória de parte do nosso banco de dados. Com ele podemos recuperar e manipular os dados do database de forma desconectada. Esse é um assunto a parte, que deve ser explorado em mais detalhes em outra ocasião.

Por fim, ainda no método Select, depois de recuperados todos os registros, estamos imprimindo-os na Console através de um foreach (linha 19), que irá percorrer por todas as linhas da tabela do nosso dataset.

Por último, temos agora os métodos de Update e Delete, que seguem nas próximas duas listagens. Eles tem comportamento muito parecido com o Insert, que usa o SqlCommand e parâmetros, dispensando qualquer comentário adicional.

private static void UpdateShippers(
    SqlConnection Conn, 
    string Name, string Phone, int ID)
{
SqlCommand Comm = new SqlCommand();

      Comm.CommandText =
      "UPDATE Shippers SET CompanyName = @Name, Phone = @Phone WHERE ShipperID = @ID";
      Comm.Parameters.Add(new SqlParameter("@Name", Name));
      Comm.Parameters.Add(new SqlParameter("@Phone", Phone));
      Comm.Parameters.Add(new SqlParameter("@ID", ID));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Alterados(s)",
            nroReg.ToString());
}

private static void DeleteShippers(
    SqlConnection Conn, int ID)
{
      SqlCommand Comm = new SqlCommand();

      Comm.CommandText = "DELETE FROM Shippers WHERE ShipperID = @ID";
      Comm.Parameters.Add(new SqlParameter("@ID", ID));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Deletados(s)",
            nroReg.ToString());
}

É importante notar que o código apresentado aqui serve como teste para estas quatro operações. Se você pretende usar este código em uma aplicação Windows ou Web, terá que realizar algumas adaptações. Se você quiser, pode ainda fazer o download desse exemplo aqui.

Espero que este post ajude quem procura por um exemplo básico de ADO.NET.
Grande Abraço e até a próxima!