HashCode

An organizer of symbols

Archive for the ‘Semiótica’ Category

Executive IT Meeting em Goiânia

Friday, October 26th, 2007


Gostaria de Convidar a todos a participarem do Executive IT Meeting l em Goiânia, 29..31 de outubro de 2007.
Vou representar a comunidade(espero ser capaz) :)
O meu amigo Alexandro Lima fez uma Charge para o evento.

palestra_rubi_contec.jpg

Nossa participação será no dia 31 na parte da tarde:

Palestra: Linguagem Ruby - Minerando e Lapidando.
Filosofia, idiossincrasia e pragmática da linguagem.

Tutorial: Ruby on Rails - Overview sobre o Framework do Ano.
Desenvolvendo um aplicação MVC em Rails.

Espero vcs lá hein! :)

Composição de funções em pilha

Tuesday, September 11th, 2007

Lendo e testando o post do Tom Moerte sobre
Composição de funções em Ruby traduzido pelo Akita e refatorado pelo TaQ, a solução de composição de blocos/funções baseai-se em um operador de composição(em Haskell) para geração de uma nova função, simplificando o cálculo e dividindo o problema em partes.

Já em Postscript é implícita tal composição. Por ser uma Linguagem de Programação Orientada a Pilha com a sintaxe Pós-Fixada (Notação Polonesa Invertida) os argumentos e os operadores ficam em um contexto único(pilha), facilitando a execução de cálculos matemáticos sem a necessidade de criar um operador “que junta as funções e passa os parâmetros”. Muito mais simples. Acompanhe.

Primeiramente observe a função

f(x) = X² + 1

Portando para X= 3, temos

f(3) = 3² + 1
f(3) = 10

a mesma função em notação polonesa com operadores postscript

3 2 exp  1 add

quando é executado 3 2 exp o resultado 9 fica na pilha, o valor 1 também está na pilha então 9 1 add resulta em 10. Veja no ghostscript o passo-a-passo(pstack mostra os valores da pilha)

GS>3
GS<1>2
GS<2>pstack
2
3
GS<2>exp
GS<1>pstack
9.0
GS<1>1
GS<2>pstack
1
9.0
GS<2>add
GS<1>pstack
10.0

Vamos criar as funções

/square { 2 exp} def         % eleva ao quadrado o valor corrente
/inc { 1 add } def         %adiciona 1 no valor corrente

testando

GS>3 square
GS<1>pstack
9.0
GS<1>inc
GS<1>pstack
10.0

A composição
Apenas aninhar as funções

/nova{ square inc } def
GS>3 nova
GS<1>pstack
10.0

Programação em pilha tem lá suas vantagens mas não é nada humano.

Limite por Tipo ou Aspecto

Tuesday, August 7th, 2007

A Ruby não faz distinção de elementos de um Array, o que eu acho uma vantagem fundamental, pois, a classe Array é uma classe para atender o escopo dos objetos remanescentes da linguagem. Como já conhecido por programadores em java, um array é de tamanho fixo e obedece a premissa que todos os elementos terão o mesmo tipo(considerando hierarquia). Em um aprendizado básico e inicial de uma linguagem de programação, a tipagem obrigatória é de fácil entendimento mas a coisa que contem coisas pode ou não aceitar tipos genéricos. Exemplo de uma mochila genérica no preposto abaixo

“Uma mochila onde aceita objetos menores que ela como, caneta, pendrive, laptop, absorvente, cueca, etc.”

Em uma tentativa de identificar o sexo do(a) dono(a) da mochila pelo seu conteúdo fica complicado pelo fato que ‘absorvente’ é usado por mulheres e ‘cueca’ por homens( normalmente é assim :).

Uma mochila genérica de um homem(deixa de ser genérica e passa a ser mochila-homem) não aceita ‘absorvente’ mas continua aceitando o catálogo de objetos masculinos. E outra coisa quando eu digo que a mochila ‘aceita objetos menores que ela’ também deixa de ser genérica e passa a ser limitada.

Limite por Tipo ou Aspecto

Em Java(a linguagem) as coleções tais como Vector e HashSet que antes da versão 1.5 recebiam apenas o tipo do topo da hierarquia ficando a critério do programador especificar em implementação de interfaces as conversões e verificação de tipo. Em uma proposta mais humana e menos burocrática o java 1.5 recebeu as definições de Generics tendo apenas a deficiência da dispersão das psedos-tags na declaração e na instância do objeto.

Array em Ruby o tipo não importa e também a linguagem não define uma limitação fixa da quantidade de elementos e as peculiaridades relativa a cada instância da coleção.

Considerando a linguagem na sua mais simples forma, a forma padrão sem APIs externas nenhuma das duas linguagens define uma coleção por aspecto.

