etiquetas: , ,

¿Cómo buscar libros en internet? Consejos para un autodidacta


Ya sea porque se está asistiendo a un curso o estudiando algún tema de forma autodidacta, el tener acceso a una literatura especializada es por norma general un gran plus. ¿Quieres aprender algo muy específico y no sabes por donde comenzar a buscar? Entonces que aproveche, porque en esta entrada te voy a dar algunos consejos que te darán acceso a una ridícula cantidad de información sobre casi cualquier cosa que puedas imaginar, información valiosa en la forma de libro electrónico, los famosos ebooks, libros que muy probablemente, de otra forma, jamás llegarías a saber de su existencia.

La primera recomendación, y probablemente la más obvia es: ¡Aprende Idiomas! Sobre todo Inglés. No es necesario detallar en esto, la mayoría de los libros están en inglés, y muchos textos interesantes no salen de su idioma natal. Pero no perdamos el norte, volverse unos poliglotas sólo nos retrasaría en nuestro verdadero objetivo, con ser capaz de comprender textos que no están en castellano es más que suficiente. Un uso prudente de Google Translate ayuda bastante y poco a poco le irás sacando las rueditas a la bicicleta.

La segunda recomendación es justo el meollo de esta entrada: Instala alguna distribución de Linux: ubuntu, debian, la que tu querai, da lo mismo. Luego instala aMule.
Linux es por un tema de seguridad, la prevalencia de virus en el pinguino es ridiculamente más baja con respecto a su homólogo de Microsoft, y aMule por un tema de comodidad. Es que si te vas a dedicar a buscar, por ejemplo, "libros, mecánica cuántica" o "quantum mechanics, books" en Google, te van a salir raíces en el culo pinchando links inútiles. No señor, usted es una persona práctica, no quiere perder el tiempo como idiota, usted quiere información ahora ya!

El tema de aMule, Linux y los virus van de la mano. Recuerda que el primero es un programa P2P que, como dice el nombre, te permite compartir archivos entre pares. Si naciste antes del año 1995 probablemente recordarás con lucidez programas como eMule, Ares, KaZaA, Limewire, SoulSeek, entre muchos otros programas P2P que funcionaban bajo Windows, y probablemente recuerdes más de alguna ocasión en que transformaste en una tostadora el preciado computador de la familia bajando películas piratas, música y juegos, entre muchas otras cosas Porno cof, cof!

—¡Ooohhh el viejo emule loco!; ¡Ohhh la weá vieja hermano!; ¿Aún funciona esa weá?

¡Exactamente ctm! Aún vive, bajo Windows como el eMule de siempre, y bajo Linux como aMule. Son lo mismo y su uso no tiene ninguna ciencia.

La instalación se puede hacer directo desde el centro de software de ubuntu



Cuando realices la primera ejecución, aMule comenzará a descargar las listas de los servidores, despues de eso irás a la siguiente pantalla y eligirás el que más te guste (priorizando ping, cantidad de archivos, número de usuarios, en el orden que quieras)

El tema de la ID baja se soluciona abriendo puertos en el router. Más información aquí.

Ahora, para ejemplificar, haré una búsqueda sobre algo que estoy interesado profundizar, buscaré libros sobre Lógica Matemática.




En lo que escribía esta entrada se descargaron al rededor de 400MB, correspondientes a 48 libros sólo sobre lógica matemática, entre los que se destacan los siguientes.



Estos son libros de excelente calidad que muy probablemente nunca encontraría si los buscase de otra forma. Ahora los puedo cargar en mi tableta para leerlos más cómodamente, los puedo imprimir si tengo tiempo, tinta y papel para la impresora, y ahora conozco los títulos por si quisiera comprarlos en algún futuro en que tenga dinero como para hacerlo.

Obviamente nunca llegaré a leer tanto, pero eso nunca fue el objetivo, lo que realmente importa es que ahora mis posibilidades de elección son mucho más generosas a la que tendría sólo recurriendo a la biblioteca de la Universidad.

