Con un tipo de dato especifico?. Si así es, porque a diferencia de las colecciones no genéricas en las que se pueden agregar cualquier tipo de elementos y todos son convertidos a System.Object, en este tipo de colecciones solo es posible almacenar elementos de un tipo de dato específico.

Cuando comencé a leer sobre esta nueva característica ofrecida por el Framework 2.0, me preguntaba si el nombre verdaderamente correspondía a la definición de estas colecciones, ya que no entendía el porque llamarlas genéricas si solo era posible almacenar datos del mismo tipo. Por el contrario, parecían ser más genéricas las otras colecciones (las del namespace System.Collections) ya que me permitían almacenar cualquier tipo de dato.

Pero finalmente y después de leer varios artículos y códigos de ejemplo, comprendí el porque del nombre generics y espero poder transmitirlo en este post.

Definitivamente, una colección genérica solo puede almacenar datos de un tipo, pero dicho tipo de dato es definido por nosotros mismos al momento de declararla e instanciarla. Es decir, no hay una clase para diferenciar las colecciones que operan con enteros de las que operan con cadenas de texto ni de las que operan objetos de tipo Empleado (por ejemplo). Absolutamente todas están definidas en la misma clase, lo único que las diferencia es la manera en que se instancia y se declara cada una de ellas. Ese es el secreto del ser genérica. Para entender mejor el concepto de la colección genérica, veamos el siguiente ejemplo:

En el ejemplo se observa la implementación de la colección genérica List, que es la versión genérica del ArrayList tratado en un post anterior. Se puede deducir que la primera colección permitirá almacenar únicamente datos de tipo int, que la segunda almacenara solo cadenas de texto y que la última almacenara objetos de tipo TablaDatos, el cual es un tipo definido en una clase aparte. En las definición de las tres colecciones se utilizo la clase List, es decir, que hay una clase “genérica” capaz de trabajar con el tipo de dato que indiquemos al momento de inicializarla. (Realmente no es cualquier tipo de dato, sino los tipos de datos soportados por la clase).

La diferencia para inicializar una clase genérica de una clase no genérica, es que en la primera se debe utilizar una parámetro adicional después del nombre de la clase y entre los caracteres < y >. Este parámetro debe ser un tipo de datos, que indica el tipo de datos con el que la colección deberá operar.

Así como esta la colecciones List<T>, que es la versión genérica del ArrayList, también existen las colecciones genéricas Stack<T>, Queue<T> y Dictionary<T>, entre otras que son las versiones genéricas de las clases Snack, Queue y HashTable respectivamente.

Un ejemplo de la clase genérica de Stack seria:

Se puede ver como se define una pila en la que únicamente se pueden almacenar datos de tipo entero, lo cual me permite obtener datos de la colección y tratarlos directamente como enteros sin necesidad de hacer algún tipo de cast, lo cual no seria posible con las colecciones no genéricas ya que el elemento es almacenado como un System.Object.

El hecho de que las colecciones genéricas operen con un tipo de dato definido en el momento de su declaración, las hace mucho más eficientes, ya que evita tener que realizar boxing, unboxing y casting de objetos. Adicionalmente los desarrolladores, obtienen un mayor grado de control sobre la información almacenada en la colección ya que en caso de intentar ingresar un objeto de un tipo de dato diferente al establecido en la inicialización de la colección, se arroja una excepción.

Además de esta ventaja que nos brindan las colecciones genéricas, tenemos la posibilidad de crear nuestras propias clases y métodos genérico cuyo comportamiento estará ligado al tipo de dato que se utilice al utilizarlo tal y como sucede con las colecciones. Para lograr esto debemos hacer uso de los “type parameters”, los cuales permiten establecer un parámetro cuyo tipo se desconocerá hasta que se indique en la declaración.

Para comprender mejor el funcionamiento de los “type parameters” que nos permiten crear clases genéricas, he desarrollado una aplicación de muestra que consiste en una clase impresora “genérica”, que es capaz de almacenar en una cola, objetos de un tipo específico (del tipo que se define al momento de definir un objeto de esta clase). Adicionalmente expone un método “imprimir” que se encarga de imprimir en pantalla cada uno de los valores contenidos en la cola. A continuación presento los fragmentos principales del código.

En esta primera imagen, se observa como se ha definido una clase Impresora genérica. Note que en este caso se utiliza la letra T para representar el “type parameter”, sin embargo es posible utilizar cualquier letra o palabra. Mediante este parámetro estamos indicando que al momento de definir e instanciar un objeto de tipo Impresora, se debe pasar como parámetro entre < y > el tipo de datos con el que se desea trabajar.

En el constructor de esta clase, se puede ver como la Queue genérica que tiene la clase Impresora como atributo toma su mismo tipo de dato, es decir, si al crear la clase Impresora indicamos el tipo de dato int, la Queue también tomara el tipo de dato int.

En esta segunda imagen se observa una propiedad que retorna una cola genérica, pero el type parameter para indicar que es una Queue genérica es el mismo utilizado en nuestra clase Impresora, lo cual indica que retornara una Queue del tipo de dato utilizado en la clase.

