Utilização de Tiny Types

[Fabrício Cabral]

Olá todos!

Gostaria de saber se vocês utilizam tiny types em seus sistemas.

Se sim, o que tem achado deles? O que trouxe de benefícios?

Se não, por que não os utiliza? Quais as desvantagens?

Algumas referências interessantes sobre o tema:

http://darrenhobbs.com/2007/04/11/tiny-types/

http://blog.caelum.com.br/pequenos-objetos-imutaveis-e-tiny-types/

http://martinfowler.com/ieeeSoftware/whenType.pdf

[]'s

--
--fx

[Marcos Tupan]

Não utilizo. Achei super interessante a utilização dele e realmente só vejo beneficios na sua utilização, deixando o código mais legivel, de melhor manutenção e promovendo uma melhor distribuição de responsabilidades. Vou procurar utilizar em algum novo projeto e se possivel em algum antigo durante um code refactoring...

Precisa ver a fundo a questão de performance para alguns tipos de sistemas.

Achei muito bacana o assunto.

Valew

 

--
Você recebeu esta mensagem porque faz parte do grupo .Net Architects hospedado no Google Groups.
Para postar envie uma mensagem para dotnetar...@googlegroups.com
Para sair do grupo envie uma mensagem para dotnetarchitec...@googlegroups.com
Para mais opções visite o grupo em http://groups.google.com/group/dotnetarchitects?hl=pt-br
---
Você está recebendo esta mensagem porque se inscreveu no grupo ".Net Architects" dos Grupos do Google.
Para cancelar a inscrição neste grupo e parar de receber seus e-mails, envie um e-mail para dotnetarchitec...@googlegroups.com.
Para obter mais opções, acesse https://groups.google.com/groups/opt_out.
 
 

--
Marcos Tupan
|41| 9147-8335

[edmilson hora]

Eu  gosto de utilizar Tiny Types,  coisas  como  CPF, CNPJ e até mesmo Datas  gosto de trabalhar com pois facilita validação e tal.

Só acho exagero colocar FirstName como Tiny Type, algumas coisas que são boas práticas podem até se  tornar problemas, se não foram bem dozadas. 

[]´s

---

De: Marcos Tupan <mtu...@gmail.com>
Para: dotnetar...@googlegroups.com
Enviadas: Segunda-feira, 29 de Abril de 2013 12:11
Assunto: Re: [dotnetarchitects] Utilização de Tiny Types

[Luiz Carlos Faria]

Eu concordo com o Edmilson, e uso apenas quando tenho ganhos. Mas o conceito é bem interessante!

[Fabrício Cabral]

Edmilson,

neste caso, eu crio um tiny type chamado Nome e o utilizo tanto em

nome como em sobrenome. Neste tipo Nome, guardo uma string que

só pode conter letras e alguns *poucos* caracteres especiais, como

o apóstrofo.

2013/4/29 edmilson hora <edmils...@yahoo.com.br>

--
--fx

[Fabrício Cabral]

Pessoal,

só para enriquecer mais o assunto: enviei a mesma pergunta também

para a lista de DDD gringa e o feedback que eu obtive (embora de poucos)

foi bem positivo para a sua utilização.

[]'s

2013/4/29 Marcos Tupan <mtu...@gmail.com>

--
--fx

[João Paulo Rezende da Silva]

Olá Fabricio, passa pra mim essa lista que você participa e o feedback!

Valeu

[Fabrício Cabral]

Pois não, João!

Link da lista: http://tech.groups.yahoo.com/group/domaindrivendesign/

E aqui as mensagens. Peço desculpas pela *besteira* que eu fiz:

enviei o e-mail sem um subject! :( 

http://tech.groups.yahoo.com/group/domaindrivendesign/message/24011

http://tech.groups.yahoo.com/group/domaindrivendesign/message/24012

http://tech.groups.yahoo.com/group/domaindrivendesign/message/24013

http://tech.groups.yahoo.com/group/domaindrivendesign/message/24014

http://tech.groups.yahoo.com/group/domaindrivendesign/message/24015

At.te.

2013/4/29 João Paulo Rezende da Silva <joaop...@gmail.com>

--
--fx

[Rafael Ponte]

Olá,

A maioria dos casos que utilizei e utilizo tiny types estão relacionados a deixar claro um conceito importante do domínio, como por exemplo NumeroDoCartao, Documento, Intervalo etc.

Daí podemos tirar algumas vantagens interessantes:

• Conceito do domínio explicito
• Evita trabalhar e ficar passando string (ou outro tipo primitivo) entre as camadas
  
• Imutabilidade
• Garante a validação
• Garante a formatação
• Código mais coeso e desacoplado
• Facilita a escrita de testes de unidade

Mais nem tudo são flores, utiliza-los pode trazer algumas dificuldades dependendo do framework MVC e ORM que você utiliza, como:

• Implementar converters e validators em frameworks MVC
• Implementar tipos customizados em frameworks ORM
• Implementar converters em serializadores&deserializadores de XML/JSON
• Abrir mão da imutablidade dependendo do framework MVC ou ORM

E como qualquer outro conceito, o uso de tiny types em excesso pode dificultar mais a vida do que ajudar!

Enfim, só para comentar um pouco da minha experiência com tiny types. E claro, eu aconselho utiliza-los sempre que possível!

2013/4/29 Fabrício Cabral <fabri...@gmail.com>

--
Rafael Ponte
http://www.triadworks.com.br

[Fabrício Cabral]

Olá Rafael!

Seus argumentos e observações são muito bons! No entanto, me permita

a seguinte pergunta: do ponto de vista das suas desvantagens, a maioria

(senão todos) se remetem aos frameworks, correto? Não seria então as

desvantagens da utilização de tiny types limitações destes frameworks?

E portanto, deveria o desenvolvedor procurar um outro framework mais

adequado a este propósito?

At.te.

2013/4/30 Rafael Ponte <rpo...@gmail.com>

--
--fx

[Rafael Ponte]

Olá Fabrício,

Você está certo, as limitações em si estão relacionadas aos frameworks, porém simplesmente mudar nunca é tão fácil assim. Se você trabalha sozinho, talvez mudar de framework seja menos doloroso, mas quando se tem uma equipe com boas skills em determinados frameworks o cenário é outro.

Não conheço muito os frameworks na plataforma .Net, mas em Java posso dizer que 99% deles trabalham em cima do padrão JavaBean (um limitação nesse caso - que te obrigam a ter getter&setters), principalmente os frameworks MVC, logo fica complicado fugir de certos aspectos.

Enfim, o ideal é tentar trabalhar junto com o framework até onde possível e saber abrir mão quando necessário!

2013/4/30 Fabrício Cabral <fabri...@gmail.com>

[edmilson hora]

Oi Fabricio,  as observações do @Rafael são IMHO excelentes, ele colocou todas as vantagens e desvantagens que vejo na utilização.  Quanto a  sua colocação de procurar  outros frameworks em detrimento da utilização de tiny types seria  uma "inversão de valores", simplesmente  não dá para abrir mão das vantagens de um ORM para forçar a utilização de tiny types, quem trabalha e gosta de MVC não vai abrir mão, simplesmente para encher o dominio de tt.

Como coloquei em minha primeira resposta neste tópico: Algumas coisas que são boas práticas podem se tornar problemas se não forem bem dozadas.

[]´s

---

De: Fabrício Cabral <fabri...@gmail.com>
Para: .Net Architects <dotnetar...@googlegroups.com>
Enviadas: Terça-feira, 30 de Abril de 2013 10:59

Assunto: Re: [dotnetarchitects] Utilização de Tiny Types

[Fabrício Cabral]

Edmilson,

também concordo com você a respeito das observações do Rafael. Em

nenhum momento eu disse que não concordava com as mesmas. No

entanto, a pergunta que fiz (veja que foi uma pergunta e não uma afirmação)

era com relação a uma implementação de um framework em específico (que

pode ser um ORM), não afirmei que deveria deixar de usar frameworks por

causa dos tiny types.

Trocando em miúdos: se, por exemplo, trabalhar com tiny types for trabalhoso

com o NHibernate, *talvez* com o EntityFramework seja bem melhor. A minha

pergunta seria mais neste sentido. Se, independente do framework houver

problemas em utilizar tiny types, então realmente, o problema está em saber

dosar corretamente a utilização destes.

Atenciosamente,

2013/4/30 edmilson hora <edmils...@yahoo.com.br>

--
--fx

[Rafael Ponte]

Fabrício,

Em alguns casos pode sim haver problemas com o tiny types, como por exemplo sacrificar a imutabilidade para ajudar o Hibernate ou outro framework MVC.

Mas isso não inviabiliza o uso dos tiny types, porém nem sempre te permite ter o design/implementação ideal. Por exemplo, a especificação JavaBean te obriga a ter getters e setters, prejudicando a imutabilidade do objeto, contudo, não é só porque você é obrigado a ter setters que você tem que utiliza-los :-)