¿Simple no?

Pero esta entrada no puede finalizar sin una advertencia: así como puedes encontrar muchas cosas interesantes también ocurrirá que algo de bullshit logre saltar el filtro de un ojo crítico, aún recuerdo aquella ocasión en que mientras descargaba textos de mecánica cuántica un libro de "teología cuántica" se coló entre las descargas.

etiquetas:

Los papeles del destino


Esta es una historia cuyo origen desconozco, me la contaron a mi y yo se las cuento a ustedes.

Se trata de un viejo profesor de matemática al que le llegaron sus últimos días y muere. Entonces, mientras caminaba por el purgatorio, se encuentra con un antiguo colega, un profesor de ingles a quien recordaba por tratarse de la persona más desagradable de la galaxia, no había nadie más en ese lugar. Conversaron un tiempo, hasta que fueron plenamente conscientes de la situación, estaban muertos, por lo que deciden ir a buscar juntos las puertas del paraíso, y cuando por fin la encuentran, se topan con un ángel guardián que les pide sus papeles de destino.

—¿Qué son los papeles del destino? —preguntaron.

— Es su pase al cielo o el infierno —contestó el ángel—.
¿No los tienen? Sin ellos estarán destinados a vagar por el purgatorio por toda la eternidad.

Entonces el ángel hace una señal con la mano y un papel aparece junto a una tijera frente a los profesores.

—Como no tienen sus papeles, tienen que fabricarlos. ¿Quién de los dos se hará cargo?

—¿Quieres intentarlo? —Pregunta el profesor de matemática a su colega.

—Esto me parece una estupidez, si quieres hazlo tú.

Entonces el profesor de matemática comienza a mirar atentamente el papel, y luego de un par de minutos pregunta.

— ¿Puedo doblar el papel?

— Si, pero no mas de 4 veces —advierte el ángel.

Así, luego de pensarlo por un momento, realiza la siguiente sucesión de dobleces y corta por la linea AB


Al realizar el corte, unos trozos de papel caen al suelo, frente al profesor de ingles, mientras la parte restante queda en su mano. El ángel estira los trozos de papel y los junta, formándose la siguiente figura:


— Ya veo, así que éste es tu destino.

Acto seguido… ¡Los papeles arden violentamente en llamas y del fuego aparece un vórtice (de donde se escuchan gritos y alaridos) del cual emerge un tentáculo gigante deforme que atrapa al profesor de inglés y se lo lleva antes de que pueda tan siquiera gritar y desaparece.

— Ahora veamos qué dice tu papel —dice el angel mientras camina hacia el profesor de matemática.

— Yo no estoy preocupado, en absoluto, mi destino es seguro —asegura mientras estira el papel que tiene en la mano:


etiquetas: , , ,

Apuntes de Física y Matemática



El objetivo de este texto es el de reunir en un solo documento mis apuntes de forma ordenada, concisa y autocontenida. Se irá actualizando con el tiempo.

Enlace


Si, está altamente incompleto, más desordenado que la mierda y a mi gusto la redacción requiere muchos retoques para que sea algo fácil de entender. Todas esas cosas las iré arreglando con el tiempo.

Se agradecen críticas, correcciones y observaciones.
etiquetas: , ,

Juegos multidimensionales



El Cubo Rubik


Estos son simuladores de cubos rubik en 4 y 5 dimensiones que se pueden descargar gratuitamente



>Cubo Rubik en 4D
>Cubo Rubik en 5D


Adanaxis


Este es un juego de código abierto para linux que trata sobre batallas de naves espaciales en 4 dimensiones.

Se puede instalar buscando directamente en el centro de software de ubuntu, o escribiendo en una terminal:

sudo apt-get install adanaxisgpl


etiquetas: , ,

Aprendiendo C++ [Parte 3: Variables de Punto Flotante y Moldeamiento Numérico - El método de Euler para Resolver Ecuaciones Diferenciales Ordinarias ]