Finalmente se observa el método imprimir, cuyo objetivo es indicar el tipo de Queue que se esta imprimiendo y además mostrar cada uno de los elementos que contiene.

Como paso final, para comprobar el funcionamiento de la clase Impresora, se crea un objeto de tipo Impresora de enteros, así:

Otra de las ventajas que nos brinda la utilización de Generics, es que los “type parameters” se traducen en tiempo de compilación, lo cual implica que es posible darnos cuenta en el momento que desarrollamos nuestra aplicación, el tipo de datos con el que se esta trabajando en cada instancia de la clase Impresora, como se ve a continuación:

Finalmente, se observa el resultado de la ejecución de la aplicación en consola:

En conclusión, debemos utilizar las colecciones genéricas tanto como sea posible en lugar de utilizar las colecciones no genéricas, ya que las primeras incrementan el rendimiento de la aplicación ya que evita un sin numero de casting, boxing y unboxing lo que permite realizar un mejor manejo de la memoria y procesamiento.

Además podemos crear propias clases y/o métodos genéricos para aumentar la flexibilidad y la posibilidad de reutilizar nuestro código.

Nesse pequeno e simples projeto aprendi a trabalhar com os conteiners do GTK, não é algo trivial pra quem é acostumado a desenhar interfaces no Delphi, não quis utilizar o Glade pra desenhar pois quero aprender a codificar o mesmo. Trabalhar com esses conteineres no início foi complicado por conta do alinhamento automático dos controles que estão dentro deles, o que seria equivalente ao alClient no Align dos componentes do Delphi, me senti tentado a utilizar o conteiner Fixed mas ao ler a documentação do Gtk# no site do projeto eu desisti :).

Aprendí também uma forma de trabalhar com o TreeView de uma forma meio que automática, mas serviu pra mostrar os dados obtidos do WebService.

Disponibilizei os fontes do projeto no Google Code quem quiser baixar, alterar ou sugerir alterações, fique à vontade. link: dotCotaAcoes no GoogleCode

Modo de usar: abra o arquivo "acoes.txt" e digite o nome dos papéis que deseja visualizar separados por uma linha, coloque esse arquivo no mesmo diretório do executável. Abra o programa e clique em Atualizar :). só pra lembrar, pra obter o índice da Bovespa, inclua o papel IBOV no arquivo.

Expectativas: Não tenho nenhuma expectativa quanto a esse projeto, a não ser utilizá-lo para testar novas descobertas como por exemplo fazer um gráfico que mostraria a variação do valor das ações durante o dia usando Cairo, fazer com que ele atualize os dados automaticamente em um período de tempo, permitir a edição dos papéis direto na TreeView e por aí vai.

You can find the code for the function here. For example, within a static class called Enumerable2, you can call it as such:

var combinedList = Enumerable2.CombineOrdered(listA, listB, keySelector);

Note: The given implementation needs to take lists sorted in an ascending order and returns a combined list in the same order. To sort descending, change the <= sign to a >= sign in the code and insure that you pass lists sorted in a descending order.

I was looking at some of those fallen trees today, both near my house and near where I work. How is it that, say, a big pine tree near my office snapped and fell to the ground, while other pine trees just a few feet away - trees of the same circumference and height - remain standing?

Plenty of factors must come into play - root strength, the condition of the surrounding soil, the health of the tree, etc. Whatever the reasons, it seems to me that it all comes down to flexibility. The vast majority of trees were flexible enough to not break under the strain. Some, however, just couldn't bend enough to last.

We're trying to bend as the financial winds (of our own making) lash at us. Tonight there's going to be a windstorm in our very own house: it's bill night. Will we be able to make this month's $1700 payment to our debt reduction program? What will we do if we can't make the payment? We don't know the answer to either question.

We slashed our discretionary spending, we got second jobs, we buy generic foods, we have no plans to travel (even for an upcoming family wedding), and we're praying (literally) that the cars and appliances all keep working. The last remaining luxury is cable TV. Internet remains a must because Buck often receives calls to work from home on evenings and weekends. Even if there was time for him to drive to work (and there isn't - these are urgent calls), the price of fuel means that it's cheaper to pay for internet and log in from home.

We're trying to flexible. Let's hope that we can bend enough to weather this storm, because it's going to last for years.

To my fellow frugalites - specifically to those trying to recover from overwhelming debt - I wish you good luck and much flexibility during your own personal storm.

	சிக்கலில் ரான்பேக்ஸி நிறுவனம்

இந்திய மருந்து தயாரிப்பு பெருநிறுவனமான, ரான்பாக்ஸி, அது தயாரிக்கும் 30க்கும் மேற்பட்ட வணிகப்பெயர்கள் அல்லாமல், ரசாயனப் பெயர்களை வைத்து மட்டுமே அறியப்படும் மருந்துகள் அமெரிக்காவுக்குள் இறக்குமதி செய்யப்பட, அமெரிக்க அரசு விதித்திருக்கும் தடை குறித்து தான் ஏமாற்றமடைந்திருப்பதாக கூறியுள்ளது.

அமெரிக்க உணவு மற்றும் மருந்துத் துறை, எப்.டி.ஏ, இந்த நிறுவனத்தின் இரண்டு தொழிற்கூடங்களில் தயாரிப்பு தரம் குறித்த பிரச்சினைகளை தான் கண்டுபிடித்திருப்பதாகக் கூறியது.

