Arquivo da categoria ‘Ruby on Rails’

Ruby – Container e Iterator – Linux

Publicado: 29 de dezembro de 2014 em Ruby on Rails

Em português iterador, é um objeto que permite a um programador examinar uma coleção ou container. Vários tipos de iteradores são frequentemente fornecidos através de uma interface de container. Apesar da interface e semântica de um determinado iterador serem fixas, iteradores são frequentemente implementados em termos de estruturas subjacentes a uma implementação de container e são muitas vezes ligados intimamente ao container para permitir a semântica operacional do iterador.

Observe que um iterador percorre e também dá acesso aos elementos de dados em um container, mas não realiza iteração (isto é, não sem alguma liberdade significativa tomada com este conceito ou com uso trivial da terminologia). Um iterador tem um comportamento semelhante a um cursor de banco de dados. Iteradores datam da linguagem de programação CLU de 1974.

Collection

É uma coleção, às vezes chamada de um recipiente (container), é simplesmente um objeto que agrupa vários elementos em uma única unidade. Coleções são usadas ​​para armazenar, recuperar, manipular e comunicar dados agregados, ou seja uma coleção é um objeto que contém outros objetos, existem outras coleções com diferentes capacidades.

Historicamente, o quadro de coleções têm sido bastante complexo, o que lhes deu uma reputação de ter uma grande curva de aprendizagem. Os exemplos mais conhecidos de frameworks de coleções são o C ++ Standard Template Library (STL). A nomenclatura das APIs e suas sintaxes podem mudar de uma linguagem de programação para outra.

Ruby - Container e Iterator

Ruby – Container e Iterator

Array e Hash

O Ruby possui dois tipos de containers, eles pertencem as classes Array e Hash. Os Arrays são ordenados, coleções indexadas por números inteiros de qualquer objeto, um Hash é uma coleção como um dicionário de chaves únicas e seus respectivos valores.

Array: http://www.ruby-doc.org/core-2.2.0/Array.html

Hash: http://www.ruby-doc.org/core-2.0/Hash.html

Exemplo:

Neste exemplo criamos uma classe para representar um item musical que contem determinadas informações de uma musica. Utilizamos um container para armazenar as musicas representando um álbum e utilizamos o iterador para navegar e imprimir o conteúdo do container.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Containers.rb

# Define classe
class Album
  
  # Métodos
  attr_accessor :id, :musica, :duracao
  
  # Construtor
  def initialize(id, musica, duracao)
    @id = id
    @musica = musica
    @duracao = duracao
  end

end

# Cria Array (Lista)
afd = [
  Album.new(1, "Welcome to the Jungle ", "4:34"),
  Album.new(2,"It's So Easy","3:23"),
  Album.new(3,"Nightrain","4:28"),
  Album.new(4,"Out Ta Get Me","4:24"),
  Album.new(5,"Mr. Brownstone","3:49"),
  Album.new(6,"Paradise City","6:46"),
  Album.new(7,"My Michelle","3:40"),
  Album.new(8,"Think About You","3:52"),
  Album.new(9,"Sweet Child O' Mine","3:21"),
  Album.new(10,"You're Crazy","3:17"),
  Album.new(12,"Anything Goes","3:26"),
  Album.new(12,"Rocket Queen","6:13")]

# itera lista
puts "Album - Appetite for Destruction  - GNR\n\n"

# Itera lista
afd.each do |musicas|
  # Recupera objetos
  objeto =  musicas
  # Imprime objeto
  puts String(objeto.id).ljust(5) +
              objeto.musica.ljust(40) + objeto.duracao.rjust(5)
  
end

Anúncios

Um módulo é um conjunto de métodos e constantes. Os métodos em um módulo podem ser métodos de instância ou métodos do próprio módulo. Módulos também proporcionam um espaço de nomes (namespace) onde pode-se organizar o código e evitar possíveis colisões de nomenclaturas. Os métodos de instância se comportam como métodos em uma classe quando o módulo está incluído na classe, os métodos do módulo não se comportam da mesma forma. Por outro lado, os métodos de módulos podem ser chamados sem criar um objeto de encapsulamento, enquanto os métodos de instância não podem.

Module: http://www.ruby-doc.org/core-2.2.0/Module.html

Linguagens como C++ permitem que uma classe possa herdar mais de uma classe, Ruby não, entretanto existe o conceito chamado Mixing que nos permite utilizar está mesma funcionalidade através dos módulos.

Ruby - Modules - Mixing

Ruby – Modules – Mixing

Exemplo:

Neste exemplo criamos um modulo chamado Portas e um modulo chamado Janelas. A especificação de objetos Ruby não permite múltiplas heranças ou seja, não permite que minha classe chamada Casa possa herdar as classes Portas e Janelas ao mesmo tempo, no entanto existe um modo de criar esta mesma funcionalidade incluindo os módulos em minha classe.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Mixing.rb