En esta entrada vamos a introducir las variables de punto flotante y escribiremos un programa que realizará un modelamiento numérico del proceso de decaimiento radiactivo.

Como sabemos, el proceso de decaimiento radiactivo se modela a través de la ecuación diferencial ordinaria con valor inicial

(1)$\hspace{1cm}$$\dfrac{d}{dt}m(t) = -km(t),$

(2)$\hspace{1cm}$$m(0) = m_0,$

donde $m(t)$ es la cantidad de materia en cada instante de tiempo $t$, $k>0$ es la constante de decaimiento y $m_0$ es la masa inicial del sistema.

Para resolver este problema utilizaremos el enfoque numérico entregado por el método de Euler.

También veremos el uso de un nuevo archivo de cabecera, fstream, el cual nos permitirá abrir, crear, escribir y leer ficheros con datos.

Finalmente, presentaremos los datos que entrega el programa a través de un gráfico con gnuplot.


El método de Euler

En general, el método de Euler está pensado para resolver una ecuación diferencial ordinaria de primer orden de la forma

(3)$\hspace{1cm}$ $\dfrac{dy(t)}{dt} = f(x,t),$

(4)$\hspace{1cm}$ $y(0) = y_0,$

Ahora, por la definición de derivada tenemos que

(5)$\hspace{1cm}$ $\displaystyle \dfrac{dy(t)}{dt} = \lim_{h\to 0} \dfrac{y(t+h) - y(t)}{h}$

por lo que, para valores pequeños de $h$, a partir de las expresiones (3) y (5) podemos escribir


(6)$\hspace{1cm}$ $\displaystyle \dfrac{y(t+h) - y(t)}{h} \approx f(x,t)$

de modo que ahora el sistema (3)-(4) ahora puede ser escrito como

(7)$\hspace{1cm}$ $y(0)=f(x,0)=y_0$

(8)$\hspace{1cm}$ $y(t+h) \approx y(t) + h f(x,t)$

De aquí tenemos que, si tomamos $t=0$, de las ecuaciones (7) y (8) llegaremos a que

(9)$\hspace{1cm}$ $y(h) \approx y(0) + h f(x,0)$

Luego, de (8) y (9)

(10)$\hspace{1cm}$ $y(2h) = y(h+h) \approx y(h) + h f(x,h)$

De (8) y (10)

(11)$\hspace{1cm}$ $y(3h) \approx y(2h) + h f(x,2h)$

y así sucesivamente.


De aqui tenemos que las expresiones entre (9) y (11) (ambas incluidas) muestran un proceso inductivo que puede ser generalizado mediante la fórmula

(12)$\hspace{1cm}$ $y( (i+1) h) \approx y(ih) + h f(x,ih)$

donde $i=1,2,3,\cdots$


Implementación


Si regresamos a la expresión (5), podemos ver que se puede escribir

(13)$\hspace{1cm}$ $h=t_f - t_0$
(14)$\hspace{1cm}$ $t_f =t_0 + h$

donde ahora es más claro cómo $h$ representa la longitud de tiempo del intervalo $[t_i, t_f]$ (tiempo inicial y tiempo final). Ahora, supongamos que dividimos ese intervalo en $n$ trozos tal y como se muestra en el siguiente esquema



y ahora aplicamos el método de Euler para cada trozo de tiempo $dt$ obtenido.

(15)$\hspace{1cm}$ $t_i = 0$ (instante inicial)
(16)$\hspace{1cm}$ $t_f =$ Tiempo de observación
(17)$\hspace{1cm}$ $n=$ Número de particiones
(18)$\hspace{1cm}$ $dt=t_f/n$ (tamaño de las particiones)
(19)$\hspace{1cm}$ $\underbrace{y( (i+1)dt )}_{y[i+1]} = \underbrace{y(idt)}_{y[i]} + f(x,idt)dt$ (método de Euler)