ரான்பேக்ஸியோ, எப்.டி.ஏ கடந்து இரண்டு ஆண்டுகளாக எழுப்பிய கவலைகள் ஒவ்வொன்றைக்குறித்தும், தான் நடவடிக்கை எடுத்திருப்பதாகவும், இந்த விஷயத்தில் முன்னேற்றம் ஏற்பட்டுவந்ததாகவே தான் கருதியதாகவும் கூறியுள்ளது.

ஆயினும், தனது மருந்துகளின் பாதுகாப்பு மற்றும் குணப்படுத்தும் திறன் குறித்து எந்த வித கேள்விகளும் இல்லை என்று எப்.டி.ஏ முடிவிற்கு வந்திருப்பது பற்றி தான் திருப்தியடைந்திருப்பதாகவும் ரான்பேக்ஸி கூறியது.

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

import sun.reflect.generics.reflectiveObjects.NotImplementedException;
import sun.reflect.generics.tree.ReturnType;

public class Foreach {
  @SuppressWarnings("unchecked")
  public static <T> T foreach(T... elements) {
    ApplyOnArrray<T> handler = new ApplyOnArrray<T>(elements);
    return (T) Proxy.newProxyInstance(elements[0].getClass().getClassLoader(),
      new Class[] { elements[0].getClass().getInterfaces()[0] },
      handler);
  }

  public static <ReturnType> List<ReturnType> get(ReturnType returnValue) {
    Collector collector = (Collector) Proxy.getInvocationHandler(returnValue);
    return collector.getReturnValues();
  }

  public static void main(String[] args) {
    IFoo f1 = new Foo();
    IFoo f2 = new Foo();
    IFoo f3 = new Foo();
    IFoo f4 = new Foo();

    List<IString> list = get(foreach(f1, f2, f3, f4).sayFoo());
    System.out.println(list);
  }
}

class Collector implements InvocationHandler {
  private final List returnValues;

  public Collector(List returnValues) {
    this.returnValues = returnValues;
  }

  public List getReturnValues() {
    return returnValues;
  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // TODO get(foreach(elements).method(args))
    throw new NotImplementedException();
  }
}

interface IString { String toString(); }

  class StringImpl implements IString {
    private String s;
    public StringImpl(String s) { this.s = s; }
    public String toString() { return s; }
  }

interface IFoo { IString sayFoo(); };

class Foo implements IFoo {
  public IString sayFoo() {
    System.out.println("foo");
    return new StringImpl("foo");
  }
};

class ApplyOnArrray<T> implements InvocationHandler {
  private final T[] elements;

  public ApplyOnArrray(T... elements) { this.elements = elements; }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Method targetMethod = elements[0].getClass().getMethod(method.getName(), method.getParameterTypes());

    List returnValues = new ArrayList();
    for (T element : elements) returnValues.add(targetMethod.invoke(element, args));

    // return a proxy for the result
    return (T) Proxy.newProxyInstance(elements[0].getClass().getClassLoader(),
    new Class[] { targetMethod.getReturnType() },
    new Collector(returnValues));
  }

}

I had this idea in a dream (too much work) and fortunately I could still remember it in the morning. Who knows, I might have dreamt also a solution that works with classes.


We used 5 oz. of kernels (about 2/3 cup) to fill the air popper's cup. That was from a 23 oz. bag of generic popcorn kernels that cost $1.50. The portion that we used cost 23 cents.

We added 1/2 stick of melted butter. That was from a 1 lb. package of generic butter that cost $3.12. The portion that we used cost 39 cents.

The yield was 18 rounded cups of popcorn, and it cost us 62 cents. You absolutely cannot beat that price for a tasty, crunchy snack that was more than enough for 2 people.

Price comparison: At Buck's office, a bag of microwave popcorn from the vending machine costs $1.50. That's almost 3 times as much as our snack last night, for far less popcorn.

Give or take a penny or two this is the going rate for generic prescriptions at some of our local pharmacies.

Maybe I am the last one to know this...I need to get out more. I thought I would pass this information along for any of my fellow Monsonites (and beyond) who may not have this information about our local area retail pharmacies. Stop & Shop has a generic prescription drug program is called "The Real Deal". The store locater is at the top of the page. Wal-Mart's generic drug program costs a penny more for the same supply. The pharmacy locater is on the left of the page. Kmart also has a generic medication program. Their list of medications is here. Target pharmacies are also included in the list of somewhat local major retailers who have a generic medication program.

I did not find a similar program at BigY, Rite Aid, CVS, or Walgreens. I may have missed the information on their websites but I did look pretty thoroughly.

Além de serem fundamentais para a programação genérica, o principal paradigma de desenvolvimento da STL (Standard Template Library) , os templates de C++ são instrumentos indispensáveis na arte da meta-programação. Em poucas palavras, a meta-programação consiste de código-fonte que é manipulado pelo compilador para gerar mais código-fonte. Ou seja, o compilador gerando código-fonte para a gente!

