ilikeblues

Stephen Hawking, uno de los más grandes físicos de nuestro tiempo (con su punto de showman, que a veces le resta un poco de seriedad), es además un gran “vendedor de divulgación científica”. Y esto es algo que saben perfectamente sus editores.

Y de ahí todo el revuelo de los últimos días, relacionado con que “Hawking de repente ha cambiado de opinión: ahora ya no cree en dios”.

Pero bueno, ¿quién dijo que antes sí creía?

Que yo sepa, lo único que había afirmado es que las teorías que manejan los físicos NO excluyen la posibilidad de un dios creador. A lo cual yo añadiría, algo que sí puede afirmar la física: la figura de dios es algo completamente fútil e irrelevante.

La razón es muy sencilla: las leyes de la física son eternas e inmutables, dentro del universo conocido, por supuesto. Sobre lo que ocurre fuera no podemos afirmar nada.

Otra cosa es que nuestras representaciones matemáticas de esas leyes no sean infalibles. Por supuesto, pueden estar sujetas a cambio.

Entonces, ¿qué sentido tiene rezar o creer en un dios que no puede, de ninguna manera, influir en el universo, pues las leyes físicas son inmutables?

Para mí, la última afirmación de Hawking sólo significa una cosa respecto a su postura anterior, y es que, en el transcurso de esto años, nuestro conocimiento sobre lo ocurrido durante el Big Bang ha progresado considerablemente.

Todo lo demás se reduce a una sóla cosa: publicidad. Publicidad para lo que será, probablemente, un nuevo best-seller de divulgación. Un libro demasiado complicado para los ciudadanos “de a pie” (en lo que se refiere a la física) y demasiado simplista para los “iniciados” en la materia.

En C++ podemos utilizar la librería boost para tener una funcionalidad similar al “garbage collector” de Java o .NET.

En concreto, podemos usar los smart pointers provistos por esta librería para “automatizar” la liberación de memoria en nuestra aplicación, ayudando a evitar los memory leaks.

Veamos un ejemplo de código:

#include <boost/shared_ptr.hpp>
#include <iostream>
#include <vector>

// Just a simple class
class Foo{
public:
        Foo(){ }
        ~Foo(){
                std::cout << "Destructing. " << (int)this << std::endl;
        }
};

// Make shorthand to cut some typing
typedef boost::shared_ptr<Foo> FooPtr;

// this functions allocates memory for an object, return a shared_ptr to it and forgets about it.
FooPtr CreateFoo(){
        FooPtr fp(new Foo);
        return fp;
}

int main(int argc, char** argv){

        std::vector<FooPtr> foos;

        foos.push_back(CreateFoo());
        foos.push_back(CreateFoo());

        FooPtr temp = foos[1]; // extract the second object
        std::cout << "clearing vector.." << std::endl;
        foos.clear(); // the first object will be deleted here, but not the second, since it has a reference still in scope.
        std::cout << "ending program.." << std::endl;
        // main returns and the final object goes out of scope and is automatically destroyed.
        return 0;
}

El código muestra cómo usar boost::shared_ptr, junto con los contenedores de la STL. Nótese que no se ha utilizado ningún “delete”.

Este objeto, shared_ptr, puede ser utilizado como “envoltorio” de los punteros a objetos, de manera que se haga un seguimiento de los referencias a estos. Una vez que todas las referencias al objeto han sido eliminadas, o han salido de su ámbito, se libera automáticamente la memoria reservada para el objeto.

Por supuesto, esta “recolección de basura” sólo es válida para los objetos creados en nuestro código usando el puntero inteligente. Cualquier objeto creado en librerías de terceros, debe ser convenientemente manejado para evitar las fugas de memoria.

Vía | http://www.libzter.com

El siguiente código muestra los pasos más sencillos para un ordenar un mapa (java.util.Map) en Java:

public class SortMapExample{

   public static void main(String[] args) {

	System.out.println("Unsort Map......");
	Map<String,String> unsortMap = new HashMap<String,String>();
	unsortMap.put("1", "1");
	unsortMap.put("2", "A");
	unsortMap.put("3", "2");
	unsortMap.put("4", "B");
	unsortMap.put("5", "C");
	unsortMap.put("6", "c");
	unsortMap.put("7", "b");
	unsortMap.put("8", "a");

	Iterator iterator=unsortMap.entrySet().iterator();

        for (Map.Entry entry : unsortMap.entrySet()) {
        	System.out.println("Key : " + entry.getKey()
       			+ " Value : " + entry.getValue());
        }

        System.out.println("Sorted Map......");
        Map<String,String> sortedMap =  sortByComparator(unsortMap);

        for (Map.Entry entry : sortedMap.entrySet()) {
        	System.out.println("Key : " + entry.getKey()
       			+ " Value : " + entry.getValue());
        }
   }

   private static Map sortByComparator(Map unsortMap) {

        List list = new LinkedList(unsortMap.entrySet());

        //sort list based on comparator
        Collections.sort(list, new Comparator() {
             public int compare(Object o1, Object o2) {
	           return ((Comparable) ((Map.Entry) (o1)).getValue())
	           .compareTo(((Map.Entry) (o2)).getValue());
             }
	});

        //put sorted list into map again
	Map sortedMap = new LinkedHashMap();
	for (Iterator it = list.iterator(); it.hasNext();) {
	     Map.Entry entry = (Map.Entry)it.next();
	     sortedMap.put(entry.getKey(), entry.getValue());
	}
	return sortedMap;
   }
}

El algoritmo implica las siguientes transformaciones:

Map –> List –> Order List –> Map

A priori, no parece que sea un algoritmo muy optimizado. ¿Alguna sugerencia para mejorar el rendimiento?