Como seria este aspecto então?

Seria uma coleção capaz de determinar um contrato não burocrático sobre quais aspectos gostarias que a classe tenha. Algo como

“Aceite qualquer instância que siga a seguinte regra: tenha o método ’somar’ , criada na terça-feira, tenha a variável ‘hello’(string) com o conteúdo maior que 5″

Você deve estar pensando “Você tá ficando doido!!”… não, não é isso; isso é : Reduzir as condicionais para uso de elementos da coleção pense em “Coleções cuja as condicionais fiquem na entrada do elemento e não na saída”

De volta a pragmática…

Proponho aqui uma forma de criar um Array em Ruby que aceita apenas um tipo de classe, podemos estudar depois como fariamos algo utilizando os aspectos do objeto….

Módulo OnlyClass
Criei o módulo OnlyClass para facilitar o acoplamento na classe Array. Temos então a instância de um Array que aceita apenas um tipo de classe:

 colecao=Array.only String

O uso da classe é normal, há apenas verificação de inclusão dos elementos, neste caso String.

 colecao=Array.only String
 colecao << "Um elemento"   #ou
 colecao[1]="Dois elemento"  #ou
 colecao.push("Mais um elemento","Mais n elementos")

Veja que o array adiciona os elementos sem problema. Mas quando um elemento não for do tipo especificado uma exceção será lançada.

 colecao=Array.only String
 colecao << "esse vai"
 colecao << 333 #esse não
 #TypeError: can't append Fixnum into Array.only String

Módulo OnlyClass obtendo elementos e elementos dos métodos

Criei uma forma automática de obter os elementos de um método específico que já é comum a todas as instâncias pertencentes a coleção. Um exemplo seria obter os sucessores de todos elementos de um Array#Fixnum, chamando o each_nome-do-método-de-instância e um bloco(opcional)

 colecao=Array.only Fixnum
 colecao << 10
 colecao << 20
 colecao.push(30,40)
 colecao.each_succ {|n| puts n}
#resultado
# 11
# 21
# 31
# 41

sem o bloco, atribuição do resultado em uma variável

 colecao=Array.only Fixnum
 colecao << 10
 colecao << 20
 colecao.push(30,40)
 succs=colecao.each_succ              #=> [11, 21, 31, 41]

Podemos também passar parâmetros para o método, exemplo: obter todos os valores do resultado do match de cada elemento em um array.

 colecao=Array.only String
 colecao << "Um elemento"   #ou
 colecao[1]="Dois elemento"  #ou
 colecao.push("Mais um elemento","Mais n elementos")
 colecao.each_match(/.*u.*/) {|r| puts r}
#saída
# nil
# nil
# "Mais um elemento"
# nil

ou substituir os valores internos

 colecao=Array.only String
 colecao << "Um elemento"
 colecao[1]="Dois elemento"
 colecao.push("Mais um elemento","Mais n elementos")
 colecao.each_gsub!(/elemento/,'coisa')    #=> => ["Um coisa", "Dois coisa", "Mais um coisa", "Mais n coisas"]

(’asterisco’ == 42.chr) != ?* => true

Wednesday, June 27th, 2007

Estava comprando alguns livros e achei um de promoção “O Signo, de Isaac Epstein” foi baratinho, mas também oitenta páginas… O livro em si me despertou um grande interesse pelo assunto de semiótica. Não demorou para que adquirisse o livro “Semiótica, de Charles S. Peirce” que define semiótica como a filosofia científica da linguagem. Linguagem no sentido de algo provê a comunicação entre duas ou mais coias através de elementos, como signos, sons, símbolos, mímicas e outros. A Semiótica é redefinida por vários autores mas a definição de Charles detêm minha atenção mais do os outros que consideram apenas uma disciplina da cadeira de lingüística.

Na graduação de Ciência da Computação a matéria que mais me interessou(e interessa) foi(é) Linguagens Formais e Compiladores, vendo a formação dos componentes de uma gramática, a validação, organização e significado de símbolos e palavras de um determinado código-fonte. Os passo dos analisadores léxicos, sintáticos e semáticos nada mais é do um dos nossos sistemas de interpretação de mensagens.

Desde a infância passamos pelos mesmos processos te entendimento dos signos e vamos adquirindo base de conhecimento capacitando-nos a detecção de padrões dos mais simples aos mais complexos, como: “se há fumaça => há fogo”, “se algo está úmido => é porque tem algo líquido”. Parece fácil mas as vezes ao pensarmos em uma solução nos deparamos com a falta desta comparação do que conhecemos e o que é novo.
Vamos fazer um estudo de caso de um símbolo o asterisco.

O Asterisco