Um exemplo clássico de meta-programação é o cálculo do fatorial de uma constante (em se tratando de templates, é necessário que a informação esteja disponível estaticamente, por isso digo uma constante) em tempo de compilação [Wikipedia]. Mas há inúmeras situações interessantes onde a meta-programação é empregada. Muitas delas podem ser encontradas nas bibliotecas Boost. Considere, por exemplo, o seguinte código-fonte para converter uma constante entre a representação binária e decimal [D. Abrahams/A. Gurtovoy].

[sourcecode language='cpp']
#include

template
struct binary
{
static unsigned const value =
binary::value * 2 + N%10;
};

template <>
struct binary<0> //Specialization.
{
static unsigned const value = 0;
};

int main()
{
std::cout << "1001 -> " << binary<1001>::value << std::endl;
std::cout << "101001 -> " << binary<101001>::value << std::endl;
return 0;
}
[/sourcecode]

Diferentemente do que acontece em C++, os generics de Java não definem tipos de verdade e são úteis, basicamente, para detecção de erros durante a compilação. Eles são implementados com uma técnica chamada Type Erasure , a qual consiste da remoção dos parâmetros genéricos durante a geração do bytecode. Logo, não há informações disponíveis sobre eles em tempo de execução. Considere, por exemplo, a classe Teste abaixo e seu respectivo bytecode. Note que do ponto de vista de execução ambos os membros a e b são tipo Object.

[sourcecode language='java']
public class Teste
{
public T a;
public Object b;
}
[/sourcecode]

[caption id="attachment_10" align="alignnone" width="450" caption="Bytecode"][/caption]

Em Java é possível especificar restrições sobre os parâmetros genéricos através do uso de bounded types e wildcards. No padrão C++ atual não há um recurso equivalente. No entanto, qualquer quebra contratual em termos da interface esperada por um template resultará em um erro de compilação da mesma forma. Além disso, uma grande novidade esperada para o C++0x (provavelmente, C++09) são os conceitos (concepts), os quais contribuirão significativamente para o formalismo semântico e amigabilidade na utilização de templates.

They should be called specific types, or parametrised collections!

I think the feature is called "Java generics" because when you use a collection, say List<E>, that List contains elements of parameterised type <E>, a "generic type".  But the element type in the plain old-fashioned non-parametrised collection List is also generic!  In fact the non-parametrised List is more generic than the "generic" version (it can contain elements of any sub-class of Object)!  The distinction is that the elements in a List<String> are all of one specific type (String), whereas the elements in a List can be of any general type, and can even be of different types in the same List collection (leading to problems that "Java generics" was invented to address).

<sarcasm>Gosh, what an epiphany.</sarcasm>

If you're a Java guru this is nothing new, of course.  But that took me ages to grasp.  I think I wasn't helped by the terminology.  In fact whenever I'm reading Java literature, it helps if I swap "generic" for "specific".  This makes much more sense to me.  Actually I already do word substitutions for much of the Java canon.  For instance:

• "class Foo is instantiated"
  Translation: "a Foo object is created"
• "invoke method X of class Y"
  Translation: "send message X to a Y object",
  or even "send class Y the X message"

Probably the Java literature is strictly more "correct" or explicit, but it'd be much more clear and concise if people used the older OOP words for things...

That's because doctors tend to continue patients on the more expensive brand name drug in the sample, rather than switch them over to a cheaper generic later on, researchers say.

"When physicians had access to brand name drug samples, they were much more likely to give uninsured patients prescriptions for that drug," said lead author Dr. David P. Miller, an internal medicine physician at the Wake Forest University Baptist Medical Center in Winston-Salem, N.C. "But when giving out drug samples is not an option, the same physicians are almost three times more likely to prescribe generic drugs to the uninsured. And generic drugs are often much cheaper than their brand-name counterparts."

"So, given that for many conditions there are very effective generic options, I think any patient who wants to save money on their medications is better off asking for an effective generic prescription rather than asking their physician for a free drug sample," Miller advised. "Because while the sample might be free in the short term, they might end up paying a lot more money in the long term."

The research team outlined its conclusions in the September issue of the Southern Medical Journal.

The current finding follows on the heels of a University of Chicago Medical Center study released this past spring that indicated that patients who receive free drug samples go on to incur significantly higher out-of-pocket expenses when filling their prescriptions than those who never get such freebies. In that instance, three-quarters of the patients had private insurance coverage.

In the new study, the researchers spent 18 months tracking prescriptions written for uninsured and/or Medicaid patients cared for by more than 70 physicians. All of the doctors worked at a large university-affiliated internal medicine practice.

Midway through the study period, the institution's so-called "drug sample closet" was closed due to a physical relocation of the facility -- meaning that for the next nine months, doctors were unable to distribute the free brand name drug samples that had been previously available.

Using a pharmacy database, Miller and his colleagues characterized the nearly 2,000 chronic prescriptions for blood pressure, diabetes, ulcers, and gastrointestinal problems that were issued during the first nine months, while drug samples were still available. They then compared those patterns with prescriptions issued by the same doctors over the next nine months.

According to the researchers, the overall percentage of money-saving generic drugs prescribed to uninsured patients more than doubled once samples became unavailable -- from 12 percent while supplies lasted to 30 percent when the flow of free samples dried up.