Vía | http://www.mkyong.com

A menudo resulta útil guardar ficheros (por ejemplo, de configuración) en el bundle y leerlos durante la ejecución de ciertas tareas de nuestro plugin. Para ello podemos utilizar el siguiente código (reemplazando el nombre del bundle, claro):

Bundle bundle = Platform.getBundle("com.ilikeblues.example.readfile");
URL fileURL = bundle.getEntry("files/test.txt");
File file = null;
try {
	file = new File(FileLocator.resolve(fileURL).toURI());
} catch (URISyntaxException e1) {
	e1.printStackTrace();
} catch (IOException e1) {
	e1.printStackTrace();
}

Otra opción es utilizar la URL directamente:

Seguir leyendo »

Como continuación de una entrada en la que comentaba como añadir un constructor y métodos a un enum Java, veamos cómo utilizar esta tipo de objetos en un switch:

private void processGender(Gender gender) {
   switch (gender) {
      case Male:
         // Código para el caso masculino
         break;
      case Female:
         // Código para el caso femenino
         break;
      default:
         // Esto es código inalcanzable, ya que
         // el switch lanzará una NullPointerException si gender == null
   }
}

Si utilizamos enums, más tarde o más temprano tendremos que usar una estructura de este tipo en la toma de decisiones.

Vía | http://javafact.com

El código que se muestra a continuación, lee el contenido de un fichero de propiedades y devuelve el valor de una de ellas:

Properties properties = new Properties();
FileInputStream in;
try {
   in = new FileInputStream("app.properties");
   properties.load(in);
   in.close();
} catch (Exception e) {
   System.out.println(e.getMessage());
}
return properties.getProperty("appcode");

Un ejemplo del fichero de propiedades:

appcode=50
email=admin@yahoo.com

Vía | http://seguide.blogspot.com

En un post en DZONE, Daniel Schneller describe una situación que pone de manifiesto un comportamiento un tanto extraño, relacionado con el orden de inicialización de los objetos Java.

Daniel muestra el siguiente código Java:

package com.ds.test;

public class Upper {
   String upperString;

   public Upper() {
      Initializer.initialize(this);
   }
}

package com.ds.test;

public class Lower extends Upper {

   String lowerString = null;

   public Lower() {
      super();
      System.out.println("Upper:  " + upperString);
      System.out.println("Lower:  " + lowerString);
   }

   public static void main(final String[] args) {
      new Lower();
   }
}

package com.ds.test;
public class Initializer {
   static void initialize(final Upper anUpper) {
      if (anUpper instanceof Lower) {
         Lower lower = (Lower) anUpper;
         lower.lowerString = "lowerInited";
      }
      anUpper.upperString = "upperInited";
   }
}

Este código, en contra de lo que podría parecer, produce esta salida:
Seguir leyendo »

En Java, los enums representan objetos con un conjunto discreto de posibles valores.

Estos valores pueden ser de cualquier tipo, enteros, cadenas, etc., pero en Java tenemos mecanismos que nos permiten representar estos valores de varias formas, de manera que se ajusten a la necesidad de cada caso.

La manera más sencilla de especificar un enum en Java:

public enum Gender{
   Male, Female;
}

Pero es que, además de sus posibles valores, un enum puede tener constructores y métodos:

public enum Gender{
   Male("Masculino"), Female("Femenino");

   private String spanish;

   // the constructor
   Gender(String spanish){
      this.spanish = spanish;
   }

   // a method
   public String toSpanish(){
      return this.spanish;
   }
}

De manera que podríamos usar este enum de la siguiente manera:

Person p = new Person();
p.setGender(Gender.Male);

String text = "The person's gender in Spanish is: " + p.getGender().toSpanish();

Con esto un enum es similar a una colección (Collection) en Java, con las siguientes diferencias:

1. La máquina virtual inicializa todos los valores.
2. No se permite añadir o eliminar elementos en runtime.
3. Se accede a los objetos estáticamente.

En el ejemplo, Gender representa a la colección, y se puede acceder a sus elementos sin necesidad de crear una instancia.

Vía | http://javafact.com

Como comentan en la vía, la documentación de jQuery en la web oficial no siempre es tan completa como debería. Así que ahí van algunos de trozos de código que puede ayudar al maneja de los checkboxes:

Seleccionar/deseleccionar un checkbox:

// Seleccionar un checkbox
$('input[name=acheckbox]').attr('checked', true);

// Deseleccionar un checkbox
$('input[name=acheckbox]').attr('checked', false);

Seleccionar/deseleccionar todos los checkbox:

// Seleccionar todos los checkboxes
$("input:checkbox").attr('checked', true);

// Deseleccionar todos los checkboxes
$("input:checkbox").attr('checked', false);

Comprobar si un checkbox está seleccionado:
Seguir leyendo »

La siguiente hoja CSS permite resetear los estilos por defecto del navegador que estés usando. Con esto podemos evitar las inconsistencias en la presentación del sitio web en distintos navegadores.

html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, font, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
b, u, i, center,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td {
margin: 0;
padding: 0;
border: 0;
outline: 0;
font-size: 100%;
vertical-align: baseline;
background: transparent;
}
body {
line-height: 1;
}
ol, ul {
list-style: none;
}
blockquote, q {
quotes: none;
}
blockquote:before, blockquote:after,
q:before, q:after {
content: '';
content: none;
}

/* remember to define focus styles! */
:focus {
outline: 0;
}

/* remember to highlight inserts somehow! */
ins {
text-decoration: none;
}
del {
text-decoration: line-through;
}

/* tables still need 'cellspacing="0"' in the markup */
table {
border-collapse: collapse;
border-spacing: 0;
}

Vía | http://www.webspeaks.in