# Define modulo
module Portas
  
  def porta(tipo)
    puts "Portas: " + tipo       
  end
      
end

# Define modulo
module Janelas
  
  def janela(tipo)
    puts "Janelas: " + tipo
  end
  
end

# Define classe 
class Casa
  
 # Inclui modulos
 include Portas
 include Janelas
 
 def modelo(tipo, cor)
   puts "Casa ----------------->>>> 1\n\n"
   puts "Modelo:" + tipo
   puts "Cor: " + cor
 end
 
end

# Cria instancia do objeto
minhaCasa = Casa.new

# utiliza objeto
minhaCasa.modelo("Sobrado", "Branco")
minhaCasa.porta("Azul")
minhaCasa.janela("Amarelas")

A programação orientada a objetos permite que classes possam herdar estados e comportamentos comuns usados de outras classes. Neste exemplo, bicicleta torna-se agora a superclasse da classe BicicletaMontanha. Na linguagem de programação Ruby, cada classe é permitido ter uma superclasse direta, e cada superclasse tem o potencial para um número ilimitado de subclasses.

Ruby - Herança - Sobreposição - Super

Ruby – Herança – Sobreposição – Super

Override

Métodos Override (substituição), em programação orientada a objeto, é um recurso de linguagem que permite que uma subclasse ou classe filha possa fornecer uma implementação específica de um método que já é fornecido por uma de suas superclasses ou classes pai.

A implementação Override das subclasses substitui a implementação na superclasse, fornecendo um método que tem o mesmo nome, mesmos parâmetros ou assinatura, e mesmo tipo de retorno como o método na classe pai.

@ (Arroba – Ruby)

Uma variável associada ao sinal de arroba em Ruby significa uma variável da instancia ex: @variavavel.

Super

Usando super você irá chamar o mesmo método, mas, tal como definido na superclasse e consequentemente lhe fornecendo o resultado.

Exemplo:

Neste exemplo damos a classe BicicletaMontanha todos os mesmos campos e métodos da classe bicicleta, e ainda permite que seu código se concentre exclusivamente sobre as características que a tornam única. Isso faz do código de suas subclasses fáceis de ler. Usamos métodos Override neste exemplo de duas maneiras, para substituir um método da subclasse e adicionar mais um construtor com parâmetros.

No entanto, você deve tomar cuidado para documentar corretamente o estado e o comportamento que cada superclasse define, uma vez que o código não irá aparecer no arquivo de origem de cada subclasse.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Herança.rb

# Define classe
class Bicicleta

 # Define métodos assesores
 attr_accessor :modelo, :quadro, :rodas, :freios

 # Construtor
 def initialize(modelo, quadro, rodas, freios)
   @modelo = modelo
   @quadro = quadro
   @rodas  = rodas
   @freios = freios
 end  

 # Imprime modelo
 def imprimeModelo()
   puts "Modelo : " + @modelo
   puts "Quadro: "  + @quadro
   puts "Rodas: "   + @rodas
   puts "Freios: "  + @freios
 end

end

# Classe com Herança
class BicicletaMontanha < Bicicleta

 # Novos métodos assessores
 attr_accessor :marchas, :amortecedores, :garrafa, :gps

 # Construtor da classe
 def initialize(modelo, quadro, rodas, freios, marchas, amortecedores, garrafa, gps)

   # Super inicializa construtor da herança
   super(modelo, quadro, rodas, freios)

   # Inicializa variáveis
   @marchas = marchas
   @amortecedores = amortecedores
   @garrafa = garrafa
   @gps = gps

 end

 # Método Override - sobrepõe o metodo da classe super
 def imprimeModelo()

    puts "Modelo : " + modelo
    puts "Quadro: "  + quadro
    puts "Rodas: "   + rodas
    puts "Freios: "  + freios
    puts "Marchas: " + @marchas
    puts "Amortecedores: " + @amortecedores
    puts "Garrafa: " + @garrafa
    puts "Gps: " + @gps

 end

end

# cria instancia da classe Bicicleta
bike1 = Bicicleta.new("Street", "Aço", "Ferro", "Pastilhas")
puts "Bicicleta Numero ---> 1:"
bike1.imprimeModelo()

# Cria instancia da classe BicicletaMontanha
bike2 = BicicletaMontanha.new("Montain Bike", "Carbono", "Aluminio", "Disco", "10 M",
                              "RX 3000 oil", "Aliminio 500ml", "Discovery 300xs")
puts "\nBicicleta Numero ---> 2:"
bike2.imprimeModelo()

Ruby – Classes – Escopos – Linux

Publicado: 28 de dezembro de 2014 em Ruby on Rails