Esto es lo que finalmente escribiremos en la forma de código.

Escribiendo el código


Partiremos creando el fichero decaimiento.c

$ pico decaimiento.c

Como siempre, la escritura de nuestro código parte con la estructura básica
#include<iostream>
#include<fstream>

using namespace std;

main(){

}
La novedad con respecto a nuestro código anterior aquí es la linea #include<fstream>. Esto nos permitirá utiliza comandos ofstream que necesitaremos en esta ocasión. Como se mencionó anteriormente, fstream es un archivo de cabecera que agrega las funcionalidades de abrir/crear y escribir/leer ficheros con datos. Finalmente, la linea using namespace std; nos permitirá ahorrarnos muchos "std::" en el código.

Lo siguiente será la declaración de las variables que serán utilizadas
#include<iostream>
#include<fstream>

using namespace std;

main(){
unsigned short int n, i=-1;
float ti=0, tf, dt, k=1;

}

Como se vió en la entrada anterior, la linea unsigned short int n, i=-1; reserva memoria para las variables n e i para guardar valores positivos. La linea float ti=0, tf, dt, k=1; introduce las variables que pueden asumir valores de punto flotante o decimales (como 0.5, etc...).

Las variables de punto flotante de C++ son:

float: 4 bytes de memoria. Permite valores entre $- 3,4\cdot 10^{38}$ y $3,4\cdot 10^{38}$, con hasta 6 decimales. También admite enteros

double: 8 bytes de memoria. Permite valores entre $- 1,79\cdot 10^{308}$ y $1,79\cdot 10^{308}$, con hasta 14 decimales. También admite enteros

Esto puede variar según la máquina.

El resto del código toma la siguiente forma:
#include<iostream>
#include<fstream>

using namespace std;

main(){
unsigned short int n, i=-1;
float ti=0, tf, dt, k=1;

 cout<<"ingresa el numero de iteraciones"<<endl;
 cin>>n;
 cout<<"ingrese el tiempo de observación"<<endl;
 cin>>tf;

 dt=tf/n;

float m[n]; 

 cout<<"ingrese la masa inicial"<<endl;
 cin>>m[0];

ofstream datnuout("datnu");

do{i=i+1; 
   datnuout<<ti<< "          ";
   datnuout<<m[i]<<endl;

   m[i+1]=m[i] - k*m[i]*dt;
   m[i]=m[i+1]; 

   ti=ti+dt;

   }while(i<=n-1);
datnuout.close();
}

Descargas: Código Limpio - Código con comentarios

Aquí hay algunas cosas nuevas (con respecto a las entradas anteriores) que merecen ser explicadas.

La linea float m[n]; introduce a la variable m como un arreglo de números de punto flotante que puede guardar $n$ valores (el $n$ es entregado por el usuario durante la ejecución del programa)

$m[n] = [\underbrace{m(1), m(2), \cdots, m(n)}_{n\;valores}]$

La linea ofstream datnuout("datnu"); crea/abre un fichero de nombre "datnu", en el que podemos escribir datos usando la sentencia "datnuout".

La parte del código
datnuout<<ti<< "          ";
datnuout<<m[i]<<endl;
escribe en el fichero "datnu" el dato ti, seguido de un espacio, luego escribe el dato m[i] y finalmente hace un salto de linea. Esto es un par "(tiempo, masa)".

El método de Euler propiamente tal, está dado por

   m[i+1]=m[i] - k*m[i]*dt;
   m[i]=m[i+1]; 

   ti=ti+dt;

La linea datnuout.close(); cierra el fichero "datnu"

Finalmente, guardamos (Crtl+O) y compilamos
$ c++ decaimiento.c -o decaimiento

Si todo ha salido bien, al ejecutar el programa se nos debería generar el fichero "datnu" con los datos que reflejan el resultado del problema.


Si ahora escribimos en la terminal
$ pico datnu
veremos lo siguiente:


Representación gráfica de los resultados