This dynamic, however, did not appear to be in play for Medicaid patients, who were typically prescribed generic drugs regardless of sample availability. According to the researchers, that might stem from the fact that doctors know that Medicaid patients typically incur the same minimal out-of-pocket expense for generic or brand name drugs, so there was less incentive to try and save the patient money with a free sample.

But for the uninsured, it's a different story. "Physicians assume they are helping out by giving a free sample to patients who have no insurance," Miller said. "But there are, nevertheless, unintended consequences to that action that physicians need to weigh when doing so."

A representative of the pharmaceutical industry took issue with the findings.

In a statement, Ken Johnson, senior vice president of the Pharmaceutical Research and Manufacturers of America (PhRMA), said the study, "overlooks the fact that Americas physicians prescribe medicines based on a wide range of factors, not simply receipt of samples." He added that, "free samples provide physicians valuable first-hand experience with new medicines. In many cases, samples help patients begin treatment sooner by quickly discovering the medicines that are best for them. And they can be an important option for patients in need of help."

But Reginald Frye, an associate professor in the department of pharmacy practice at the University of Florida College of Pharmacy in Gainesville, agreed that while free samples can benefit patients, they must be used carefully.

"For example, sometimes you have a question as to if a drug is going to work well for your patient, so you give him or her the free sample as a trial," he said. "And there's, of course, the initial intent to spare some expense. But I'm not too surprised that it would influence a patient's choice later on and perhaps not to that patient's benefit."

"So it's important," he added, "for a physician to discuss with patients all the options, such as the availability of generics at a cheaper cost. And for their part, patients should ask their pharmacists as well if a brand name drug is available as a generic."

More information

There's more on generic drugs at the U.S. Food and Drug Administration.

SOURCES: David P. Miller, M.D., internal medicine physician, Wake Forest University Baptist Medical Center, Winston-Salem, N.C.; Reginald Frye, Ph.D., Pharm.D., associate professor, department of pharmacy practice, University of Florida College of Pharmacy, Gainesville; Sept. 5, 2008, news release, Pharmaceutical Research and Manufacturers of America; September 2008, Southern Medical Journal

By Alan Mozes
HealthDay Reporter

Last Updated: Sept. 05, 2008

Copyright © 2008 ScoutNews, LLC. All rights reserved.

Related Links:

Moderar un foro de programación no es fácil, puedo decirlo por experiencia, pero tampoco es agotador. Los programadores somos gente difícil y poco tolerante hacia los "users", o sea, esa gente que usa la tecnología sin molestarse lo suficiente en comprenderla o por lo menos respetar su complejidad (y dejar a los que se dedican a ello preocuparse por los problemas mayores).

En fin, aquí va un pequeño relato de lo que acontece en los oscuros pasillos de internet, donde se trama la conquista del ciberespacio, un bit a la vez.

Dejarse llevar por la corriente lejos del tema de discusión es algo usual. Así es como alguien preguntando por el protocolo bittorrent puede llevar discusiones filosóficas con quotes como el siguiente:

De la misma manera que si un arbol se cae en el bosque y nadie lo escucha no hace ruido si uno comete un delito y nadie lo ve tampoco es delito, ¿no?

Como moderador uno tiene que tratar de contener el tema de discusión en su cauce, aunque muchas veces resulta más interesante ver hasta donde pueda llegar el offtopic. A veces se me va la mano.

Si un árbol cae en el bosque y nadie lo escucha, es noticia en el
diario "El argentino" y la culpa la tienen los gorilas golpistas por
deforestar. Después hablarían de como la redistribución de la riqueza
hubiera salvado al árbol y porque el nacional socialismo es la mejor
forma de gobierno. El diario "Crítica" hubiera titulado: hicieron caer
a un árbol y todos se hicieron los sordos. Crónica hubiera dedicado una
de sus clásicas pantallas rojas y hubiera mostrado material exclusivo
del árbol cayéndose, sin sonido, obviamente, porque nadie lo escucho
caer. Y Tinelli hubiera hecho doble programa del baile del caño, no en
homenaje al árbol caído sino porque tiene que levantar el rating.

Hagansé un favor y dejen al pobre árbol en paz.

Entre otras cosas interesantes que merecen ser comentadas:

Discutiendo cual sería el algoritmo para encontrar el mejor equipo para El Gran DT

Discutiendo sobre los pormenores de mezclar legacy code con generics code en Java5

Una interesante discusión sobre optimizaciones

Preguntándose quien habra sido el infeliz que penso que la notación octal era una buena idea

Tirando ideas de sobre como evitar que un reproductor en un sitio web deje de reproducir al navegar el sitio

Discutiendo sobre los prejuicios hacia la programación orientada a objetos en el mercado de desarrollo de videojuegos

Pero lo mas importante es construir una buena y saludable comunidad, ayudando con lo que uno puede, tratando de enseñar tanto lo que uno sabe sobre programación como lo que uno aprendió sobre como tratarse con los demás en un ambiente donde el sarcasmo es inevitable. Un colega agradecido es la mejor recompensa, aunque a veces se pasen en su entusiasmo