2013/4/30 Fabrício Cabral <fabri...@gmail.com>

[Fabrício Cabral]

Olá Rafael!

Eu sei que a imutabilidade é um ponto importante, principalmente quando estamos

compartilhando objetos, mas me permita a seguinte pergunta: quando falamos de

tiny types, estes necessariamente precisam ser imutáveis? Também não podem

ter métodos setters?

Sei que há diversas vantagens tem ser imutável e não ter métodos setters, mas

acho que o ponto chave da utilização de tiny types é a representação de um

conceito do domínio e a encapsulamento do comportamento (como validação) neste

tipo único. Acredito que a API do sistema fica bem mais representativa e OO.

Também concordo com você no que diz que perder a imutabilidade e ter métodos

setters somos obrigados a modificar aquele objeto. Se a API puder ajudar a policiar

o desenvolvedor, ótimo. Senão, um pouco de controle do próprio desenvolvedor

sobre o que o seu código faz também faz parte do jogo. :)

Atenciosamente,

2013/4/30 Rafael Ponte <rpo...@gmail.com>

--
--fx

[Rafael Ponte]

Oi Fabrício,

Não há qualquer problema de seus tiny types serem mutáveis, mas normalmente eles tendem a ser imutáveis - muitas vezes para manterem a consistência/integridade da informação (validação no construstor, por exemplo).

2013/4/30 Fabrício Cabral <fabri...@gmail.com>

[Juan Lopes]

Se um tiny type é mutável (i.e. tem estado) ele não seria considerado
uma entidade?

2013/4/30 Rafael Ponte <rpo...@gmail.com>:

https://github.com/juanplopes

[Rafael Ponte]

Não. Uma entidade deve ter uma identidade e normalmente um ciclo de vida bem definido no domínio!

2013/4/30 Juan Lopes <m...@juanlopes.net>

[Juan Lopes]

Exatamente. A identidade de um tiny type está intimamente atrelada ao
seu valor. Por isso eles devem ser imutáveis.

Você até pode permitir que eles sejam mutáveis por conveniência, mas
isso vaza a abstração que eles se propõem a representar, não?

2013/4/30 Rafael Ponte <rpo...@gmail.com>:

[Rafael Ponte]

Oi Juan,

2013/4/30 Juan Lopes <m...@juanlopes.net>

Exatamente. A identidade de um tiny type está intimamente atrelada ao
seu valor. Por isso eles devem ser imutáveis.

Isso! O conjunto de dados/atributos de um tiny type é o que realmente define o objeto! Ou seja, um value object!

 