Escopo refere-se à vida e acessibilidade de uma variável. Quão grande é o alcance depende de onde uma variável é declarada. Por exemplo, se uma variável é declarada na parte superior de uma classe, ela será acessível a todos os métodos de classe. Se for declarada num método, em seguida, só pode ser utilizada em tal método.

Ruby - Escopo

Ruby – Escopo

O escopo de uma variável é a parte do programa que pode acessar uma variável. Quando você tenta acessar uma variável que não está no escopo, você normalmente tem um erro do compilador. Aqui estão algumas das regras de escopo:

  1. Variáveis globais estão no escopo do programa e podem ser utilizadas dentro de classes.
  2. Variáveis ​​de classe (campos estáticos) estão no escopo em todos os lugares na classe.
  3. As variáveis ​​e parâmetros locais estão no escopo apenas dentro do método que os declarou.

Exemplo:

Neste exemplo utilizamos tipos de variáveis que possuem diferentes alcances dentro do programa e de sua respectiva classe. Utilize os comentários no código abaixo para entender os diferentes tipos de escopos.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Escopo.rb

$variavel_global = "olá sou uma variavel global e existo em todo programa"

# Define classe
class Escopo

  # Variável da classe existe em toda a classe
  # não precisa de uma instancia do objeto para existir
  @@variavel_estatica = 0

  # Existe para toda a classe e fora dela (Métodos públicos - Variável Privada)
  attr_accessor :variavel_publica

  # Construtor da classe
  def initialize()
    @@variavel_estatica += 1
    @variavel_publica = "publica existo em toda classe e sub-classes"
  end

  # Retorna variável estatica
  def self.variavel_estatica()
      return @@variavel_estatica
  end

  # Imprime variável global
  def imprimeVariavelGlobal()
    $variavel_global = "Variável global modificada na classe"
    puts $variavel_global
  end

  #Imprime variável publica
  def imprimeVariavelPublica()
    puts  variavel_publica
  end

  # Imprime variável local
  # Existe somente dentro do método
  def imprimeVariavelLocal()
    variavel_local = "Sou uma variável local e só existo dentro deste método"
    puts variavel_local
  end

end

# Imprime escopos
puts "---------------- Escopos ----------------\n\n"
puts "imprime variável global:"
puts $variavel_global
puts "Imprime variável da classe: "
puts Escopo.variavel_estatica

# Cria uma instancia da classe
escopo = Escopo.new

puts "Imprime variável global dentro da classe:"
puts escopo.imprimeVariavelGlobal
puts "Imprime variável privada com métodos públicos:"
puts  escopo.imprimeVariavelPublica
puts "Imprime variável local:"
puts  escopo.imprimeVariavelLocal
puts "Reimprime variável da instancia pois já existe um objeto instanciado: "
puts Escopo.variavel_estatica

Encapsulamento que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações. Objetos restringem a visibilidade de seus recursos (atributos e métodos) aos outros usuários. Todo objeto tem uma interface, que determina como os outros objetos podem interagir com ele. A implementação do objeto é encapsulada, isso é, invisível ou visível  fora do próprio objeto.

Ruby - Encapsulamento - Public - Private - Protected

Ruby – Encapsulamento – Public – Private – Protected

Tipos de Acesso

  1. Public – deixa visível a classe ou membro para todas as outras classes, subclasses e pacotes.
  2. Private – deixa visível o atributo apenas para a classe em que este atributo se encontra.
  3. Protected – deixa visível o atributo para todas as outras classes e subclasses que pertencem ao mesmo pacote.  O protected é um intermediário entre public e private.

Publico VS Private

  • Publico todas as classes podem usar os métodos e campos.
  • Privado apenas a classe  podem usar os métodos e campos.

Por que Controlar o Acesso?

  • Proteger informação privada.
  • Esclarecer como outros programadores devem usar sua classe.
  • Manter a implementação separado da interface.

Exemplo:

Imagine o seguinte cenário,  temos uma classe que é responsável por transações de cartões de credito geralmente este tipo de classe pertence a companhia de cartões de credito e foi desenvolvida por um outro programador e esta dentro de uma DLL ou OS, acontece que o desenvolvedor terceirizado cometeu um deslize deixando visível a propriedade numero do cartão. Um desenvolvedor malicioso pode facilmente capturar o numero do cartão referenciando o objeto.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# ControleAcesso.rb