En caso de no tener gnuplot instalado en el sistema, en ubuntu la solución es simple. Lo puedes instalar escribiendo
$ sudo apt-get install gnuplot 
Para iniciar gnplot basta con escribir
$ gnuplot 

Ahora le pediremos que nos grafique los datos del fichero "datnu" y la solución analítica del problema para comparar, escribimos
gnuplot> plot "datnu", 90*exp(-x)
y obtendremos el siguiente gráfico


Mientras más iteraciones, mejor será el ajuste entregado por el programa.
etiquetas: , ,

Aprendiendo C++ [Parte 2: Variables Enteras y Ciclos do-while - La Sucesión de Fribonacci ]

Una de las razones por las que es bueno aprender a programar es porque con eso ganas el control sobre un esclavo que hará exactamente lo que tu le digas, tantas veces como se lo pidas. El computador puede realizar una tarea millones de veces sin cansarse, y cada repetición será igual a la primera. Sin embargo, el mundo no es tan perfecto, este esclavo carece de la capacidad de pensar y hará literalmente lo que tu le digas (lo cual no es necesariamente lo que tu quieres decir), similar a la leyenda del Golem de Praga.

A continuación ahondaremos un poco más en el lenguaje de C++ para realizar ciertos trabajo matemático muchas veces, por lo que introduciremos los conceptos de variable entera y los ciclos do-while de C++.

La Sucesión de Fribonacci

La sucesión de Fribonacci es la sucesión dada por los números 1, 1, 2, 3, 5, 8, 13..., donde cada número es la suma de los dos anteriores. Lo que queremos hacer es escribir un programa que nos proporcione los n primeros números de esta serie, donde n es cualquier numero natural positivo que nosotros le entreguemos al programa.

Lo que debemos hacer, antes de tirarnos de cabeza a escribir el código, es razonar un poco sobre cómo se construye la sucesión de Fribonacci. Notamos que tenemos dos valores iniciales, los dos primeros 1's, luego tenemos que el tercero es 1+1=2 y los siguientes son 1+2=3, 2+3=5, etc... Si colocamos esto en una recta y les asignamos variables, podemos armar el siguiente esquema



Con este esquema ya tenemos una idea de lo que queremos que el programa haga, ahora toca escribir el código. Creamos un programa llamado fribonacci.c

$ pico fribonacci.c

y dentro de él comenzamos escribiendo la estructura básica de todo programa escrito en C++

#include
main(){
}

Tenemos un proceso que queremos que se repita n veces, que es el de sumar tal y como se muestra en el esquema anterior. Para indicarle al programa que queremos repetir algo n veces usamos un ciclo do-while. Esto se hace agregando el siguiente código dentro del main

#include<iostream>
main(){
  int i=0,n;
  std:: cin>>n;
  do{i=i+1;
  }while(i<=n);
}

Aquí aparecieron cosas nuevas que explicaré ahora mismo:

La linea int i=0,n; le dice al programa que las letras n e i serán variables que asumen valores enteros. Nótese que es posible dar un valor a las variables justo cuando son declaradas, en este caso, se hizo i=0 y n se declaró como variable entera sin asignarle ningún valor. Cuando declaramos variables, lo que en el fondo hacemos es reservar algo de memoria para guardar información en ella.

La linea std::cin>>n indica al programa que solicite al usuario que le asigne un valor a n. Como éste es declarado como un entero en el programa, si el usuario proporciona algo que no sea un número entero hará que el programa no entregue resultados coherentes.

El ciclo do-while viene dado por do{i=i+1; }while(i<=n);. Lo que hace esto es tomar el valor inicial de i (i=0 en nuestro caso) e incrementarlo en 1, si nuevo valor de i es menor que el n entregado por el usuario, entonces se repite la operación. Esto lo hará siempre que se cumpla la relación i≤n,, cuando esto ya no ocurra, el ciclo do-while finalizará. Notemos que cualquier procedimiento que coloquemos dentro del ciclo do-while se repetirá n veces.