Muchisimas gracias hombre gris ya van varias veces que me salvas los huevos, cuando tengas orientaciones homosexuales llamame :P

I think I'll pass on that....

Y es impagable cuando dos colegas logran resolver sus diferencias olvidando que la web es un espacio plagado de trolls que creen que el "anonimato" les da la libertad para comportarse como completos idiotas. Me sentiría orgulloso pero no es mi logro.

Eu não estava lá quando a Peligro no Milo inaugurou a casa. Eu acompanhava tudo à distância, em Londrina, informado por amigos como Ronaldo, Eugênio e Matias. Mas sempre que eu visitava São Paulo dava um jeito de dar um pulo no "Milo de quinta", forma corriqueira de se referir à festa. Foi lá que em julho, um mês antes de me mudar pra SP, eu assisti pela primeira vez um show da Lulina.

A questão que faz com que o fim da Peligro no Milo seja o "fim de uma era" é o senso de comunidade que se formou em torno da festa. Vinda das anárquicas noites na Generics (que, reza a lenda, teve uma festa de despedida de rachar o assoalho literalmente), a Peligro no Milo girava em torno de Gui Barrella (dono do selo/distro que batiza a festa) e Dago Donato, metade do Centro Cultural Batidão que ficou sozinho quando Eduardo Ramos começou a rodar o mundo no cargo de produtor/ empresário de bandas indies (mas que nunca deixou de voltar ao Milo quando no Brasil).

Esse espírito de comunidade é quase invisível, é intangível e espontâneo. Quando eu saí de Londrina, me senti um estrangeiro no meu próprio país. Se lá eu conseguia ir ao Valentino ou ao Potiguá sozinho e sem nenhum planejamento e ainda assim encontrar pessoas, fazer presepadas, me divetir e beber, em São Paulo eu só me sentia deslocado, quase inconveniente.

Mas o Milo (que a partir de agora aparece neste texto como sinônimo da festa da Peligro) tornou-se a minha segunda casa, antes mesmo de eu me mudar para Higienópolis, a duas quadras do bar. Foi no Milo que fiz e reencontrei grandes amigos, e lá, por muito tempo, era o único lugar para o qual eu iria sem nenhuma companhia.

Muitas vezes eu não estive nos melhores momentos do Milo, muito por não morar aqui antes de 2006. Eu não vi a Kátia (que eu conheci numa reunião pré-Milo na casa do Ronaldo e da Gê) discotecar o samba-enredo da Viradouro de 96. Eu não estava lá quando o Palugan gravou a apresentação do CSS. Eu não estava lá no show do Moving Stairs, banda que tinha dois terços da Folk This Town. Eu não vi o Diplo discotecar lá sob o pseudônimo de Wesley Pentz (na verdade o nome "civil"dele).

Mas eu vi muita coisa boa no Milo. Vi o Grenade pela primeira vez fora de Londrina, numa festa lotada. Vi o James Orr Complex, mal falando português, tocando para uma platéia atônita e plantando na minha cabeça a semente da Folk This Town. Vi o Macaco Bong num dos shows mais intensos EVER, tocando no melhor palco para artistas pedreiros - o chão. Eu enfrentei fila e VI o show da Mallu Magalhães, que a maioria só ouviu. Vi o Elma tocando Portishead, Telepatas tocando Wilco, Lulina tocando Velvet. Vi o Ronex e seu Royale e ajudei o Palugan e a Susan na "iluminação" - e ainda carreguei o Ronex no colo no fim do show. Discotequei duas vezes, uma delas no meu aniversário. Ouvi o Dago discotecar "Tiny Dancer", vi ele fazer um set indie/soul/rap de não deixar ninguém ir embora, passei horas na "cabine do DJ" só sacando o som que o Barba ia colocar. Ouvi o Eugênio e o Breno num duelo grunge. Fechei o bar, e também saí cedo demais. Perdi banda para ficar conversando no quintal e já dancei até as pernas ficarem doendo no dia seguinte. Tive uma revelação espiritual patrocinada pelo Massari. Vi o Plato Dvorak e vi o Walverdes tocando para quase ninguém. Aliás, eu estava lá no PIOR dia do Milo, apresentação de um tal de Bernhard Ghal. Não perguntem muito, mas foi horrível mesmo.

Essa lista não é só minha - todos que consideravam-se parte da comunidade Peligro devem ter a sua. E cada uma dessas listas é a verdadeira história do Milo, pelo menos o Milo que me interessava de verdade.

E claro que a festa não morre, nem morre o bar. O Milo vai achar algo para as suas quintas, e a Peligro vai criar sua própria casa, a Neu ("novo" em alemão e nome de uma das bands mais influentes do krautrock).

E vai ser massa, porque o que vai prevalecer, muito além da geografia, é esse senso de comunidade - uma das coisas mais importantes da e para a boa música. É só pensar na Rough Trade do começo, é só pensar no Our Band Could Be Your Life. E o melhor e mais importante dessa turma é que a comunidade é receptiva, e recebe o novo, seja um indivíduo ou um novo gênero musical, de peito e braços abertos.