# Define classe 
class CartaoCredito
  
  # Assessores publicos
  # Estes assessores não deveriam existir
  # pois podem ser utilizados por qualquer um
  attr_accessor :cartao_public, :valor_public
  
  # Estes métodos controlam os assessores privados
  # Os encapsulando e permitindo quaisquer tipo de validações
  # como por exemplo usuários que podem utilizar a função
  
  def setCartao(cartao)
    # Você pode criar uma validação para
    # ter certeza que o usuário pode utilizar esta função 
    @cartao = cartao
  end
  
  def getCartao()
    # Você pode criar uma validação para
    # ter certeza que o usuário pode utilizar esta função
    return @cartao
  end
  
    def setValor(valor)
    # Você pode criar uma validação para
    # ter certeza que o usuário pode utilizar esta função 
    @valor = valor
  end
  
  def getValor()
    # Você pode criar uma validação para
    # ter certeza que o usuário pode utilizar esta função
    return @valor
  end
  
  # Declara setor privado
  private
  
  # Assessores privados
  attr_accessor :cartao, :valor 
  
end

# Os assessore públicos são visíveis para qualquer pessoa
c1 = CartaoCredito.new

# Acesso direto 
c1.cartao_public= "1234 5678 8900 1236"
c1.valor_public= 1234.56

puts "Acesso publico - Qualquer pessoa pode utiliza-lo"
puts "Cartão 1: " + c1.cartao_public + " ---- Valor: R$ " + String(c1.valor_public)

c2 = CartaoCredito.new

# c2.cartao="1234 5678 8900 1236"
# Caso tente acessar o metodo privado obterá o seguinte erro:
# private method `cartao=' called for #<CartaoCredito:0x00000001360e38>
# não possibilitando acesso direto ao assessor cartão

# Você deve permitir acesso aos assessores privados
# através do encapsulamento utilizando métodos públicos
# O método correto seria:

c2.setCartao("4567 1234 7890 3456")
c2.setValor(3456.89)

puts "\nAcesso privado - Você permite que utilizem através de métodos"
puts "Cartão 2: " + c2.getCartao + " ---- Valor: R$ " + String(c2.getValor)

Construtores são métodos especiais chamados pelo sistema no momento da criação de um objeto. Eles não possuem valor de retorno, porque você não pode chamar um construtor para um objeto, você só usa o construtor no momento da inicialização do objeto. Construtores representam uma oportunidade de inicializar seus dados de forma organizada. Construtores são obrigatórios em uma classe, mas não é preciso declara-los, caso não declare um construtor por default a declaração é:  Classe.new

Ruby - Métodos Estáticos

Ruby – Métodos Estáticos

Static

Declaração de  um tipo de Classe, método, propriedade ou variável que pertence exclusivamente a sua própria classe, classes estáticas não podem ser instanciadas. Métodos e variáveis estáticas não precisam ser instanciadas, em Ruby a palavra Static significa da classe e é substituída por self para métodos e @@atributo para atributos.

Exemplo:

Neste cenário queremos saber quantos bebês foram instanciados, para isto criamos um contador no construtor do objeto e a cada objeto criado o contador aumenta nos mostrando no final a quantidade exata de novos objetos de uma classe. Visto que nosso contador pertence a classe e não a cada instancia de cada classe, neste caso para usar o contador não precisamos instanciar a classe graças a declaração self para o método e @@ para o atributo.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# ClassesReferencia.rb

# Define classe bebê
class Bebe

  # Define atributos da classe (estático)
  @@quantidade = 0

  # Define método da classe
  def self.quantidade
    return @@quantidade
  end

  # Define construtor da classe
  def initialize()
    @@quantidade = @@quantidade + 1
  end
end

# Intancias de objetos bebês
Daniela = Bebe.new
Rodrigo = Bebe.new
Tamara  = Bebe.new
Mateus  = Bebe.new

# Imprime quantidade de instancias da classe Bebe
puts "Parabéns !!!!!"
puts "Você teve " + String(Bebe.quantidade) + " bebês"

Ruby – Classes – Referência – Linux

Publicado: 27 de dezembro de 2014 em Ruby on Rails

Referência na ciência da computação é registro que aponta o local em que se encontram armazenados os dados que identificam outro dado. Nas linguagens tradicionais variáveis são como canecas fixas e os primitivos são pequenos o suficiente para caber dentro da caneca. Os objetos são grandes para caber dentro de variáveis. Variáveis guardam números que localizam um objeto e a localização do objeto é chamada de referência. O Ruby possui apenas objetos então variáveis referenciam outros objetos.

Ruby - Referências

Ruby – Referências

Exemplo:

Neste cenário temos um bebê recém nascido que precisa ser registrado no cartório, para isto vamos criar um objeto bebê e através de um método de outro objeto chamado cartório vamos cadastrar os dados do bebê referenciando o objeto ao nosso bebê, tenha em mente que Ruby possui apenas objetos deste modo não possuímos tipos primitivos como outras linguagens de programação e não precisamos definir o tipo de cada objeto quando fazemos uma referencia a uma variável.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# ClassesReferencia.rb

