

<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comments on: Herança não funciona, parte 2</title>
	<atom:link href="http://www.kumpera.net/blog/index.php/2007/12/31/heranca-nao-funciona-parte-2/feed/" rel="self" type="application/rss+xml" />
	<link>http://www.kumpera.net/blog/index.php/2007/12/31/heranca-nao-funciona-parte-2/</link>
	<description>Meus achados sobre tecnologia</description>
	<lastBuildDate>Wed, 16 Jun 2010 18:47:13 +0000</lastBuildDate>
	<generator>http://wordpress.org/?v=2.8.6</generator>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
		<item>
		<title>By: kumpera</title>
		<link>http://www.kumpera.net/blog/index.php/2007/12/31/heranca-nao-funciona-parte-2/comment-page-1/#comment-46985</link>
		<dc:creator>kumpera</dc:creator>
		<pubDate>Thu, 14 Feb 2008 02:54:54 +0000</pubDate>
		<guid isPermaLink="false">http://www.kumpera.net/blog/index.php/2007/12/31/heranca-nao-funciona-parte-2/#comment-46985</guid>
		<description>O problema com arrays é que eles são covariantes ao tipo do elemento, o que torna todo store indecidivel em tempo de compilação.

O funcionamento é seguro pois o runtime verifica o tipo armazenado contra o do elemento do array. Porém isso não exige o sistema de tipos de possuir esse furo.

Converter o sistema de tipos do Java para o calculo OO do Cardelli não é uma tarefa trivial exatamente por conta disso.

Indo além do problema com arrays, Java5 é um sistema de tipos fraco da mesma forma que C++ é por possuir type erasure para generics. Característica essa que limitou em muito aquilo que pode ser feito.