Por isso que eu não estou triste. Termina uma fase na vida de muita gente, uma nova fase se delineia no horizonte. Quando eu colocar minha camiseta do Sonic Youth, minha camisa de flanela xadrez e o meu all-star de flames, quando eu subir a Angélica e chegar lá, cumprimentar o segurança, ir comprar minha Skol de meio litro, eu não estarei triste. Eu vou estar feliz, celebrando ao lado dos meus amigos. Porque é o fim do Milo como o conhecemos. E eu me sinto bem.

His solution uses a trait for partially applying a function to some of its arguments. An abstract type exposed by the trait represents the resulting function which takes the remaining arguments.

[sourcecode language='java']
object Partial {
// Partial application of f2 to x
trait papply[f2[_, _], x] {
type f1[y] = f2[x, y]
}

// apply f to x
type apply[f[_], x] = f[x]

trait X
trait Y
trait F[A1, A2]

// Test whether applying the partial application of
// F to X to Y equals in the type F[X, Y]
case class Equals[A >: B <: B, B]
Equals[apply[papply[F, X]#f1, Y], F[X, Y]]
}
[/sourcecode]

Having this solved we can define a type which encodes multiplication on the Church Numerals.

[sourcecode language='java']
trait curry[n[_[_], _], s[_]] {
type f[z] = n[s, z]
}

// Multiplication for this encoding
type mult[m[_[_], _], n[_[_], _], s[_], z] = m[curry[n, s]#f, z]
[/sourcecode]

A full working example is available from my code page. Note, the code takes forever (i.e. some minutes) to compile. Matt also noted an issue with squares. With my version of the compiler (Ecipse plugin 2.7.2.r15874-b20080821120313) the issue does not show up however.

Have you ever tried generic foods? It's amazing that we had never tried them. In fact, we never even thought about them. It was automatic to buy Kellogg's, Smuckers, Tostitos, etc. But times they are a-changin' and we decided to try some generics at Walmart.

Our only negative experiences have been with generic cheeses - specifically Great Value colby and Great Value shredded cheddar. Both were flavorless. We threw them away long before finishing them. We want to reduce our costs, but in doing so we consider value. Flavorless cheese costs less but has no value to us. So we're sticking with Kraft and Land-O-Lakes. Otherwise, we've been happy with all generics that we've tried - when it comes to both quality and price.

Which generic products do we like so far?

Great Value Sour Cream. It's just like the name brands. No difference in appearance, taste or texture.

Great Value Strawberry Preserves. I was raised on Smuckers and never bought anything else. GV has a different consistency, but the color and flavor are good. Once it's smooshed between bread and peanut butter, or spread onto toast, any difference in consistency is no longer noticeable.

Sam's Choice Salsa. It'd be difficult to screw up salsa, so we had high hopes for this. GV did it right. Good texture, color and flavor. Not too chunky or too runny. We'll definitely be buying this again.

Now for the true test... generic cereal!

Malt-O-Meal "Frosted Mini Spooners". These are the generic equivalent of Frosted Mini Wheats. Now, I'm a cereal fanatic. I adore it. It's the perfect meal or snack, any time of day. If I could live on cereal, I would. And one of my favorite cereals is Frosted Mini Wheats. I approached Frosted Mini Spooners with caution, ready to take one for the team, you know? Surpringly, I really like them! They're somewhat less sweet than the name brand, but what I like about the original is the texture, which is characterized by the sugar/wheat relationship and ratio. All of that remains in the generic and I'm completely satisfied with the product.

We expect to find bargains and good value with generics in the long run. Maybe we're terribly late getting onto the generics train, but better late than never.

The first thing that stinks about creating datatables from scratch is that you have to manually define the columns which is tedious. The second thing that stinks is that you can only add rows to the datatable using an object array which means you have to count commas to keep track of which column you are populating. Or you have to do something awkward like obj[datatable.Columns["FieldName"].Ordinal] = "somevalue". To get around this, the first step is to define the structure of our rows by creating a simple class, EG:

[sourcecode language='csharp']
public class Person
{
public string LastName { get; set; }
public string FirstName { get; set; }
public DateTime DateOfBirth { get; set; }
public decimal Salary { get; set; }
}
[/sourcecode]

Now we can call the method with a very convenient syntax that capitalizes on object and list initializers:

[sourcecode language='csharp']
public DataTable GetPeople()
{
return ListToTable(new List {
new Person {
LastName = "Opincar",
FirstName = "John",
DateOfBirth = new DateTime(1901, 1, 1),
Salary = 250000.00M
},
new Person {
LastName = "Lincoln",
FirstName = "Abe",
DateOfBirth = new DateTime(1801, 1, 15),
Salary = 1000.00M
}
});
}
[/sourcecode]

If you've ever manually populated datatables you can really appreciate what a huge improvement this is.

Finally, we discuss the method itself. Using reflection, we can leverage the type information stored in Person to create our datatable columns in a generic method that takes a List as input and returns a datatable:

[sourcecode language='csharp']
public DataTable ListToTable(List rows)
{
var dt = new DataTable();
var props = typeof(T).GetProperties();
Array.ForEach(props, p => dt.Columns.Add(p.Name, p.PropertyType));
foreach ( var r in rows )
{
object[] vals = new object[props.Length];
for (int idx = 0; idx < vals.Length; idx++)
{
vals[idx] = props[idx].GetValue(r, null);
}
dt.Rows.Add(vals);
}
return dt;
}
[/sourcecode]

I hope you find this method as useful as I have.

Note that this example is a .NET3.5 example due to the lazy implementation of the property

[sourcecode language='csharp']
class Program
{
static void Main(string[] args)
{
List derivCls = new List();
derivCls.Add(new MyDerivCls("Hello World1"));
derivCls.Add(new MyDerivCls("Hello World2"));

//Now I wan't to cast List to List, but that gives a compile error:
//Cannot implicitly convert type 'System.Collections.Generic.List' to 'System.Collections.Generic.List'
//List baseList = derivCls;

//Instead a helper function helps us out:
List baseList = MyDerivCls.ToListOfBase(derivCls);

IMyBase baseObj = baseList[0];
string myStr = baseObj.MyProperty;
Console.WriteLine(myStr); //"Hello World1"
}
}

interface IMyBase {
string MyProperty { get; set; }
}

class MyDerivCls: IMyBase
{
public MyDerivCls(string InitValue) {
MyProperty = InitValue;
}

public string MyProperty { get; set; }

///

///

Recently I read this rather fascinating post about a Type-safe Builder Pattern in Scala. When Heinz Kabutz mentioned the builder pattern in his latest issues of the The Java Specialists’ Newsletter I decided to try to come up with a type safe version for Java.

What I finally came up with is not strictly a builder but something I rather call an initializer. The initializer contains the initial state required by the target object. The state is accumulated within the initializer. Only when the state is complete can it be passed to the targets object's constructor. Java's type system prevents passing a initializer with an incomplete state to the target class's constructor.

[sourcecode language='java']
public class Foo {
private final int a;
private final int b;

public Foo(Initializer initializer) {
this(initializer.a, initializer.b);
}

private Foo(int a, int b) {
super();
this.a = a;
this.b = b;
}

public String toString() {
return "a = " + a + ", b = " + b;
}

public static class Initializer {
private int a;
private int b;

private Initializer() {
super();
}

private Initializer(int a, int b) {
super();
this.a = a;
this.b = b;
}

public static Initializercreate() {
return new Initializer();
}

public Initializer setA(int a) {
this.a = a;
return new Initializer(a, this.b);
}

public Initializer setB(int b) {
this.b = b;
return new Initializer(this.a, b);
}

static abstract class TRUE {}
static abstract class FALSE {}
}

}
[/sourcecode]

The basic technique is the same as for the Type-safe Builder Pattern in Scala: the phantom types TRUE and FALSE are used to keep track of the state. Only a complete state will result in a Initialiter instance which subsequently can be passed to Foo's constructor.

Here is how this is used:

[sourcecode language='java']
public class Main {
public static void main(String[] args) {
Initializer initializer = Initializer.create();

// Foo.create(initializer); // won't compile
// Foo.create(initializer.setB(1)); // won't compile
// Foo.create(initializer.setA(1)); // won't compile

Foo foo = new Foo(initializer.setA(1).setB(2));
System.out.println(foo);
}
}
[/sourcecode]

The New constraint must be the first one, if needed.
The interface constraint is to be able to use properties and methods on the generic type.
It could be a base class also. The base class should then be placed before the interfaces.

[sourcecode language='vb']
Imports System.Collections.Generic 'List(Of

        Public Sub MyGenericSub(Of T As {New, IImplementedByT})(ByRef MyList As List(Of T))
            Dim myObj As New T
            myObj.AMethodOnIImplementedByT()
[/sourcecode]

And some C#:
http://msdn.microsoft.com/en-us/library/d5x73970.aspx
The New constraint must be the last one, if needed.

[sourcecode language='csharp']
public bool MyMethod(T t) where T : IMyInterface, new() { }
[/sourcecode]

You could also choose to convert the List to a Dict using ToDictionary()

[sourcecode language='vb']
Imports System.Collections.Generic 'List
Imports System.Linq '.NET3.0 extension methods: ToLookup(), ToDictionary()

Public Sub SomeSub()
Dim my1stList As List(Of MyObject) = LoadMyList() 'Get some data

Dim my2ndList As List(Of MyObject)
Dim myDict As Dictionary(Of String, MyObject)
Dim myLookup As ILookup(Of String, MyObject)
Dim myRow As MyObject = Nothing

'Following will crash in runtime if the key field userid on MyObject is not unique

'Example of using lookup with userid as key
myLookup = my1stList.ToLookup(Function(o) o.userid) 'using IEnumerable.ToLookup()
myRow = myLookup.Item("myuserid" )
Console.WriteLine(myRow.someProperty)

'convert the List to a Dict
myDict = my1stList.ToDictionary(Function(o) o.userid, Function(o) o)
'or
myDict = my1stList.ToDictionary(Of MyObject, String)(Function(o) o.userid)
myRow = myDict("myuserid" )
Console.WriteLine(myRow.someProperty)
[/sourcecode]

C#:  

[sourcecode language='csharp']
myDict = my1stList.ToDictionary(p => p.userid, p => p);
//or
myDict = my1stList.ToDictionary(p => p.userid);
[/sourcecode]