Projeto reconhece profissões de TI, mas exclui criação de conselhos

Fonte: TI Inside

A Comissão de Ciência, Tecnologia, Inovação, Comunicação e Informática (CCT) do Senado aprovou, nesta quarta-feira (5/3), parecer favorável do senador Eduardo Azeredo (PSDB-MG) ao projeto de lei que regulamenta o exercício das profissões de analista de sistemas e técnico de informática. A proposta é de autoria do senador Expedito Júnior (PR-RO) e agora será encaminhada à Comissão de Assuntos Sociais (CAS), na qual receberá decisão terminativa.
(…)
De acordo com a proposta, a profissão de analista de sistemas somente poderá ser exercida por pessoas que possuam diploma de nível superior em análise de sistemas, ciência da computação ou processamento de dados.

Sem comentários…

Java é uma linguagem orientada a objetos que contem tipos primitivos e wrappers para estes tipos, é executada sobre uma maquina virtual, com suporte a herança simples mas possui interfaces, com mecanismos de sobreescrita e sobrecarga de métodos, com um sistema de tratamento de exceções que te obriga a tratar determinadas situações e por ai vai.

Ao meu ver o estudo da linguagem deveria focar o domínio do mecanismo de herança e a construção de classes, domínio dos métodos, tipos de retorno, escopos de variavel, conversão de tipos, domínio das estruturas condicionais, de loops e de tratamento de erros, domínio das operações matemáticas e lógicas e,principalmente, domínio da classe String (ok, domínio pode ser uma palavra forte, talvez uma boa noção fosse suficiente em algumas situações).

Com disso tudo, o aluno deveria primeiro trabalhar com argumentos de linha de comando (o que vc acha que o main recebe?), depois passar a estudar a leitura e escrita em arquivo texto e, por fim, leitura pela entrada padrão.

Pois leitura pela entrada padrão é o que vc menos vai fazer em Java. Ninguem faz programa com menuzinho em Java pra console no mercado. Temos coisas mais complexas pela frente e sem conhecer tudo aquilo que eu listei antes só é possivel fazer gambiarras (como as famosas class functions, gigantescos métodos que fazem centenas de coisas com nomes adequados do tipo createTree3).

Ensina-se Java ao contrário: primeiro o camarada programa como se fosse C, perdendo tempo em fazer menus e estruturas de controle pois o usuario pode ter dado um enter, tab, “ç” ou ter digitado algo inválido quando deveria aprender os fundamentos da linguagem. Cria-se vícios que pode ser custoso para remover (como encher o código de getters/setters sem necessidade). A prova disso é que invariavelmente temos comparação de Strings usando o operador == quando deveria ser utilizado os métodos adequados para isso (imagina o susto quando a galera descobre o equalsIgnoreCase).

Eu vejo muitos estudantes incapazes de compilar e executar uma classe (o famoso hello world) pois os mesmos nunca fizeram uso da linha de comando muito menos foram apresentados ao conceito de classpath. Vejo barbaridades típicas de quem não conhece (ou não sabe ler) o javadoc das classes básicas. Fico me perguntando quando esses jovens serão capazes de ler um “Effective Java”, por exemplo.

Aqui tem um excelente começo.

Espero que os professores acordem para essa realidade e que os alunos percebam que estão sendo prejudicados e passem a estudar por sua conta os tópicos necessários para sair arrasando pro ai.

class Omega
        def a
                self
        end
        def b
                self
        end
        def c
                self
        end
        def to_s
                "Omega"
        end
end

def da? 
        begin
                yield() if block_given?
        rescue => exc
                nil
        end
end

xyz = nil
a = da? { xyz.a.b.c } 

xyz = Omega.new
b = da? { xyz.a.b.c } 

puts "da? com nil -> '#{a}'"
puts "da? com Omega -> '#{b}'"

Executando:

da? com nil -> ''
da? com Omega -> 'Omega'

O que eu fiz? como a expressão xyz.a.b.c poderia retornar algum erro pois um dos métodos poderia returnar nil, bastaria executar em um bloco de código com a ajuda do método da? (péssimo nome, uma corruptela de “da para executar sem erro? se não, me retorna nil e era wilson…), que captura qualquer erro e some com ele.

Ruby é divertido. :)

ps: teste com

a = da? { xyz.a.b.c } || "nao deu..."

Vou pedir perdão ao meu amigo Urubatan, que publicou um artigo de mesmo nome.

class Omega
   def doIt
     puts "ola"
     self
   end
end

class NullableClass
   def method_missing(*x)
      self
   end
end

class Object
   def existe?
      self
   end
end

class NilClass
   def existe? 
      NullableClass.new 
   end
end

xyz = Omega.new 
xyz . existe? . doIt . doIt

abc = nil
abc . existe? . doIt . doIt

Estou em duvida sobre o nome do metodo, por enquando fica existe? mesmo.

O que isso faz? Imagine que vc tem uma variavel ou atributo de classe que pode ser nil. Se for nil ela vai lançar um um erro em tempo de execução quando vc for tentar chamar algum método que a NilClass não possua (o que geralmente acontece, é semelhante ao NullPointerException do java).

Eu poderia resolver isso alterando o method_missing da NilClass, porém alguns scripts podem estar esperando erros desse tipo. Decidi então criar um método que, para qualquer objeto, retorna ele mesmo (self). Caso seja nil, ele vai retornar um NullableClass (outro nome infeliz, não tenho nenhuma ideia melhor) que simplesmente retorna ele para qq método requisitado.

IMHO pode ser o suficiente quando queremos fazer um teste simples: o objeto é nil? então não faz nada.

Se alguem achar isso util por favor me avise :)

Ah sim, a execução do script acima resulta em:

ola
ola