# Define classe bebê
class Bebe
  # Define atributos
  attr_accessor :codigo, :nome, :peso, :tamanho, :nomepai, :nomemae, :genero
end

# Define classe cartório
class Cartorio
  
  # Cria método da classe(estático)
  # Transfere objetos por referencia
  def self.registro(codigo, dados, bebeRef )

    # Alimenta objeto bebe
    bebeRef.codigo = codigo
    bebeRef.nome=    dados[0]
    bebeRef.peso=    dados[1]
    bebeRef.tamanho= dados[2]
    bebeRef.nomepai= dados[3]
    bebeRef.nomemae= dados[4]
    bebeRef.genero=  dados[5]
    
    # Imprime registro
    puts "Registro:" + String(bebeRef.codigo)
    puts "nome: " + bebeRef.nome
    puts "Peso: " + bebeRef.peso + " tamanho: " + bebeRef.tamanho
    puts "Genero: " + bebeRef.genero
    puts "Pai: " + bebeRef.nomepai
    puts "mãe: " + bebeRef.nomemae

  end
end

# Cria instância do Bebê
bebe = Bebe.new

# Preenche ficha do cartório
fichaRegistro = ["Samanta Amaral", "2.8kg", "36cm", 
                 "Roberto Amaral", "Marcia Amaral","Feminino" ]

# Registra bebê
# Passa objeto ficha e objeto bebe por referencia
Cartorio.registro(123456, fichaRegistro, bebe)

Ruby – Classes – Linux

Publicado: 27 de dezembro de 2014 em Ruby on Rails

Programação orientada a objetos representa o mundo real. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software. Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Em outros termos, uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar.

Porque Usar Classes?

No mundo real, muitas vezes você vai encontrar muitos objetos individuais todos da mesma espécie. Pode haver milhares de outros bebês na existência, todos parecidos. Cada bebê foi construído a partir do mesmo conjunto de projetos(DNA) e, portanto, contém os mesmos componentes. Em termos de orientação a objetos, dizemos que o seu bebê é uma instância da classe de objetos conhecidos como bebê. Uma classe é o modelo a partir do qual objetos individuais são criados. Criando a classe bebê teremos um objeto bebê com seus atributos definidos:

Bebê

Bebê

Classes Ruby

Em Ruby tudo é um objeto, então podemos dizer que tudo tem uma classe, deste modo Ruby possui alguns conceitos diferentes de outras linguagens de programação hibridas como por exemplo C++ e Java. Entretanto uma classe escrita em Ruby também possui os conceitos básicos da linguagem orientada a objeto e possui basicamente 3 partes distintas:

  • A Definição da classe  (Nome da classe: Bebe).
  • Os membros da classe (Atributos da classe: nome, peso, tamanho).
  • Construtor da classe (Método: initialize).
Classe - Bebê

Classe – Bebê

Exemplo:

Neste exemplo criamos uma classe chamada Bebe e criamos um construtor para inicializar os valores para cada bebê que for instanciado, e também utilizamos um recurso que nos permite não inicializar valores na classe simulando um construtor Overload, no qual permite instanciar um objeto Bebe com valores ou sem valores definidos podendo alimenta-los através de métodos ou atributos a qualquer hora.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Classes.rb

class Bebe

   # Define atributos
   attr_accessor :nome, :peso, :tamanho
   
   # Define construtor da classe (Efeito Overload)
   def initialize (nome = nil, peso=nil, tamanho=nil)
     @nome = nome 
     @peso = peso
     @tamanho = tamanho
   end
  
end

# Cria instância do Bebê construtor defindo
b1 = Bebe.new("Daniel", "3.5", "36")

# Cria instância do Bebê construtor overload
b2 = Bebe.new

# Alimenta valores nos atributos publicos
b2.nome="Sabrina"
b2.peso="2.7"
b2.tamanho="32"

# Imprime Bebês
puts "Bebê 1:", "Nome: " + b1.nome, "Peso: " + b1.peso, "Tamanho: " + b1.tamanho + "cm"

puts "\nBebê 2:", "Nome: " + b2.nome, "Peso: " + b2.peso, "Tamanho: " + b2.tamanho + "cm"

Ruby – Methods – Getter e Setter – Linux

Publicado: 27 de dezembro de 2014 em Ruby on Rails

Métodos em sua forma mais simples são sub-rotinas e podem ser tanto um procedimento ou uma função, geralmente estão associados a um objeto, mas podem ser utilizados independente de estarem ou não dentro de uma classe, isto vai depender exclusivamente do paradigma de programação que você vai escolher programar.

Genericamente falando, métodos alimentam e retornam valores, no entanto existem vários tipos de métodos especialmente no paradigma de programação orientada a objeto, os mais comuns são chamados de Getters e Setter, servem especificamente para retornar e alimentar objetos, especificando ou validando alguma regra de negocio entre seu processo.

