tag:blogger.com,1999:blog-60758403788600131162024-03-05T12:16:59.858+01:00A vueltas con la programaciónRaúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.comBlogger15125tag:blogger.com,1999:blog-6075840378860013116.post-25826516275845099772011-06-07T22:50:00.000+02:002011-06-07T22:50:35.847+02:00Puntos clave del tema 5<div dir="ltr" style="text-align: left;" trbidi="on">Estos son los puntos clave del tema 5:<br />
<ul style="text-align: left;"><li> Implementación de Tipos Abstractos de Datos:</li>
<ul><li>Cadena enlazada</li>
<li>Pila</li>
<li>Cola</li>
<li>Pila acotada</li>
<li>Lista</li>
<li>Buffer</li>
</ul><li>Utilización de atributos de tipo objeto</li>
</ul></div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-24917256497283964732011-05-27T16:15:00.000+02:002011-05-27T16:15:24.294+02:00Interacción avanzada con aplicaciones Java utilizando el teclado<div dir="ltr" style="text-align: left;" trbidi="on"><div><br />
En muchas aplicaciones Java queremos interaccionar con el teclado no únicamente para introducir datos, sino para hacer otro tipo de acciones. Un ejemplo de esto son los juegos, en los que queremos detectar qué teclas o combinaciones de teclas se están pulsando en cada momento. <br />
<br />
Java proporciona la interfaz <i><a href="http://download.oracle.com/javase/6/docs/api/java/awt/event/KeyListener.html">KeyListener</a></i> que deben implementar todas aquellas clases interesadas en procesar eventos del teclado. <br />
<br />
La interfaz define tres métodos:<br />
<ul style="text-align: left;"><li><i>void keyPressed(KeyEvent e)</i> para cuando una tecla se pulsa</li>
<li><i>void keyReleased(KeyEvent e)</i> para cuando una tecla se suelta</li>
<li><i>void keyTyped(KeyEvent e)</i> para cuando se escribe un caracter </li>
</ul><br />
Una forma de implementar la interfaz <i>KeyListener</i> para conocer qué teclas se están pulsando en un momento determinado en una aplicación Java es la siguiente: <br />
<br />
</div><div><b>1. Creamos una clase que implemente la interfaz <i>KeyListener</i></b></div><br />
<b>2. Creamos los atributos de la clase</b><br />
Nos interesará crear:<br />
<ul><li>Un array que almacene el estado de cada una de las teclas de un teclado; este estado puede ser un booleano (pulsado o no pulsado). Un valor que se puede utilizar como tamaño del array y que valdrá para la mayoría de teclados es 256. </li>
<li>También podríamos querer tener otro array donde almacenemos estados más allá de un simple booleano (por ejemplo un enumerado con pulsado, pulsado por primera vez o pulsado y mantenido pulsado).</li>
<li>Otros atributos que pueden interesarnos son booleanos que nos indiquen si se ha pulsado una tecla o no, para los casos en los que nos de igual qué tecla se haya pulsado.</li>
</ul><b>3. Implementamos los métodos de la interfaz </b><br />
<div>Como hemos visto antes, los métodos reciben como parámetro un <i><a href="http://download.oracle.com/javase/6/docs/api/java/awt/event/KeyEvent.html">KeyEvent</a></i>, el cual tiene un método <i>getKeyCode</i> que nos devuelve el código de la tecla. Una vez comprobemos que este código está dentro de los valores admitidos por nuestro array (entre 0 y 255) actualizamos los atributos para almacenar el estado actual del teclado. <br />
<br />
<b>4. Implementamos los métodos para preguntar por el estado de las teclas </b><br />
Finalmente, implementaremos los métodos que queramos para preguntar a nuestra clase acerca del estado actual del teclado. Por ejemplo: <br />
<br />
<ul style="text-align: left;"><li><i>boolean teclaPulsada(int tecla) </i></li>
<li><i>boolean teclaNoPulsada(int tecla) </i></li>
<li><i>boolean algunaTeclaPulsada() </i></li>
<li><i>boolean algunaTeclaNoPulsada() </i></li>
</ul><br />
Una vez tengamos nuestra clase implementada (y probada) ya podemos utilizarla en nuestra aplicación. <br />
Primero nos definimos e inicializamos un objeto de dicha clase y después le iremos preguntando por las teclas acerca de las que nos interesa conocer su estado. <br />
<br />
<b>Referencias:</b> <br />
<br />
<ul style="text-align: left;"><li>Esta entrada ha sido inspirada por <a href="http://gpsnippets.blogspot.com/2008/03/keyboard-input-polling-system-in-java.html">esta</a> y <a href="http://www.gamedev.net/page/resources/_/reference/programming/languages/java/java-games-keyboard-and-mouse-r2439">esta</a>, en ellas podéis encontrar ejemplos de lo que he explicado.</li>
<li>Aquí podéis encontrar más información de <i><a href="http://download.oracle.com/javase/tutorial/uiswing/events/keylistener.html">cómo implementar la interfaz KeyListener</a></i>. </li>
<li>Una librería que tiene buena pinta para manejar entrada de datos en juegos es <i><a href="http://java.net/projects/jinput/">Jinput</a></i>. </li>
<li>Y una muy buena referencia para programar juegos en Java es el libro <i><a href="http://fivedots.coe.psu.ac.th/%7Ead/jg/">Killer Game Programming in Java</a></i>, disponible por completo en la Web, continuamente actualizado y con un montón de ejemplos de código. </li>
</ul><br />
<br />
Y, para finalizar, Java además de proporcionar una interfaz para procesar eventos de teclado también proporciona una para procesar eventos del ratón. ¿A alguien se le ocurre cómo se puede llamar la interfaz? </div></div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com2tag:blogger.com,1999:blog-6075840378860013116.post-2059950999667556232011-05-19T23:30:00.000+02:002011-05-19T23:30:55.768+02:00Enlazar una librería con su documentación<div dir="ltr" style="text-align: left;" trbidi="on"> <style type="text/css">
li { list-style: none; margin: 0; }
p { margin: 0; }
span.l { color: red; font-weight: bold; }
a.mapnode:link {text-decoration: none; color: black; }
a.mapnode:visited {text-decoration: none; color: black; }
a.mapnode:active {text-decoration: none; color: black; }
a.mapnode:hover {text-decoration: none; color: black; background: #eeeee0; }
</style> <br />
Hay veces en las que tenemos por separado el fichero jar de una librería y otro fichero con la documentación de dicha librería.<br />
<br />
Eclipse nos permite asociar la documentación de un jar con el mismo de una forma fácil.<br />
<br />
Hay que ir a: <i>Project -> Properties -> Jaba Build Path -> Libraries</i>. Si desplegamos el jar al que queramos añadir la documentación, nos encontraremos con algo como lo que aparece en la figura.<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjafj5KbV5A1a5SemVfmxYPjIkDiTyMS9yxUlmmeoiib6k8e8k3cEiMoZEfoOmj_h2j5N570K2wslC57Knzw0agcZSEowPnreufHLZm1SZ6e_5JXkejC6mn9IBoh-Zv3Y5zm-jXKyjNlhE/s1600/Captura+de+pantalla+2011-05-19+a+las+23.17.00.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="295" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjafj5KbV5A1a5SemVfmxYPjIkDiTyMS9yxUlmmeoiib6k8e8k3cEiMoZEfoOmj_h2j5N570K2wslC57Knzw0agcZSEowPnreufHLZm1SZ6e_5JXkejC6mn9IBoh-Zv3Y5zm-jXKyjNlhE/s400/Captura+de+pantalla+2011-05-19+a+las+23.17.00.png" width="400" /></a></div><br />
Al seleccionar <i>Javadoc location</i> y hacer click en <i>Edit...</i> nos aparece un formulario en el que podemos elegir la localización de la documentación del jar, ya sea en una URL o en un archivo del ordenador o del workspace. <br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhtInLLVIjhIB3Xs0WzjYT57x9bX3f9_nqhC-s7rH0HBMWnWruh5rggb0OOyHLxc-mH_JGIvJcdzOMwiSqjx0OHsNApWVYKkhnl5G-5VnFkcpN_OzaKJlJ9etGv3TyVPSKawofjB7yTF3U/s1600/Captura+de+pantalla+2011-05-19+a+las+23.19.14.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="272" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhtInLLVIjhIB3Xs0WzjYT57x9bX3f9_nqhC-s7rH0HBMWnWruh5rggb0OOyHLxc-mH_JGIvJcdzOMwiSqjx0OHsNApWVYKkhnl5G-5VnFkcpN_OzaKJlJ9etGv3TyVPSKawofjB7yTF3U/s400/Captura+de+pantalla+2011-05-19+a+las+23.19.14.png" width="400" /></a></div><br />
Al seleccionar una opción u otra, tenemos la opción de validar si la selección ha sido correcta con el botón <i>Validate...</i>. <br />
<br />
Una vez asociada la documentación con el jar, podemos beneficiarnos de tener la documentación del mismo integrada dentro del Eclipse. <br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhQl_Do37FGmFfL9S6lYwBSg50ZZdX-Ur9KTlFWN5EsWzq7CLvITFq7LEH50zepnDKA1wfAAbGDmnf7AsDfNR1Bwvb5QTnW4FTlLwlW8KUjRG0oqQ-qMGKkDWLWGgYPgkjcwZkieB02Vcw/s1600/Captura+de+pantalla+2011-05-19+a+las+23.20.58.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="127" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhQl_Do37FGmFfL9S6lYwBSg50ZZdX-Ur9KTlFWN5EsWzq7CLvITFq7LEH50zepnDKA1wfAAbGDmnf7AsDfNR1Bwvb5QTnW4FTlLwlW8KUjRG0oqQ-qMGKkDWLWGgYPgkjcwZkieB02Vcw/s400/Captura+de+pantalla+2011-05-19+a+las+23.20.58.png" width="400" /></a></div><br />
De la misma manera, también podemos asociar el código fuente de un jar a un jar en concreto. ¿Para qué creéis que puede valer esto? <br />
</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-74503564002930467602011-05-05T17:56:00.000+02:002011-05-05T17:56:48.270+02:00Puntos clave del tema 4<div dir="ltr" style="text-align: left;" trbidi="on">Estos son los puntos clave del tema 4:<br />
<ul style="text-align: left;"><li>Documentación con <a href="http://www.oracle.com/technetwork/java/javase/documentation/index-jsp-135444.html">Javadoc</a></li>
<ul><li>Precondiciones</li>
<li>Postcondiciones</li>
<li><a href="http://www.lab.dit.upm.es/%7Elprg/material/apuntes/o/index.html">Complejidad</a></li>
</ul><li>Tipos Abstractos de Datos (TADs)</li>
<ul><li>Qué es un TAD</li>
<li>Ejemplos de TADs</li>
<ul><li>Pila</li>
<li>Cola</li>
<li>Pila acotada</li>
</ul></ul></ul></div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-6042235468919863282011-04-28T18:55:00.002+02:002011-04-28T19:00:00.766+02:00Orden de complejidad de algoritmos a simple vista<div dir="ltr" style="text-align: left;" trbidi="on">Esta gráfica muestra de un vistazo la importancia de la complejidad del código que implementemos.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg94l-r3ML9i3zptknDe9zqfLWkBTdirx5vi_fhQSxkDfNmCW6o9bQQxhc-wSesbxgORY98DrKS6bpHL0BTgvVSh43-y5HH5uonAJ2MeuZAzPfRJgzvvc2v5DEkTE-kApR4fgHOeAO9jzE/s1600/Complejidad2.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="257" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg94l-r3ML9i3zptknDe9zqfLWkBTdirx5vi_fhQSxkDfNmCW6o9bQQxhc-wSesbxgORY98DrKS6bpHL0BTgvVSh43-y5HH5uonAJ2MeuZAzPfRJgzvvc2v5DEkTE-kApR4fgHOeAO9jzE/s400/Complejidad2.jpg" width="400" /></a></div>A pesar de que se muestran valores cercanos al eje de coordenadas, se puede comprobar fácilmente la penalización en tiempo de ejecución según aumenta la complejidad.</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-20282418992337021042011-04-15T10:37:00.000+02:002011-04-15T10:37:56.409+02:00Puntos clave del tema 3<div dir="ltr" style="text-align: left;" trbidi="on">Estos son los puntos clave del tema 3:<br />
<style type="text/css">
li { margin: 0; }
p { margin: 0; }
span.l { color: red; font-weight: bold; }
a.mapnode:link {text-decoration: none; color: black; }
a.mapnode:visited {text-decoration: none; color: black; }
a.mapnode:active {text-decoration: none; color: black; }
a.mapnode:hover {text-decoration: none; color: black; background: #eeeee0; }
</style> <br />
<ul style="text-align: left;"><li>Manejo de situaciones anómalas</li>
<ul><li>Aserciones</li>
<li>Excepciones</li>
<ul><li>Lanzamiento y captura</li>
<li>Definición de excepciones </li>
</ul></ul><li>Interfaces </li>
<ul><li>Interfaces comunes</li>
<ul><li><a href="http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Cloneable.html">Cloneable</a></li>
<li><a href="http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Comparable.html">Comparable</a> </li>
</ul></ul><li>Herencia y polimorfismo</li>
<ul><li>Herencia de clases</li>
<li>Polimorfismo</li>
<li>Clases abstractas </li>
</ul><li>Genéricos </li>
</ul></div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-48220111269395197902011-04-08T10:05:00.000+02:002011-04-08T10:05:00.462+02:00Serialización de objetos Java<div dir="ltr" style="text-align: left;" trbidi="on">Los objetos que creamos en Java no sólo viven en la memoria del ordenador. Java permite convertir un objeto en memoria en un grupo de bytes para después convertir de nuevo ese grupo de bytes en un objeto en memoria (lo que se llama serializar y deserializar, respectivamente).<br />
<br />
Las utilidades de esto son todas las que se nos ocurran. Desde persistir objetos en ficheros para utilizarlos más allá de la ejecución del programa a enviar un objeto a través de una red para utilizarlo en un programa Java en otro ordenador.<br />
<br />
Para indicar que una clase es serializable, ha de implementar la interfaz <a href="http://download.oracle.com/javase/1.5.0/docs/api/java/io/Serializable.html">Serializable</a> (como no). Y, en caso de que uno de los atributos de la clase sea a su vez un objeto, la clase de dicho objeto tiene también que implementar dicho interfaz.<br />
<br />
Tenía pensado contar más detalles acerca de la serialización, pero me he encontrado con una guía muy buena sobre la serialización en Java en <a href="http://chuwiki.chuidiang.org/index.php?title=Serializaci%C3%B3n_de_objetos_en_java">ChiWiki</a> que incluye lo que pensaba contar y más.<br />
<br />
Y, por su puesto, nunca viene de más consultar la <a href="http://download.oracle.com/javase/1.5.0/docs/guide/serialization/">documentación de Java sobre serialización</a>.</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-2291434005720220832011-04-01T15:55:00.000+02:002011-04-01T15:55:46.382+02:00Más allá del println<div dir="ltr" style="text-align: left;" trbidi="on">Si queréis llevar vuestra depuración de código a otro nivel, sin tener que recurrir continuamente al <i>System.out.println</i>, podéis utilizar una librería de manejo de trazas.<br />
<br />
Estas librerías os permiten manejar trazas de ejecución de los programas que hagáis, evitando mostrar siempre los mensajes por la consola, y además definen distintos niveles de mensajes para poder elegir con qué detalle se quiere almacenar la traza.<br />
<br />
El propio Java viene con un manejador de trazas (<a href="http://download.oracle.com/javase/6/docs/technotes/guides/logging/overview.html">Logger</a>), no obstante el más utilizado es <a href="http://logging.apache.org/log4j/">Log4J</a> y es el que os voy a presentar a continuación.<br />
<br />
Para utilizar Log4J en un proyecto, lo primero que hay que hacer es incluir en dicho proyecto el jar con las librerías de Log4J que os podéis descargar de la página del proyecto.<br />
<br />
El funcionamiento básico es definirse un objeto de tipo <a href="http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/Logger.html">Logger</a> llamando a su constructor y pasándole como parámetro el nombre que le queramos dar (si en vez de un nombre le pasamos una clase, utilizará el nombre de la clase). <br />
<br />
<pre>Logger miLogger = Logger.getLogger("programa.logger");
</pre><br />
Después tenemos que configurar cómo queremos manejar la traza. Esto se puede hacer o utilizando un fichero de configuración o desde el mismo código. Lo más recomendable es utilizar un fichero de configuración; no obstante, para este ejemplo utilizaremos el configurador por defecto que nos muestra las trazas de todos los niveles por la consola. <br />
<br />
<pre>BasicConfigurator.configure();
</pre><br />
A partir de aquí, podremos utilizar distintos métodos para almacenar nuevas trazas con distintos niveles. Log4J tiene los siguientes niveles de traza (definidos como constantes de la clase org.apache.log4j.Level):<br />
<br />
<ul style="text-align: left;"><li><b>FATAL</b>. Errores serios que harán que la aplicación interrumpa su ejecución<b> </b></li>
<li><b>ERROR</b>. Errores con los que la aplicación podría continuar su ejecución<b> </b></li>
<li><b>WARN</b>. Situaciones potenciales de error<b> </b></li>
<li><b>INFO</b>. Mensajes generales de diagnóstico del progreso de la aplicación<b> </b></li>
<li><b>DEBUG</b>. Mensajes específicos de diagnóstico del progreso de la aplicación<b> </b></li>
<li><b>TRACE</b>. Mensajes mucho más específicos sobre la aplicación </li>
</ul><br />
Y cada uno de dichos niveles tiene un método que almacena una traza en dicho nivel.<br />
<br />
<pre>public void debug(Object message)
</pre><br />
Si quisiéramos mostrar sólo a partir de cierto nivel, se podría también indicar tanto en el código como en el fichero de configuración. Por ejemplo la siguiente linea mostraría sólo las trazas de nivel INFO y superiores (WARN, ERROR y FATAL).<br />
<br />
<pre>logger.setLevel(Level.INFO);
</pre><br />
Si ejecutamos el siguiente ejemplo<br />
<br />
<pre>import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;
public class ClaseEjecutable {
public static void main(String[] args) {
Logger miLogger = Logger.getLogger("programa.logger");
BasicConfigurator.configure();
miLogger.info("Inicio de la ejecución");
String cadena = "Cadena de texto";
int numero = 1;
cadena = cadena + numero;
if (cadena.equals("Cadena de texto1")){
System.out.println("La cadena calculada es: " + cadena);
miLogger.debug("La concatenación ha funcionado");
} else {
miLogger.debug("La concatenación no ha funcionado");
}
miLogger.info("Fin de la ejecución");
}
}
</pre><br />
podremos ver por la consola la siguiente salida donde se muestran las distintas trazas y sus correspondientes niveles. <br />
<br />
<pre>0 [main] INFO programa.logger - Inicio de la ejecución
La cadena calculada es: Cadena de texto1
1 [main] DEBUG programa.logger - La concatenación ha funcionado
1 [main] INFO programa.logger - Fin de la ejecución
</pre><br />
Una vez hemos acabado de depurar el programa, no hace falta que eliminemos ni una linea de código, con poner el nivel ERROR ya solo nos aparecerán aquellas trazas que muestren errores en el programa. <br />
<br />
Log4J permite hacer muchas más cosas que las que se mencionan aquí, con lo que os animo echar un vistazo a su <a href="http://logging.apache.org/log4j/1.2/manual.html">documentación</a> y a los <a href="http://www.google.es/search?q=log4j+tutorial">tutoriales</a> disponibles en la Web. <br />
<br />
¿Qué os parece esta alternativa al <i>println</i>?<br />
¿Creéis que la usaréis en un futuro cercano? <br />
<br />
</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com2tag:blogger.com,1999:blog-6075840378860013116.post-25887219860566417292011-03-24T23:15:00.000+01:002011-03-24T23:15:45.525+01:00Depuración de Java con Eclipse<div dir="ltr" style="text-align: left;" trbidi="on"><style type="text/css">
li { list-style: none; margin: 0; }
p { margin: 0; }
span.l { color: red; font-weight: bold; }
a.mapnode:link {text-decoration: none; color: black; }
a.mapnode:visited {text-decoration: none; color: black; }
a.mapnode:active {text-decoration: none; color: black; }
a.mapnode:hover {text-decoration: none; color: black; background: #eeeee0; }
</style> <br />
En esta entrada voy a intentar dar unas primeras nociones de cómo facilita Eclipse la depuración de código. En su modo de depuración, Eclipse nos permite ejecutar paso a paso el código y analizar el contenido de las variables. <br />
<br />
Lo primero que hay que hacer es definir en qué punto o puntos del código queremos que la ejecución del programa se pause. Para ello, definiremos puntos de ruptura (<i>breakpoints</i>) en las lineas de código donde queramos que la ejecución pause.<br />
<br />
Para definir un punto de ruptura (o para eliminar uno existente), nos situamos en la linea que queramos y seleccionamos "<i>Run -> Toggle breakpoint</i>" o hacemos doble-click en la barra a la izquierda de la ventana del código. Al definir un punto de ruptura aparecerá en dicha barra un punto, tal y como se puede ver en la figura.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"></div><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgZd_MF1TZxfk7Xi81KO_yQWrdTY00U6aPZMZuH2eLp-rtf4hNTas4zwMtsX9qi4NrkUxR5H2r5hVEW6nBxBkJTTaZYUx18UPCHft1j3Hqr4-rZmcppejL04w6pO0B3oOHjJrn8QZv82yY/s1600/Breakpoint.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="267" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgZd_MF1TZxfk7Xi81KO_yQWrdTY00U6aPZMZuH2eLp-rtf4hNTas4zwMtsX9qi4NrkUxR5H2r5hVEW6nBxBkJTTaZYUx18UPCHft1j3Hqr4-rZmcppejL04w6pO0B3oOHjJrn8QZv82yY/s400/Breakpoint.png" width="400" /></a></div><br />
Una vez tenemos definidos los puntos de ruptura que queramos, iniciamos el depurador seleccionando desde una clase ejecutable "<i>Run -> Debug</i>" o, alternativamente, dando al botón con el bicho:<br />
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgFhARFMZAQIIP4jSyS8Kbu2cuwUZwtgPd8udGYW4bBCkceCuPh7-qfBxDP7zJQV0wF_pyFSRSAWQTbhRCZ9b6eLgpvqEGnzoCeX-Uh0hpsZ2MXrxeknfSB970FGya4iVkO0OFJ7P2DgZg/s1600/Bicho.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgFhARFMZAQIIP4jSyS8Kbu2cuwUZwtgPd8udGYW4bBCkceCuPh7-qfBxDP7zJQV0wF_pyFSRSAWQTbhRCZ9b6eLgpvqEGnzoCeX-Uh0hpsZ2MXrxeknfSB970FGya4iVkO0OFJ7P2DgZg/s1600/Bicho.png" /></a><br />
<br />
Lo primero que vemos es que el Eclipse cambia de la perspectiva <i>Java</i> a la Perspectiva <i>Debug</i>. En esta perspectiva, además de el código fuente, el esquema o la consola, podemos ver la información de las variables y una ventana donde se muestran los hilos de ejecución. <br />
<br />
En la siguiente imagen podemos ver cómo la ejecución se ha detenido en la linea 14 del <i>main</i> (donde habíamos definido el punto de ruptura) y cómo dicha linea aparece marcada en el código fuente. En la figura podemos ver el contenido de las variables y objetos que existen en el momento en que se ha pausado la ejecución, lo cual nos va a ayudar mucho en la depuración. <br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEghqwFvM9cM7HnlWIGkzOoLSEGpqSJ2U-tZHn4DsBzN-gKtYCNV02L4g1UZ-Xm_qVuxZtvT7bmqskJF1V7v71CPuyXr8QvnghGzAeADb0mY6Z5NjW_btxT8YH8m5v0ehwsD4XUjtqFdZFo/s1600/Debug.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="307" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEghqwFvM9cM7HnlWIGkzOoLSEGpqSJ2U-tZHn4DsBzN-gKtYCNV02L4g1UZ-Xm_qVuxZtvT7bmqskJF1V7v71CPuyXr8QvnghGzAeADb0mY6Z5NjW_btxT8YH8m5v0ehwsD4XUjtqFdZFo/s400/Debug.png" width="400" /></a></div><br />
Además, podemos indicar que la ejecución siga o se detenga a nuestro gusto utilizando los botones de la vista <i>Debug</i> (o las opciones del menú "<i>Run</i>"). A continuación explicamos las básicas. <br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhglLcQMQZ2pAhNz_raquyjrGX6j4HK_uFhcue3AFdCp89GC6rlGzeAy2xzRJExyLTjlbk24I2CrMIEhzzYZHoG9gsqs9wIPm58iybqOVTgrhILOu7uzqPUB5mwjBnCWaKuZC5KYMgOU9A/s1600/Resume.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhglLcQMQZ2pAhNz_raquyjrGX6j4HK_uFhcue3AFdCp89GC6rlGzeAy2xzRJExyLTjlbk24I2CrMIEhzzYZHoG9gsqs9wIPm58iybqOVTgrhILOu7uzqPUB5mwjBnCWaKuZC5KYMgOU9A/s1600/Resume.png" /></a></div><b>Resume. </b>Continúa la ejecución del programa hasta el próximo punto de ruptura o hasta que finaliza la ejecución. <br />
<ul></ul><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjl_2lGw1mwtY0kO1adHqdHi77QgRfJPB9zXFyWQ9ejv8GpNvjbYOvFXQ4WezgId_WysxhM3UULy2E8NgC__SVg5TxqVEqKjuQOtCHRjUqmgr8A-vpBzQjpdKIWiwiO1P4xwLOA9lhMPX8/s1600/Terminate.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjl_2lGw1mwtY0kO1adHqdHi77QgRfJPB9zXFyWQ9ejv8GpNvjbYOvFXQ4WezgId_WysxhM3UULy2E8NgC__SVg5TxqVEqKjuQOtCHRjUqmgr8A-vpBzQjpdKIWiwiO1P4xwLOA9lhMPX8/s1600/Terminate.png" /></a></div><b>Terminate. </b>Finaliza la ejecución del programa. <br />
<ul></ul><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEheMiaPdrWGIIzT3c_sxWMidtg0VPiB92l6rZD0FWpXYpBmZltuUbboYpNIeS0QkQZX0d1d81SpZQXzJGq7xWMe78WAHzb7x6uTav5M3xJ9Ld15nb29S9lhjdKogVlIss0bndBjJz3SVa8/s1600/StepInto.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEheMiaPdrWGIIzT3c_sxWMidtg0VPiB92l6rZD0FWpXYpBmZltuUbboYpNIeS0QkQZX0d1d81SpZQXzJGq7xWMe78WAHzb7x6uTav5M3xJ9Ld15nb29S9lhjdKogVlIss0bndBjJz3SVa8/s1600/StepInto.png" /></a></div><b>Step into. </b>Se ejecuta la linea actual y, en caso de ser una llamada a un método, la ejecución continúa dentro del método. <br />
<ul></ul><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgY-heNUozF04Rxlg-zAElYsUUC5hNMFy5ISPWsMJ6yYLyEeaooDN1MPsAUwQbRp_qZRvuVZuc-vBv79YTQqOaHQsVl-KANpruxQ7qccglimvlyTVpcJTbqdlafoEKKGPp1c83E8r5vr38/s1600/StepOver.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgY-heNUozF04Rxlg-zAElYsUUC5hNMFy5ISPWsMJ6yYLyEeaooDN1MPsAUwQbRp_qZRvuVZuc-vBv79YTQqOaHQsVl-KANpruxQ7qccglimvlyTVpcJTbqdlafoEKKGPp1c83E8r5vr38/s1600/StepOver.png" /></a></div><b>Step over. </b>Se ejecuta la linea actual y se pasa a la linea siguiente sin entrar en los métodos. <br />
<ul></ul><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEivKXkzIRq_NfeJjmfkoUR17GTBkG63q965fW40mBAI-tLc0Oyi0uw9K-rwxk7wUcpr_BN124ZDrBROaKwvw2S8DpqI5ID3tvntAHzoAQezsZGcEaNNxyEeHLtb7elIvLcTZESLRe4buRc/s1600/StepReturn.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEivKXkzIRq_NfeJjmfkoUR17GTBkG63q965fW40mBAI-tLc0Oyi0uw9K-rwxk7wUcpr_BN124ZDrBROaKwvw2S8DpqI5ID3tvntAHzoAQezsZGcEaNNxyEeHLtb7elIvLcTZESLRe4buRc/s1600/StepReturn.png" /></a></div><b>Step return. </b>Se sigue ejecutando hasta que se ejecute un <i>return</i>. Es decir, se ejecuta por completo el método en el que estemos y se pasa a la linea siguiente a la invocación del método. <br />
<ul></ul>Con todo esto, encontrar los defectos que tengamos en el código se hace mucho más fácil. Por supuesto, hay muchas más cosas que decir acerca de la depuración. Todos los que estéis interesados podéis consultar el <a href="http://help.eclipse.org/helios/index.jsp?topic=/org.eclipse.jdt.doc.user/tasks/task-running_and_debugging.htm">manual de Eclipse</a>.<br />
<br />
¿Qué os parece? ¿Pensáis que sabiendo cómo depurar el código programaréis mejor? <br />
<br />
</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com12tag:blogger.com,1999:blog-6075840378860013116.post-52533708748453602492011-03-10T18:03:00.000+01:002011-03-10T18:03:08.161+01:00Puntos clave del tema 2<div dir="ltr" style="text-align: left;" trbidi="on">Estos son los puntos clave del tema 2:<br />
<ul style="text-align: left;"><li>Programación modular</li>
<ul><li>Qué es y para qué sirve un módulo</li>
<li> Creación de módulos</li>
<li>Utilización de módulos</li>
</ul><li><a href="http://download.oracle.com/javase/tutorial/java/package/packages.html">Paquetes</a></li>
<ul><li>Creación de paquetes</li>
<li>Utilización de paquetes</li>
</ul><li>Ocultación de información</li>
<ul><li>Cohesión y acoplamiento</li>
<li><a href="http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html">Modificadores de acceso</a></li>
</ul></ul><br />
</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-78361172327588493222011-03-01T23:55:00.000+01:002011-03-01T23:55:02.153+01:00Trabajar en Eclipse con los proyectos en un lápiz de memoria<div dir="ltr" style="text-align: left;" trbidi="on">Muchas veces nos puede interesar tener nuestros proyectos de Eclipse en un lápiz de memoria y trabajar directamente sobre el lápiz en vez de sobre el disco duro.<br />
<br />
Esto nos puede ser útil para ir de un lado a otro con el código o para evitar perder el trabajo si se va la luz de repente en el aula informática durante un exámen. :)<br />
<br />
No obstante, tener en cuenta que la velocidad de acceso al lápiz de memoria va a ser menor que la de acceso al disco duro y que la probabilidad de que un lápiz de memoria se estropee es mayor que la de un disco duro. Es decir, que hagáis copias se seguridad del contenido del lápiz de memoria de vez en cuando.<br />
<br />
La forma más conveniente de trabajar en Eclipse teniendo los proyectos en un lápiz de memoria es utilizando los <a href="http://help.eclipse.org/helios/index.jsp?topic=/org.eclipse.platform.doc.isv/guide/resInt_workspace.htm">workspaces</a> de eclipse. Un workspace no es más que un directorio que contiene los proyectos, directorios y ficheros que se pueden utilizar en Eclipse.<br />
<br />
Los pasos a seguir son los siguientes:<br />
<br />
1.- Conectar el lápiz de memoria al ordenador.<br />
<br />
2.- Crear un directorio en el lápiz donde se va a localizar el workspace.<br />
<br />
3.- Cambiar el workspace actual por el directorio que hemos creado en el lápiz.<br />
File -> Switch Workspace -> Other...<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhDheU1IEPsnbi8xfPIx6Rp4__Rnrz0sQEkDDm60959mHgXhAeB0nA2nz2WYyXhNGsVTr8vx4ZfF4k1T-13Bd100E68fos362IQViL9VvkEnSaIZ4i7qBVbF78iTmzQA782UObwslViSQ0/s1600/MenuSwitchWorkspace.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="226" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhDheU1IEPsnbi8xfPIx6Rp4__Rnrz0sQEkDDm60959mHgXhAeB0nA2nz2WYyXhNGsVTr8vx4ZfF4k1T-13Bd100E68fos362IQViL9VvkEnSaIZ4i7qBVbF78iTmzQA782UObwslViSQ0/s320/MenuSwitchWorkspace.png" width="320" /></a></div><br />
<br />
4.- Una vez hecho esto, se reiniciará el Eclipse y tendremos el nuevo workspace vacío sobre el que podemos crear nuestros proyectos.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh-E47_y-NkOS3Lt6FE1pYo_T7o216-mKEQZPhSYr_127Esol0UvV-Z4ZPeGze5WlQ8cnodDXH3LbHXUho-6w-iuL1hRkD7I6RZruF6mwcKh1FooHRKehEPfU7xlDPtQvQDheIG49Q5M5Y/s1600/EmptyEclipse.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="247" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh-E47_y-NkOS3Lt6FE1pYo_T7o216-mKEQZPhSYr_127Esol0UvV-Z4ZPeGze5WlQ8cnodDXH3LbHXUho-6w-iuL1hRkD7I6RZruF6mwcKh1FooHRKehEPfU7xlDPtQvQDheIG49Q5M5Y/s320/EmptyEclipse.png" width="320" /></a></div><br />
Por último, recordad que si en cualquier momento queréis saber dónde se encuentran almacenados en el disco duro los ficheros de vuestro proyecto, solo tenéis que ir a las propiedades del proyecto.<br />
Project -> Properties -> Resource -> Location<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjRqkH_YfUPTOu3L3xtGeuX6XjWi1VZKPt5V0zV6nT432kCxIw92th62SPpDyRi5VFBGgPM9sIltnFRdYVEYFKGZigE4AVr9Ct-3Jg7JObAh60GVV4EkOHIwJgdP5kIcjkVGIlGF4NvBWs/s1600/ShowLocation.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="244" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjRqkH_YfUPTOu3L3xtGeuX6XjWi1VZKPt5V0zV6nT432kCxIw92th62SPpDyRi5VFBGgPM9sIltnFRdYVEYFKGZigE4AVr9Ct-3Jg7JObAh60GVV4EkOHIwJgdP5kIcjkVGIlGF4NvBWs/s320/ShowLocation.png" width="320" /></a></div><br />
</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com3tag:blogger.com,1999:blog-6075840378860013116.post-68791243387925588742011-02-24T19:00:00.001+01:002011-02-24T19:00:04.590+01:00Puntos clave del tema 1<div dir="ltr" style="text-align: left;" trbidi="on">Al ir finalizando cada tema de la asignatura de <i>Programación II</i>, enumeraré los puntos principales del mismo, ya estén relacionados con el lenguaje de programación Java o con cualquier otra materia relacionada con la asignatura, y proporcionaré alguna referencia adicional para todo aquel que quiera profundizar en ellos.<br />
<br />
Estos son los puntos clave del tema 1:<br />
<ul style="text-align: left;"><li><a href="http://www.youtube.com/results?search_query=java+clases+y+objetos">Clases y objetos</a></li>
<ul><li><a href="http://www.google.es/search?q=java+diferencia+entre+clases+y+objetos">Diferencia entre clases y objetos</a></li>
<li> Definición de clases: atributos y métodos</li>
<li>Métodos constructores</li>
<li><a href="http://www.developer.com/java/other/article.php/1025601">Atributos y métodos de clase</a></li>
<li>Visibilidad de atributos y métodos</li>
<li>Puntero <i>this</i></li>
<li>Clases de tipos básicos</li>
</ul><li>Uso de la memoria</li>
<ul><li>Manejo de memoria </li>
<li>Paso de parámetros</li>
<li>Igualdad y asignación</li>
</ul><li>Uso de Eclipse para el desarrollo en Java </li>
</ul> ¿Hay alguno de estos puntos que os de más problemas que otros?<br />
<br />
¿Os gustaría que incidiéramos más en alguno de ellos?</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-77438603462963735862011-02-18T17:00:00.076+01:002011-02-18T17:04:21.589+01:00¿Qué tipo de datos elijo?<div dir="ltr" style="text-align: left;" trbidi="on">Java proporciona un conjunto predefinido de tipos de datos para definir variables; elegir un tipo de datos u otro dependerá de distintas cosas tales como qué queremos almacenar en la variable (un número, una letra, etc.), qué valores máximos o mínimos necesito almacenar (en el caso de números) o cualquier otra necesidad específica (ej., que la variable ocupe poco en memoria).<br />
<br />
Otro elemento a tener en cuenta, no a la hora de elegir un tipo de datos sino de usarlo, es el valor por defecto que toman las variables de los tipos de datos predefinidos cuando no son explícitamente inicializados en el código.<br />
<br />
La siguiente tabla muestra los tipos de datos predefinidos de Java junto a su tamaño, su rango de valores y su valor por defecto.<br />
<br />
<table border="1"><tbody>
<tr><td>Tipo de datos</td><td>Tamaño </td><td>Rango</td><td>Valor por defecto</td></tr>
<tr><td>byte </td><td>8 bit </td><td>[128 — 127]</td><td>0</td></tr>
<tr><td>short </td><td>16 bit</td><td>[-32.768 — 32.767]</td><td>0</td></tr>
<tr><td>int </td><td>32 bit</td><td>[-2.147.483.648 — 2.147.483.647]</td><td>0</td></tr>
<tr><td>long </td><td>64 bit</td><td>[-9.223.372.036.854.775.808 — 9.223.372.036.854.775.807]</td><td>0L</td></tr>
<tr><td>float </td><td>32 bit</td><td>[NaN, -∞, -(2-2<sup>-23</sup>)·2<sup>127</sup> — -2<sup>-149</sup>, -0, +0, 2<sup>-149</sup> — (2-2<sup>-23</sup>)·2<sup>127</sup>, +∞]</td><td>0.0f</td></tr>
<tr><td>double </td><td>64 bit</td><td>[NaN, -∞, -(2-2<sup>-52</sup>)·2<sup>1023</sup> — -2<sup>-1074</sup>, -0, +0, 2<sup>-1074</sup> — (2-2<sup>-52</sup>)·2<sup>1023</sup>, +∞]</td><td>0.0d</td></tr>
<tr><td>boolean </td><td>1 bit </td><td>0, 1</td><td>false</td></tr>
<tr><td>char </td><td>16 bit</td><td>['\u0000' — '\uffff']</td><td>'\u0000'</td></tr>
</tbody></table><br />
Fuente: <a href="http://www.blogger.com/%20http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html">Java Tutorials</a></div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0tag:blogger.com,1999:blog-6075840378860013116.post-41359677935225102132011-02-11T17:30:00.000+01:002011-02-11T17:30:41.732+01:00Complejidad del algoritmo de búsqueda binaria<div dir="ltr" style="text-align: left;" trbidi="on">Para buscar un elemento dentro de un <a href="http://es.wikipedia.org/wiki/Vector_%28programaci%C3%B3n%29">vector</a> (<i>array</i>) hay que recorrer dicho vector, elemento a elemento, hasta encontrar el elemento en cuestión o hasta que se acabe el vector.<br />
<span id="goog_286149378"></span><span id="goog_286149379"></span><a href="http://www.blogger.com/"></a><br />
La <a href="http://es.wikipedia.org/wiki/Complejidad_computacional">complejidad</a> de los algoritmos se calcula teniendo en cuenta el peor caso posible. Para el caso de una búsqueda en un vector de tamaño <i>n</i>, el peor caso es que el elemento no se encuentre en el vector, con lo que habría que recorrer los n elementos del vector antes de poder decir que el elemento no se encuentra en el mismo. A la complejidad de esta operación se la denomina de orden lineal (O(n)).<br />
<br />
El algoritmo de <a href="http://es.wikipedia.org/wiki/Algoritmo_de_b%C3%BAsqueda">búsqueda binaria</a> (o búsqueda dicotómica) es un algoritmo de búsqueda en vectores ordenados que permite disminuir la complejidad de la búsqueda en dichos vectores.<br />
<br />
La intuición detrás de la búsqueda binaria es la misma que cuando se busca en un diccionario; cuando se va a buscar una palabra que empieza por la letra "s", nadie comienza a leerse las palabras que empiezan por la "a", luego la "b", y así en adelante. Normalmente, se abre el diccionario por la mitad y, dependiendo de si la letra inicial por la que hemos abierto es mayor o menor que la que buscamos, descartamos la mitad de las palabras de la enciclopedia y ya solo buscamos en la mitad restante.<br />
<br />
El pseudocódigo del algoritmo de búsqueda binaria se puede encontrar, por ejemplo, <a href="http://es.wikipedia.org/wiki/Algoritmo_de_b%C3%BAsqueda">aquí</a>. El algoritmo consiste en mantener unos índices que marcan los límites superior e inferior de la parte del vector que nos queda por analizar.<br />
<br />
Para calcular la complejidad de este algoritmo, inicialmente en número de elementos por analizar es n. Tras la primera división, el número será como mucho n/2 (pues nos hemos quedado con la mitad de elementos); tras la segunda división, el número será como mucho n/4; y así sucesivamente. Por lo general, tras la división número i, el número de elementos por analizar será como mucho:<br />
<div style="background:white">\[\frac{n}{2^i}\]<br />
</div><br />
El peor caso se da cuando el elemento a buscar no se encuentra en el vector (es decir, cuando tras dividir los elementos por analizar nos quedemos con un número menor a 1). Por lo tanto, el número máximo de llamadas a realizar es el menor número <i>m</i> tal que:<br />
<div style="background:white">\[\frac{n}{2^m} < 1\]
</div><br />
<br />
Transformando esta fórmula a un <a href="http://es.wikipedia.org/wiki/Logaritmo">logaritmo</a> en base 2, tenemos que:<br />
<div style="background:white">\[n < 2^m\]
</div><br />
y que<br />
<div style="background:white">\[\log n < m\]
</div><br />
es decir, que el número m depende, no del tamaño n del vector, sino del logaritmo de dicho n.<br />
<br />
Es por esto que el algoritmo de búsqueda binaria tiene una complejidad de orden logarítmico (O(log n)).<br />
<br />
<b>Referencia:</b><br />
<br />
Michael T. Goodrich y Roberto Tamassia. <a href="http://eu.wiley.com/WileyCDA/WileyTitle/productCd-EHEP001602.html">Data Structures and Algorithms in Java, Fifth edition</a>. John Wiley & Sons. 2011.</div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com10tag:blogger.com,1999:blog-6075840378860013116.post-14564951274190225662011-02-11T16:39:00.000+01:002011-02-11T16:39:25.534+01:00¡Bienvenidos!<div dir="ltr" style="text-align: left;" trbidi="on">Al acabar la clase de hoy unos alumnos se me han acercado y me han hecho una pregunta que, por un lado, se salía un poco del temario de la lección y, por otro, requería una explicación un poco más larga que un simple (y posiblemente indescifrable) "O(log n)".<br />
<br />
Por ello me he animado a iniciar este blog para incluir cosas fuera de temario, cosas curiosas, resoluciones de dudas o simplemente anécdotas sobre el mundo de la programación.<br />
<br />
Espero que el blog facilite la comunicación con los alumnos de mi grupo y que les sea útil a ellos, al resto de grupos de la asignatura y a cualquiera interesado en el mundo de la programación.<br />
<br />
No espero escribir muy frecuentemente en el blog, dependerá de los tópicos que vayan surgiendo. No obstante, estoy abierto a peticiones de la audiencia. :) </div>Raúl García Castrohttp://www.blogger.com/profile/03203416419489855017noreply@blogger.com0