Ahora, dentro del ciclo do-while introducimos las instrucciones para generar la sucesión de Fribonacci sugerido por el esquema de más arriba

#include<iostream>
main(){
int i=0,n, a=1, b=0, c;
std:: cin>>n;
do{i=i+1;
   c=a+b;
   a=b;
   b=c;
   std::cout << c << std::endl;
   }while(i<=n);
}

Para concluir la redacción del programa, podemos agregar algunos "adornos" al código para hacerlo más fácil de entender durante la ejecución:

#include<iostream>
main(){
int i=0,n, a=1, b=0, c;
std::cout << "ingresa el número de iteraciones" << std::endl;
std:: cin>>n;

std::cout << "los primeros "<< n <<" términos de la sucesión de fribonaci son" << std::endl;
do{i=i+1;    
   c=a+b;
   a=b;
   b=c;
   std::cout << c << std::endl;
   }while(i<=n);
}

Ahora guardamos (Ctrl+O), salimos del editor de texto (Ctrl+X), compilamos y ejecutamos

$ c++ fribonacci.c -o fribonacci
$ ./fribonacci

El resultado debería ser el siguiente:
 

En los siguientes enlaces puedes encontrar el código fuente con comentarios y el código fuente limpio.

Tipos de variables enteras y sus propiedades

Si comenzamos a hacer pruebas el programa que hemos escrito no tardaremos en toparnos con algo extraño. Si le proporcionamos, por ejemplo, un n=50, entonces veremos algunos resultados algo extraños:



Lo que ha pasado aquí es que el tamaño de los números de la serie de Fribonacci se han hecho tan grandes que han superado el espacio de memoria disponible para una variable de tipo entero (int), es por eso que, a partir de cierto punto, los resultados entregador por el programa comienzan a perder todo sentido; vale la pena, por lo tanto, detenernos un momento a revisar los tipos de variables enteras y sus propiedades.

En C++ podemos encontrar los siguientes tipos de variables de tipo entero, donde cada una destina una cantidad de memoria determinada, estas son:

unsigned short int
Normalmente usa 2 bytes de memoria, permite valores entre 0 y 65.535

short int
Normalmente usa 2 bytes de memoria, permite valores entre -32.768 y 32.767

unsigned long int
Normalmente usa 4 bytes de memoria, permite valores entre 0 y 4.294.967.295

long int
Normalmente usa 4 bytes de memoria, permite valores entre -2.147.483.648 y 2.147.483.647

int (16 bits)
Normalmente usa 2 bytes de memoria, permite valores entre -32.768 y 32.767

int (32 bits)
Normalmente usa 4 bytes de memoria, permite valores entre -2.147.483.648 y 2.147.483.647

unsigned int (16 bits)
Normalmente usa 2 bytes de memoria, permite valores entre 0 y 65.535

unsigned int (32 bits)
Normalmente usa 2 bytes de memoria, permite valores entre 0 y 4.294.967.295

El tamaño de las variables en memoria puede variara de un PC a otro.

Formas adecuadas de definir las variables permite un mejor uso de la memoria, por ejemplo, como el programa fribonacci sólo utiliza enteros positivos, es buena idea declarar las variables como unsigned int, de este modo, la memoria reservada para los enteros negativos que implementa int puede ser aprovechada para obtener algunos cuantos términos adicionales de la sucesión de Fribonacci. Sin embargo, y como ha ocurrido aquí, el hecho de haber usado int nos ha permitido detectar fácilmente que un error estaba ocurriendo, ya que para el programador es más fácil notar cuando aparecen números negativos en la serie que cuando un grupo de enteros positivos dejan de pertenecer a la serie (sobre todo cuando estos son muy grandes). Aquí cada quien es libre de decidir qué priorizar. Es importante ser consciente de los límites de cada aspecto del programa para evitar esta clase de problemas.