Ruby - Métodos - Getter e Setter

Ruby – Métodos – Getter e Setter

Exemplo:

Neste exemplo criamos uma simples variável global que é alimentada através do método Setter e retornada através do método Getter, este tipo de método é comumente visto dentro de classes na programação orientada a objeto.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Métodos.rb

# Define uma variável global 
$meuvalor = 0
 
# Os metodos mais comuns definem e retornam valores

# Retorna valor da variável global
def getValor()
  return $meuvalor
end

# Alimenta valor na variável global
def setValor(valor)
   $meuvalor = valor
end

# método para alimentar valor
setValor(10)

# método para retornar valor
puts "Meu valor é :", getValor()

O termo Enterprise se refere a organização empresarial corporativa. Na indústria de computadores, o termo é frequentemente usado para descrever qualquer grande organização que utiliza computadores, sistemas operacionais, softwares ou ferramentas de desenvolvimento para o mundo dos negócios. E ao analisarmos o DNA das soluções Enterprise que encontramos nos dias de hoje, sem duvida encontraremos a herança de uma empresa que foi amplamente responsável por tudo que conhecemos, a IBM, empresa pioneira no desenvolvimento de hardware e softwares corporativos.

O principal software corporativo é chamado de Enterprise Resource Planning (ERP) e grande parte de toda infraestrutura e metodologias existentes no universo corporativo prezam garantir que este software funcione perfeitamente desde o inicio da era da computação empresarial. O ERP nasceu de seu antecessor, Manufacturing Resource Planning (MRP) e evoluiram desde os primórdios dos pacote de gerenciamento de banco de dados comercial desenvolvido por Gene Thomas na IBM na década de 1960. Logo os primeiros sistemas ERP foram concebidos como uma ferramenta organizacional e de programação para as empresas industriais. A função da próxima geração de sistemas de software ERP foram estendidos além dos limites do que poderia ser feito para uso interno de uma empresa de fabricação individual e começou a incluir clientes e fornecedores. Não demorou muito para que outras indústrias reconhecessem os benefícios dos sistemas ERP, então as agências governamentais e organizações do setor de serviços também começaram a tirar proveito desta tecnologia.

A evolução se deu dos processos executados em grandes mainframes, como IBM/360 para os processos atuais que gerenciam enormes quantidades de dados em tempo real e são executados em diferentes plataformas transpondo os limites físicos das empresas, permitindo que o processo de trabalho continue sem fronteiras e a qualquer hora, em qualquer lugar.

De onde vem os softwares Enterprise?

Um rápido passeio pela historia das três maiores soluções Enterprise encontradas no mercado de software da atualidade, nos mostram o como foi o inicio dos sistemas corporativos:

A SAP AG criada em 1972 por cinco consultores da IBM que perceberam a possibilidade de criar um pacote de software padrão a ser executado em um mainframe IBM. Em dezoito meses foi criado o sistema R que foi renomeado para R/1, sendo seguido pelo sistema R/2 de duas camadas e logo depois o R/3 apareceu inicialmente no final dos anos 80 quando a IBM lançou sua arquitetura SNA, mas foi decidido trabalhar com Unix no lugar do mainframe IBM e após cinco anos de desenvolvimento, em 1992 o sistema R/3 finalmente foi lançado.

A JD Edwards World Solution Company, foi fundada em março 1977 e era uma empresa de software empresarial, o foco inicial da empresa foi o desenvolvimento de um programa de contabilidade necessário para seus clientes. Seu produto mais popular chamado World era centralizado em servidores, bem como multiusuário; os usuários poderiam acessar o sistema usando um dos vários terminais de computador da IBM ou “telas verdes”. Como um sistema ERP, o JD Edwards World incluía as três áreas básicas de atuação: analista funcional/negócios, desenvolvedor/programador e  administração do sistema.

O Microsoft Dynamics AX foi originalmente desenvolvido como uma colaboração entre a IBM e a dinamarquesa Damgaard Data que resultou no IBM Axapta. O Axapta foi inicialmente lançado em março de 1998, nos mercados dinamarqueses  e norte-americanos. A IBM devolveu todos os direitos sobre o produto para a Damgaard Data logo após o lançamento da versão 1.5 antes da Damgaard Data ser fundida com Navision Software A/S em 2000, a empresa combinada, inicialmente Navision Damgaard, depois Navision A/S, foi adquirida pela Microsoft em julho de 2002 e em setembro de 2011, a Microsoft anunciou o lançamento da versão nova AX 2012.

Hoje a IBM não possui uma solução de ERP mas ela endossa através de suas alianças poderosas soluções em conjunto com a SAP e Oracle:

IBM ERP Alliance: http://www.ibm.com/solutions/alliance/us/en/index/erp.html

????????????????????????????????????????
O que os Softwares Corporativos Podem Fazer?

Unificar os dados como um todo, integrando os sistemas de gestão empresarial, permitindo a centralização de todo o negócio em uma única fonte, pois são desenvolvidos para atender às necessidades das diferentes áreas de uma empresa.

As varias ferramentas oferecem aos seus gestores um maior controle sobre suas operações e planejamentos, interligando todos os departamentos e se tornando um importante apoio às decisões estratégicas da diretoria, indicando os mercados mais lucrativos no qual pode-se investir.

Como beneficio a empresa passa a obter maior agilidade aos processos e uma maximização de resultados a longo prazo, com a padronização das informações internas consegue-se uma ampla visibilidade dos procedimentos empresariais e uma automação das dinâmicas de apoio. A obtenção de dados em tempo real, possibilita a eliminação das falhas de comunicação entre os setores e um melhor gerenciamento de qualidade de seus produtos ou serviços e também um melhor relacionamento com os seus clientes.

Como é a arquitetura de um software Enterprise?

Os softwares Enterprise geralmente utilizam o topo da tecnologia disponível em termos de hardware. Novos hardwares são construídos para atender as novas exigências que as empresas demandam com o crescimento baseado no beneficio da tecnologia que elas adquirem, sendo assim novos hardwares necessitam de novas versões de softwares e sistemas operacionais para que possam ser controlados, gerando um ciclo de desenvolvimento de tecnologia de ponta.

Os programas Enterprise atuais utilizam uma arquitetura de três camadas, cada camada é auto contida o suficiente de forma que a aplicação pode ser dividida em vários computadores em uma rede distribuída. As camadas são compostas da interface do usuário (Camada de Apresentação ou Servidor de Apresentação); da lógica do negócio (Camada de Negócio ou Servidor de Aplicação) e da camada de banco de dados (Camada de Dados ou Servidor de Dados). Cada camada desta arquitetura é normalmente mantida em um ou mais servidores para tornar-se mais escalonável e independente das demais. Com o mesmo objetivo são utilizadas tecnologias de middleware como, por exemplo, COM, CORBA, Web Services ou RMI. Esta arquitetura tem como características baixos custos de disponibilização, de mudança da base de dados, de mudança na lógica de negócios, eficiente armazenamento e reutilização de recursos.

Três camadas SAP:

R/3 - Três camadas

R/3 – SAP – Três camadas

Três camadas Oracle:

JD Edwards - três camadas

JD Edwards – Oracle – Três camadas

Três camadas Microsoft:

Dynamics - Microsoft - Três camadas

Dynamics – Microsoft – Três camadas

Como funcionam na pratica para desenvolvedores e consultores?

Os softwares corporativos que integram a linha empresarial como já vimos ditam não só a tecnologia de hardware e software mas também o funcionamento de empresas de tecnologia, de desenvolvimento ou consultorias que trabalham com este tipo de solução.

No mercado de softwares corporativos um desenvolvedor em alguns casos também é um tipo de consultor ou especialista, outras profissões que conhecemos no mercado da tecnologia também se enquadram no time de consultores tendo sua própria nomenclatura, os códigos fontes são abertos e podem ser herdados e modificados, porem geralmente tudo que é desenvolvido dentro de um software corporativo pela licença sob o qual ele é gerido é de propriedade da empresa fabricante do software, entretanto é permitindo que consultorias desenvolvam e comercializem módulos adicionais para seus produtos seguindo as melhores praticas de desenvolvimento, implantação e manutenção da empresa detentora da solução.

Os sistemas ERP podem se conectar com qualquer banco de dados topo de linha do mercado e tem como parceiros as empresas fabricantes de cada banco, quando também não é proprietária de uma solução de banco de dados, em ambos os casos os bancos de dados possuem Features exclusivas desenvolvidas para uso com cada um destes sistemas. Os sistemas ERP contam com um dicionário de dados que controla o banco de dados em uso, permitindo que o sistema e os desenvolvedores utilizem uma linguagem única para acesso a dados. Possuem também seu próprio compilador e sua própria linguagem de programação na qual as consultorias podem desenvolver novos módulos ou modificar módulos existentes.

A SAP possui a linguagem Abap, a Oracle utiliza entre outros métodos a linguagem C e a Microsoft a linguagem X++. As empresas terceirizadas também podem desenvolver outros softwares corporativos que se comunicam com o ERP através de um protocolo de comunicação especifico, geralmente utilizando as tecnologias DCOM ou Corba e são nada mais que interfaces para a comunicação entre um sistema proprietário e outro compatível de terceiros através de conexões TCP/IP e podem chamar funções remotas do ERP que são criadas para inserir ou exportar dados garantindo a consistência de dados utilizando a própria regra de negocio do ERP e fornecendo uma maneira para que um programa externo escrito em linguagens como  Java, C, C ++C# ou outras línguas possam também atuar como o cliente ou servidor em uma chamada.