Basta comparar aquilo que estão fazendo com C# 2.0. Tuplas eficiente e fortemente tipadas são um exemplo. Em Java generics é usado p/ Collections e todo o resto é perfumaria.</description>
		<content:encoded><![CDATA[<p>O problema com arrays é que eles são covariantes ao tipo do elemento, o que torna todo store indecidivel em tempo de compilação.</p>
<p>O funcionamento é seguro pois o runtime verifica o tipo armazenado contra o do elemento do array. Porém isso não exige o sistema de tipos de possuir esse furo.</p>
<p>Converter o sistema de tipos do Java para o calculo OO do Cardelli não é uma tarefa trivial exatamente por conta disso.</p>
<p>Indo além do problema com arrays, Java5 é um sistema de tipos fraco da mesma forma que C++ é por possuir type erasure para generics. Característica essa que limitou em muito aquilo que pode ser feito.</p>
<p>Basta comparar aquilo que estão fazendo com C# 2.0. Tuplas eficiente e fortemente tipadas são um exemplo. Em Java generics é usado p/ Collections e todo o resto é perfumaria.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Osvaldo Doederlein</title>
		<link>http://www.kumpera.net/blog/index.php/2007/12/31/heranca-nao-funciona-parte-2/comment-page-1/#comment-46853</link>
		<dc:creator>Osvaldo Doederlein</dc:creator>
		<pubDate>Tue, 12 Feb 2008 21:28:19 +0000</pubDate>
		<guid isPermaLink="false">http://www.kumpera.net/blog/index.php/2007/12/31/heranca-nao-funciona-parte-2/#comment-46853</guid>
		<description>Sobre sua afirmação que os arrays do Java são incomatíveis com type-soundness. Não são. Há uma pilha de papers demonstrando o type-soundness do Java, ex.: do Drossopoulou. Em geral (IIRC - faz vários anos li essas coisas) são papers que trabalham com um subset do Java, pois como vc deve saber, qq linguagem da complexidade do Java é praticamente intratável para uma prova formal completa. (Até mesmo linguagens &quot;politicamente corretas&quot; como o Haskell forçam pesquisadores a criar subsets para provas formais. Jamais vi uma linguagem realista que escape disso.)

Acho que vc está se confundindo com o probema de falhas em runtime. Nenhum código Java &quot;puro&quot;, sem typecasts (e outras manhas como reflection ou JNI), que compile corretamente, terá erros de tipo em runtime. Inclusive com arrays. O que pode ocorrer por exemplo é um ArrayStoreException em métodos como arraycopy(). Mas isso é uma deficiência dessa API, não da linguagem. É uma API antiga (JDK1.0) que recorre a código nativo para copiar arrays de qq tipo, com otimizações como usar um memcpy() quando possível ex.: arrays de tipos primitivos. Modernamente esse tipo de otimização é besteira, pois o overhead de JNI é relativamente alto e os JITs podem gerar código superior com intrinsics. Por isso temos os novos métodos Arrays.copyOf(), que substituem arraycopy() com mais type-safety (e outras vantagens). Sendo que o copyOf(T[],int) é type-safe para arrays de reference types (desde que o código-cliente seja type-safe segundo os padrões de generics/Java5). Ainda há buracos, logicamente, como a má integração entre arrays e generics, que nos obriga a eventuais @SuppressWarnings para calar a boca do compilador com generics (e implica em perda de garantias type-safe), mas isso não torna a linguagem unsound, basta evitar a mistura de arrays com generics (o que na teoria é fácil, claro que na prática é mais difícil devido à necessidade de usar um mix de APIs que exigem ora arrays, ora collections genéricas).</description>
		<content:encoded><![CDATA[<p>Sobre sua afirmação que os arrays do Java são incomatíveis com type-soundness. Não são. Há uma pilha de papers demonstrando o type-soundness do Java, ex.: do Drossopoulou. Em geral (IIRC &#8211; faz vários anos li essas coisas) são papers que trabalham com um subset do Java, pois como vc deve saber, qq linguagem da complexidade do Java é praticamente intratável para uma prova formal completa. (Até mesmo linguagens &#8220;politicamente corretas&#8221; como o Haskell forçam pesquisadores a criar subsets para provas formais. Jamais vi uma linguagem realista que escape disso.)</p>
<p>Acho que vc está se confundindo com o probema de falhas em runtime. Nenhum código Java &#8220;puro&#8221;, sem typecasts (e outras manhas como reflection ou JNI), que compile corretamente, terá erros de tipo em runtime. Inclusive com arrays. O que pode ocorrer por exemplo é um ArrayStoreException em métodos como arraycopy(). Mas isso é uma deficiência dessa API, não da linguagem. É uma API antiga (JDK1.0) que recorre a código nativo para copiar arrays de qq tipo, com otimizações como usar um memcpy() quando possível ex.: arrays de tipos primitivos. Modernamente esse tipo de otimização é besteira, pois o overhead de JNI é relativamente alto e os JITs podem gerar código superior com intrinsics. Por isso temos os novos métodos Arrays.copyOf(), que substituem arraycopy() com mais type-safety (e outras vantagens). Sendo que o copyOf(T[],int) é type-safe para arrays de reference types (desde que o código-cliente seja type-safe segundo os padrões de generics/Java5). Ainda há buracos, logicamente, como a má integração entre arrays e generics, que nos obriga a eventuais @SuppressWarnings para calar a boca do compilador com generics (e implica em perda de garantias type-safe), mas isso não torna a linguagem unsound, basta evitar a mistura de arrays com generics (o que na teoria é fácil, claro que na prática é mais difícil devido à necessidade de usar um mix de APIs que exigem ora arrays, ora collections genéricas).</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Proteu Alcebidiano</title>
		<link>http://www.kumpera.net/blog/index.php/2007/12/31/heranca-nao-funciona-parte-2/comment-page-1/#comment-43355</link>
		<dc:creator>Proteu Alcebidiano</dc:creator>
		<pubDate>Wed, 02 Jan 2008 00:38:54 +0000</pubDate>
		<guid isPermaLink="false">http://www.kumpera.net/blog/index.php/2007/12/31/heranca-nao-funciona-parte-2/#comment-43355</guid>
		<description>Por que é que eu tenho impressão que modelos desenhados sob herança traz para suas sub-classes comportamentos contaminadores?

Passagem de mensagem realmente, parece ser um efeito descontaminador. E vendo herança ser implementada, parece com a idéia de introduzir a construção de produtos não-software para produtos de software.

T+</description>
		<content:encoded><![CDATA[<p>Por que é que eu tenho impressão que modelos desenhados sob herança traz para suas sub-classes comportamentos contaminadores?</p>
<p>Passagem de mensagem realmente, parece ser um efeito descontaminador. E vendo herança ser implementada, parece com a idéia de introduzir a construção de produtos não-software para produtos de software.</p>
<p>T+</p>
]]></content:encoded>
	</item>
</channel>
</rss>