Dejaremos esto hasta aquí por ahora.
etiquetas: , ,

Aprendiendo C++ [Parte 1: Introducción, consejos para comenzar a programar y un "Hola Mundo" ]


El día de hoy me he propuesto aprender a programar, y a programar bien, y el lenguaje que he elegido es C++. Lo elegí por la sencilla razón de ser bastante usado y por ser un lenguaje multiparadigma.

Algo que he aprendido en mi poca experiencia en programación (principalmente en Fortran) es que los textos nunca son de ayuda cuando uno comienza a aprender a programar. Uno tiende a buscar textos para aprender, los lee y simplemente pierde el tiempo. Nadie aprende a andar en bicicleta leyendo un tratado sobre cómo andar en bicicleta y lo mismo ocurre con la programación. Sin embargo, con esto no pretendo decir que los textos no sirvan para nada, es sólo que su utilidad tiende a verse mal enfocada; en mi opinión, los textos generalmente sirven como material de consulta, como algo que recién comienzas a utilizar cuando ya tienes un conocimiento básico y quieres profundizar sobre algo específico o quieres resolver una duda en particular.

En esta entrada (y posteriores) no pretendo "dar lecciones como un experto", si no mas bien dejar mis experiencias como alguien que está aprendiendo algo nuevo, un material que me sirva de ayuda-memoria o que sirva de guía para los que saben menos que yo (que en este momento es casi nada).

Consejos de un novato

Como dije anteriormente, nadie aprende a programar leyendo un texto sobre programación, eso no sirve. Si existe algo que se pueda denominar como el mejor método para aprender a programar, yo lo describiría en los siguientes puntos:

  1. Sigue a un Guia: Busca a alguien que sepa más que tu y que deje huellas que puedas seguir mientras camina en frente de ti. Esto es más fácil de encontrar de lo que parece, incluso si eres un antisocial de mierda como yo; en YouTube, por ejemplo, hay bastantes canales de personas que hacen vídeos enseñando a programar, mostrando cómo escribir un código; incluso yo hago algo parecido justo ahora lo poco que se.
  2. Comenta los códigos: Ya sean tus propios códigos como los escritos por otras personas. En tus primeros códigos es muy recomendable comentar todo lo que no sepas en ese momento porque así recordarás con mayor facilidad el funcionamiento de cada cosa y podrás entender fácilmente tus códigos cuando los veas en el futuro. En C++ los comentarios van entre "/*" y "*/". También es recomendable descargar códigos de otras personas (sobre todo si se trata de un programa que no has logrado programar por tu propia cuenta) y comentar todas las cosas para explicar lo que en una primera lectura no era evidente, esto te ayudará a comprender el funcionamiento de nuevos comandos y técnicas de programación y es justo aquí donde comienza a tomar relevancia la literatura como material de consulta.
  3. Del Código a la Literatura, nunca de la Literatura al Código: Esto es más o menos lo que explicaba antes. Es una perdida de tiempo consultar la literatura antes siguiera de saber qué demonios vas a programar. Esto sólo te ayudaría si tienes una capacidad de retención impresionante que bordea lo sobrehumano, y eso es algo que escapa a casi todo el mundo. Personas normales como tu o como yo tendemos a retener lo que aprendemos en la medida que lo vamos usando para algo, es por eso que debes comenzar primero visualizando un problema para luego intentar escribir un código (o revisar un código escrito por otra persona) que lo resuelva, y entonces a partir de ahí ir consultando en la literatura (si es necesario) para resolver las dudas. La satisfacción de compilar y correr tus propios códigos, y que estos funcionen, es estímulo suficiente para que lo usado se convierta en conocimiento duradero.

Primeros pasos

Ahora a lo que vamos, que es a programar. En este apartado voy a explicar lo más básico sobre cómo escribir un primer código en C++ y dejaré un enlace para descargar el código fuente de un "hola mundo", pero primero un par de especificaciones sobre el entorno en que voy a trabajar:

CPU: Intel(R) Core(TM) i52430M CPU @ 2.40GHz
Memoria: 4 GB
Plataforma: x86_64
SO: Linux - Ubuntu 14.04

PASO 1: Define tu espacio de trabajo

Esto es elemental. Si no quieres tener tus programas regados por todos lados, crea un directorio donde guardarás todos tus programas, y crea subdirectorios para organizarlos mejor si es necesario, la idea es que luego sean fáciles de encontrar. Abre una terminal y usa los comandos cd y mkdir nombre_de_directorio para moverte al lugar que consideres adecuado y crear el directorio donde guardarás tus programas. A continuación un ejemplo:

$ mkdir Documentos/c++
$ mkdir Documentos/c++/p1
$ cd Documentos/c++/p1/

PASO 2: Programar

Para comenzar a programar abriremos el editor de texto pico, porque me gusta programar con el pico, así que escribimos lo siguiente en la terminal

$ pico hola-mundo.c
Hecho esto, la terminal se convertirá un editor de texto donde escribiremos el siguiente código

#include<iostream>
main(){
std::cout<<"hola mundo"<<std::endl;
}

Los detalles sobre qué significa cada linea los dejo como comentarios en el siguiente código fuente.

Una vez escrito el código, guardamos presionando Ctrl+O, y salimos del editor de texto con Ctrl+X. Finalmente, para compilar escribimos en la terminal:

$ c++ hola-mundo.c

Para que esto funcione, obviamente debes tener instalado el compilador de C++. Si no lo tuvieras, simplemente escribe en la terminal

$ sudo apt-get install build-essential

Luego de compilar el código hacemos un ls en la terminal y veremos que, a parte de nuestro archivo hola-mundo.c ha aparecido un objeto a.out, esto es justo el ejecutable que resulta de compilar código que acabamos de escribir y que podemos echar a correr escribiendo

$ ./a.out

Si quisiéramos darle un nombre diferente al momento de compilar, entonces escribimos, por ejemplo:

$ c++ hola-mundo.c -o hola-mundo

y ahora tenemos un programa llamado "hola-mundo" que podemos echar a correr escribiendo en la terminal

$ ./hola-mundo

El resultado será el siguiente


Para no extender demasiado esta entrada, dejaré esto hasta aquí por ahora. Espero pronto poder publicar un poco más, ya que esto es solo una muy vaga introducción y hay muchas más cosas por hacer.
etiquetas:

Cómo quitar el comando "Atacar" del menú de batalla en RPG Maker MV


Nunca me gustó el Comando "Atacar" de la pantalla de batalla, así que me puse a averiguar sobre cómo quitarlo. Como todo lo que pude encontrar era sobre las versiones anteriores (xp, vx ace, etc.), y yo uso RPG Maker MV, muestro aquí la solución con la que dí luego de escudriñar un poco entre el código que, como sabrán, ya no está escrito en Ruby, si no que en JavaScript.

En realidad la cosa no es nada complicada, simplemente abrimos en un block de notas el archivo

rpg_windows.js

ubicado en la carpeta js del juego y buscamos las siguientes líneas de código

Window_ActorCommand.prototype.makeCommandList = function() {
    if (this._actor) {
        this.addAttackCommand();
        this.addSkillCommands();
        this.addGuardCommand();
        this.addItemCommand();
    }
};

Aquí solo debemos comentar lo marcado en negrita, obteniendo

Window_ActorCommand.prototype.makeCommandList = function() {
    if (this._actor) {
        /**this.addAttackCommand();*/
        this.addSkillCommands();
        this.addGuardCommand();
        this.addItemCommand();
    }

};

Finalmente guardamos los cambios, y listo.

Puedes borrar la línea comentada si quieres hacer este cambio de forma definitiva, pero es recomendable dejarlo como comentario por si cambias de parecer en algún futuro, después de todo los cambios los puedes revertir simplemente quitando el comentario.


Antes


Después