SAP – Abap: Linguagem de programação.

Oracle – JDE: Development Tools.

Microsoft – MorphX: IDE e linguagem X++.

Solutions_key
Como é a Metodologia dos Softwares Enterprise?

Com décadas de experiência no mercado corporativo os softwares empresariais desenvolveram algumas metodologias ao longo dos anos que possibilitam que as empresas utilizem de forma adequada suas soluções, abrangendo todas as fases de um projeto desde a engenharia de software, a definição de escopo, passando pela especificação funcional, design, construção, testes, até chegar à validação, implantação e uso produtivo da solução.

ASAP Methodology: Metodologia ASAP

Oracle Unified Method: Metodologia OUM

Microsoft Dynamics Sure Step methodology: Metodologia MS Sure Step

Falando de modo genérico já que estamos nos referindo a três ótimos softwares empresariais da atualidade, podemos perceber que os três possuem uma arquitetura semelhante que proporciona uma metodologia muito similar para execução de seus projetos, deste modo, segue uma visão geral de um projeto corporativo.

A fase de preparação geralmente é executada por um gerente de projetos e engloba o escopo, estimativas, planejamento inicial do projeto, cronograma, aspectos técnicos, definição de equipe, identificação de riscos e estratégias, planejamento de controle de qualidade e o inicio do projeto.

A fase inicial, já com os recursos definidos em ação, o gerente de projeto e os analistas funcionais devem tratar do levantamento dos processos de negócio, gestão do projeto, mudanças organizacionais, definição dos novos processos de negócio, necessidades e mudanças organizacionais.

Com toda a definição realizada, já na fase de customização e desenvolvimento, entra em cena os consultores especialistas que iniciam a configuração, implementação e o desenvolvimento das definições funcionais que entre elas estão a configuração base, a configuração final, desenvolvimento de programas, implementação de interfaces, testes unitários, testes integrados, documentação de cenários e processos, execução dos treinamentos aos key users e usuários, controle de qualidade e a correção de possíveis erros.

Na fase de pré-produção toda atenção se volta aos detalhes finais como, testes de volume, testes de stress, planejamento da implantação, estratégia de implantação, treinamentos finais e o controle de qualidade.

Com tudo pronto o projeto é finalmente implantado e o sistema é colocado em produção e os retoques finais são a transferência de pré-produção, ajuste da configuração de hardware, ajustes na configuração de software, base de dados, sistema operacional e outros. Só então se inicia os treinamentos finais, suporte aos key-users e usuários e encerramento do projeto.

Ambientes Corporativos

Integrando a metodologia de gestão de projeto os softwares corporativos e suas demais ferramentas são desenvolvidas para utilizar ambientes específicos nos quais tem o intuito de maximizar a eficiência dos métodos de implantação, desenvolvimento, testes, qualidade, treinamento, utilização e gerenciamento dos produtos adquiridos. Cada ambiente possui suas especificações de uso e são utilizados para uma finalidade especifica e devido a eficiência deste modelo outras metodologias também utilizam alguns destes cenários.

Ambientes do SAP:

Alguns dos ambientes SAP

Alguns dos ambientes SAP

Ambientes da Oracle:

Alguns dos ambientes Oracle

Alguns dos ambientes Oracle

Ambientes da Microsoft:

Alguns dos ambientes Microsoft

Alguns dos ambientes Microsoft

Como Desenvolver Suas Próprias Aplicações Enterprise?

As grandes empresas de tecnologia que desenvolvem o hardwaresoftware para o mercado corporativo em sua maioria também desenvolvem ferramentas para desenvolvimento de softwares para empresas terceirizadas, para que estas possam desenvolver seus próprios softwares empresariais ou soluções que complementas as soluções já existentes, entre elas a Oracle, a IBM, a Microsoft e com exceção da SAP que também utilizam em certos casos o Java da Oracle e ferramentas da IBM como a IDE Eclipse. Todas disponibilizam um vasto matérial sobre como desenvolver seus próprios projetos Enterprise, veja os seguintes links:

Microsoft: http://msdn.microsoft.com/en-us/library/ff648951.aspx

Oracle: http://www.oracle.com/technetwork/java/javaee/overview/index.html

IBM: http://www.ibm.com/developerworks/

SAP: Enterprise Learning

O primeiro passo é ter em mente que um software enterprise bem sucedido necessita de hardware adequado, arquitetura e programação adequada, metodologia adequada, consultoria adequada e o mais importante de tudo um grande know-how das regras de negocio das áreas incluídas no escopo de sua solução.