Se perguntarmos o que é * a uma criança que não conhece a palavra asterisco teremos entre outras respostas algo como “é uma estrelinha”, “um pontinho explodido”…. Para um adulto a afirmação é um “asterístico” e para os mais sensatos “asterisco” lexicograficamente correto. Portando entramos na idiossincrasia; que é a forma de percepção individual do símbolo. Por exemplo, cada um tem o asterisco como um símbolo que representa algo de forma distinta.

Qual a função(significado) do símbolo asterisco?

Não sei. Depende da linguagem, do contexto em que se encontra.

Para a língua portuguesa ele não faz parte da gramática e nem do alfabeto. Em anúncios sabemos que ele é o “porem ou o lá-invem!”. Exemplo.: ‘Fale a R$ 0,01*’, nas letras bem pequenas temos ‘promoção válida somente para falar que ama sua sogra no dia 30 de fevereiro’. Em alguns livros o * induz ao leitor ler o rodapé explicativo, etc. Já na informática comum pode ter vários significados. Temos alguns:

- Em um editor de texto moderno tenta detectar que o * é um marcador e troca por uma bolinha.
- Caractere de multiplicação
- Todos arquivos em uma lista de arquivos. Ex: ls *.txt

Veja a cima que o asterisco é também um ‘Caracter de multiplicação’. Agora você lembra da terceira série que o x era o sinal de multiplicação? E mais adiante …

2 x 2 = 4

depois

2 . 2 = 4

e agora no computador

2 * 2 = 4

Calma, não fique louco, já passamos desta fase… mas deu para entender um pouco sobre idiossincrasia. A sua idiossincrasia tem que ser mutável principalmente para usar a linguagens de programação como C e Ruby. Em C temos ponteiro com * para o valor e ** ponteiro para apontador…, comentários e assim vai. Demonstraremos abaixo como o asterisco pode ser genérico em uma linguagem computacional, Ruby.

Asterisco em Ruby
O caracter

42.chr #=> '*'

o valor ASCII do caracter

?*   #=> 42

Em Ruby o asterisco pode ser um método
Multiplicação (Numeric * Numeric)

2 * 2       #=>  	4

Potenciação (Numeric ** Numeric)

2**3	  #=> 8

Classe String(String * Numeric)

'ha! '  * 5	#=> 'ha! ha! ha! ha! ha! '

Classe Array (Array * String)

[20, 30, 40] * ':'   #=> '20:30:40'  o mesmo que join

Observe que o resultado que é a multiplicação de todos os elementos e não uma operação distributiva de matemática. (Array * Fixnum)

[20, 30, 40] * 2 #=> [20, 30, 40, 20, 30, 40] 

mas podemos redefinir o método * para um resultado diferente

a=[20, 30, 40]
def a.*(valor)
  self.map{|v| v*valor}
end
a * 2     #=> [40, 60, 80]

Expressões Regulares, zero ou mais ocorrências

a='asterisco'
a =~ /a*/      #=> 0
a =~ /z*/      #=>0

Atribuição
Atribuição com multiplicação

d=2
d*=2   #=> 4

Atribuição com potenciação

d=2
d**=3  #=> 8

Atribuição paralela

a=[1,2,3,4]
x,y=a      #=> x =1 e y=2
x,*y=a    #=> x=1 e y=[2,3,4]
x,*y=33  #=> x=33 e y=[]

Conversão em Array de um argumento de bloco

a=[1,2,3,4,5]
a.each {|v| puts v}
1
2
3
4
5
a.each {|*v| puts v}
[1]
[2]
[3]
[4]
[5]

Argumentos de linha de comando

ruby -e 'puts $*' teste1 teste2

resultado

teste1
teste2

equivalente ao ARGV

ruby -e 'puts ARGV' teste1 teste2

resultado

teste1
teste2

Utilização em argumentos
Na definição do método

def teste(um_valor, *argumentos)
  puts 'valor = '  + um_valor.to_s
  puts 'args = '  + argumentos.join(', ')
end

utilizando o método teste

teste('A',2,'B',4,5,6,7)

resultado

valor = A
args = 2, B, 4, 5, 6, 7

passando um array

array=[20,'C',40,'D']
teste(array)

resultado

valor = 20C40D
args =

mas com a mágica do *

array=[20,'C',40,'D']
teste(*array)

resultado

valor = 20
args = C, 40, D

o mesmo vale para o case. Case normal

s='teste'
case s
  when Fixnum: puts 'N'
  when String,Symbol: 'S'
 end

resultado

'S'

podemos fazer assim com *

s='teste'
tipos=[String,Symbol]
case s
  when Fixnum: puts 'N'
  when *tipos: 'S'
 end

resultado

'S'

Asterisco em Ruby dá nó na cabeça mas depois começamos a entender a idiossincrasia do Matz.