Você até pode permitir que eles sejam mutáveis por conveniência, mas
isso vaza a abstração que eles se propõem a representar, não?

Concordo contigo, por isso disse que eles tendem a ser imutáveis - assim como os value objects. Não me recordo agora de ter feito algum tiny type mutável por necessidade do negócio; mas já escrevi alguns mutáveis para satisfazer frameworks!

[Mauricio Aniche]

Olás,

Concordo em absoluto com a resposta do Rafael.

Considero o uso de tiny types benéfico. Obviamente seguindo as
recomendações dadas acima, como "talvez não faça sentido criar um tiny
type pra firstName", e coisa do tipo (já tive uma péssima experiência
com isso).

Quando bem utilizados, o único problema que vejo são os mesmos que o
Rafael disse: os frameworks ao redor sofrem com eles. Sempre pedem um
getter/setter ou coisa do tipo. No Hibernate, vc sofre com as hqls
"pessoa.nome.valor" (a não ser que escreva algo customizado), no HTML,
teus elementos ganham nomes maiores, e etc.

Ou seja, apesar de discutirmos bastante que infraestrutura não deve
afetar seu modelo OO, se ela não ajuda nada, fica difícil. Ta aí algo
pra alguém trabalhar: fazer o Asp.Net MVC e ecossistema ao redor ser
tiny-type-friendly! :)

PS: O VRaptor (mundo Java) tem um plugin chamado IOGI, que ajuda você
a trabalhar com tipos imutáveis. Então, fica bem bonitinho.

Um abraço,

--
Mauricio Aniche
www.TDDNoMundoReal.com.br
www.aniche.com.br
@mauricioaniche

2013/4/30 Rafael Ponte <rpo...@gmail.com>:

[Fabrício Cabral]

@Mauricio e @Rafael,

estou gostando muito desta discussão sobre tiny types. Inclusive, no meu

trabalho, também discutimos este e assunto e o que foi apontado realmente

é a dificuldade de se trabalhar com alguns frameworks.

No entanto, gostaria de saber se você poderiam dar alguns exemplos mais

específicos de como a utilização de tiny types prejudicou a utilização de

um determinado framework (se possível, exemplo com códigos).

Abraços!

2013/5/3 Mauricio Aniche <maurici...@gmail.com>

--
--fx

[Mauricio Aniche]

Oi Fabricio,

Falando em Javanês aqui, pq foi onde vivi isso de verdade. Imagina a
classe Pessoa -> classe Nome -> property Valor. Nas minhas JSPs
(ASPx), eu precisava fazer ${pessoa.nome.valor}. Nas queries do
(N)Hibernate, a mesma coisa. "where p.nome.valor = :bla", e assim por
diante.

Faça um teste. Crie um tiny type no seu sistema, e faça-o transitar
entre todas as camadas da sua app. Acho que aí descobrirás grande
parte dos desafios!

Um abraço,

--
Mauricio Aniche
www.TDDNoMundoReal.com.br
www.aniche.com.br
@mauricioaniche

2013/5/3 Fabrício Cabral <fabri...@gmail.com>:

[André Körbes]

Oi pessoal,

Esse problema dos tiny types com os ORMs não seriam facilmente resolvidos utilizando repositórios? Dentro do repositório se usaria um objeto "flat" para conversar com o ORM, e no retorno criaria os objetos do domínio com os tiny types.

André

[Fernando Mondo]

Eu não sei no Hibernate, mas no Entity Framework, eu possuo algumas classes que funcionam exatamente como tiny type, e funcionou numa boa.

É só configurar a propriedade como complextype.

[Mauricio Aniche]

Oi André,

Sim, é só encapsular. Mas fica um saco escrever a query maior, né!? :)

Um abraço,
--
Mauricio Aniche
www.TDDNoMundoReal.com.br
www.aniche.com.br
@mauricioaniche

2013/5/14 André Körbes <andre....@gmail.com>: