Como estudiante de Ingeniería en Sistema Computacionales he encontrado una gran pasión por el tema de Algoritmos Evolutivos, hace poco tiempo leí una serie de libros relacionados con el tema y tomé nota de esas lecturas. Aquí les presento esas notas con referencias completas de los libros consultados, en esta ocasión el post es enfocado al paradigma más conocido dentro de los algoritmos evolutivos: Algoritmo Genéticos.

Introducción

Durante los últimos treinta años ha crecido el interés en sistemas basados en los principios de la evolución y herencia naturales, para resolver cierto tipo de problemas, dichos sistemas mantienen una población de soluciones potenciales, tienen algún proceso de selección basado en la aptitud de los individuos y algunos operadores “genéticos”. Las Estrategias Evolutivas son un tipo de esos sistemas i.e., algoritmos que imitan los principios de evolución natural para problemas de optimización por parámetros. La programación evolutiva de Fogel es una técnica por búsqueda a través de un espacio de pequeñas máquinas de estados finitos. Otro tipo de sistemas basados en la evolución natural son los Algoritmos Genéticos de Hollman. En 1990 Koza propusó otro tipo de sistemas, la Programación Genética, para buscar el programa computacional más apto para resolver un problema en particular. [1, pp. 1].

Orígenes

Los algoritmos genéticos son una técnica de búsqueda y optimización basada en los principios de la genética y la selección natural.Un algoritmo genético mantiene una población de varios individuos que evolucionan a un estado, bajo reglas especificadas, para maximizar la “aptitud” (i.e., maximizar el costo de una función). [2]Los algoritmos genéticos únicamente maximizan, pero la minimización puede realizarse fácilmente utilizando el recíproco de la función maximizante (debe cuidarse, por supuesto, que el recíproco de la función no genere una división por cero) ,i.e. si el problema es minimizar una función f esto es equivalente a maximizar una función g donde g = -f:

Una definición bastante completa de un algoritmo genético es la propuesta por J. Koza [3, pp. 819]:

Es un algoritmo matemático altamente paralelo que transforma un conjunto de objetos matemáticos individuales con respecto al tiempo usando operaciones modeladas de acuerdo al principio Darwiniano de reproducción y supervivencia del más apto, y tras haberse presentado de forma natural una serie de operaciones genéticas de entre las que destaca la recombinación sexual. Cada uno de estos objetos matemáticos suele ser una cadena de caractéres (letras o números) de longitud fija que se ajusta al modelo de las cadenas de cromosomas, y se les asocia con una cierta funci\’on matem\’atica que refleja su aptitud.

 

Estos algoritmos son muy probablemente los tipo de algoritmos evolutivos más ampliamente conocidos al día de hoy, recibiendo notable atención en todo el mundo. Probablemente el primer predecesor de éstos algoritmos surgió del trabajo de Fraser, un biólogo quien quería simular el proceso de evolución, con especial énfasis en la interacción de la epistasis(Un fenómeno, en el cual, las características de un gen son modificados por uno ó más genes) con selección. Trabajos similares a los de Fraser fueron resumidos por Goldberg [4, pp. 89-103].

Sin embargo, los algoritmos genéticos en su forma usual fueron desarrollados por Holland, científico computólogo y psicólogo de la Universidad de Michigan. En 1975 él resumió su trabajo en “adaptive and reproductive plans” un libro que sirve como el punto inicial de las primeras aplicaciones e implementaciones de algoritmos genéticos [4]. Mientras los biólogos intentaban simular evolución usando algoritmos genéticos, Holland estudiaba como éste tipo de algoritmos podrían ser combinados con problemas que ocurren en campos de aplicación práctica [5, pp. 106-107].

Los AG’s toman prestado cierto vocabulario de la genética. Se habla de individuos (o genotipos) en una población, algunas veces esos individuos son llamados cadenas o cromosomas, esto podría ser un poco confuso, para aclararlo veamos la siguiente explicación:

Cada célula de todo organismo de una especie dada acarrea un cierto número de cromosomas ( el hombre, por ejemplo, tiene 46 de ellos), sin embargo, aquí se hablará de individuos con un solo cromosoma, i.e. cromosomas haploides. Los cromosomas a su vez están formados de genes (también conocidos como características, caracteres ó decodificadores) organizados en sucesión lineal; cada gen controla la herencia de una o más características. Los genes de ciertas características esta colocados en ciertos lugares del cromosoma, a esta posición se le conoce como loci(posición dentro de la cadena).

Cada característica de los individuos (como el color de su cabello) puede manifestarse de diferentes maneras, se dice entonces que el gen puede estar en varios estados, llamados alelos.

Cada genotipo(un único cromosoma) representaría una posible solución a un problema, un proceso de evolución se ejecuta sobre una población de cromosomas correspondientes a una búsqueda a través de un espacio de soluciones potenciales. Por lo que una búsqueda requiere balancear dos objetivos (aparentemente conflictivos): explotar las mejores soluciones y explorar el espacio de búsqueda [6 pp. 61-73].

El Algoritmo Genético Canónico

El AG comienza, como cualquier otra técnica de optimización, definiendo las variables de optimización, la función mediante la cual se evaluarán las variables y el costo. Éste termina también como otros algoritmos de optimización, haciendo pruebas de convergencia. En la fase intermedia, sin embargo, el algoritmo es un poco diferente. En la figura 1 se muestra una ruta a través de los componentes de un algoritmo genético “canónico” o estándar [2, pp. 52].

Estructura general de un algoritmo genético

El siguiente paso es generar una población inicial compuesta por cadenas ó cromosomas de longitud L, generalmente ésta se inicia aleatoriamente, diversas formas de inicializar una población pueden encontrarse en [3]. Cada miembro de dicha población es representado de acuerdo al problema, pero podemos encontrar tres tipos de representaciones comunes [7]:

• Representación Binaria: Cada gen es un valor de 0 ó 1.
• Representación Entera: Cada gen es un valor entero.
• Representación Real: Cada gen es un valor real.

Operadores Genéticos

Después de crear la población inicial, cada cromosoma es evaluado y se le asigna un valor de aptitud. Es importante distinguir entre lo que se conoce como una función de evaluación y una función aptitud; la función de evaluación, o función objetivo, proporciona una medida del desempeño con respecto a un conjunto de parámetros. La función aptitud transforma esa medición en asignación de oportunidades de reproducción para el individuo. La evaluación de una cadena es independiente de la evaluación de cualquier otra cadena. La aptitud, sin embargo, es siempre definida con respecto a otros miembros de la población actual.

Selección

La selección es la etapa del algoritmo genético en la cual individuos o cromosomas se eligen de una población para su posterior reproducción (recombinación y/o cruce).

Fundamentalmente, pueden considerarse 3 esquemas de selección, aunque existe múltiples esquemas distintos a estos, así como innumerables combinaciones de aspectos de estos tres mecanismos fundamentales. A continuación se describe cada uno de ellos:

Ruleta o Seleccion proporcional: Con este método la probabilidad que tiene un cromosoma de reproducirse es proporcional a su valor de función de evaluación, es decir, a su adaptación. Una vez calculadas estas probabilidades, la selección de los individuos para reproducirse es aleatoria según estos valores. El algoritmo propuesto por Goldberg(1989) es el siguiente:

• Construcción de la ruleta: Calcular el valor de aptitud eval(u) para cada cromosoma de la población actual (i=1, … , tamp), donde tamp corresponde al tamaño de la población.
• Calcular el valor total de la aptitud de la población

• Calcular la probabilidad de selección de cada cromosoma 

• La ruleta gira tamp veces, cada vez seleccionamos un cromosoma para una nueva población de la siguiente forma:
• Generar un número aleatorio flotante r del rango [0 ... 1].
• Si   entonces seleccionar el primer cromosoma , en otro caso seleccionar el i-ésimo cromosoma  (2 ≤ i ≤ tamp) tal que

Obviamente con este algoritmo, algunos cromosomas serán elegidos en distintas ocasiones.

Selección por ranking: Desarrollado por Whitley en 1989, el método consiste en calcular las probabilidades de reproducción atendiendo a la ordenación de la población por el valor de aptitud en vez de simplemente el valor de la función, la aptitud esta definida por:, donde   es la evaluación asociada con el cromosoma i , y   es la evaluación promedio de todos los cromosomas en la población [8]. Una vez realizada esta evaluación, se simula un proceso de selección natural, los individuos son acomodados de acuerdo a la función de aptitud, en esta etapa los mejores individuos son elegidos de la población actual y el resto son eliminados. Esta selección natural ocurre cada generación o iteración del algoritmo. La decisión del número de cromosomas elegidos es algo arbitrario, sin embargo, dejando que solo unos pocos cromosomas sobrevivan para la siguiente generación limita los genes disponibles para producir descendientes, almacenando demasiados cromosomas permite que los cromosomas con baja aptitud reproduzcan sus características en la siguiente generación.

Selección por torneo: Un esquema ideal de selección debería ser simple de codificar, y eficiente para arquitecturas paralelas y no paralelas, más aún, un esquema de selección debería ser capaz de ajustar su influencia de selección acorde a su dominio. El uso de selección por torneo ha ido en incremento debido a que satisface los criterios anteriores[9]. La idea es simple, se elige un número de individuos de una población(normalmente 2, torneo binario), se selecciona el mejor individuo de este grupo para un nuevo procesamiento genético, la selección se realiza tantas veces como se desee (por lo general hasta que a partir de ellos, sea posible realizar el proceso de apareamiento). El método puede aplicarse con reemplazo o sin reemplazo, en el primer caso los individuos seleccionados del actual torneo son candidatos para participar en otro torneos, por otro lado en un torneo sin reemplazo los individuos son seleccionados una sola vez.

Una comparación de complejidad entre estos tres esquemas de selección puede verse en [10].

Operador Mutación

El operador de mutación fue introducido por Holland como un operador que ocasionalmente cambia bits individuales de cromosomas invirtiéndolos, la probabilidad de mutación   por bit es muy pequeña en un AG. Algunos valores comúnes son: y . En últimos estudios, algunos investigadores formularon algunas reglas heurísticas indicando que el rendimiento es cada vez mayor tanto para poblaciones grandes (tamp > 200) combinadas con una probabilidad de mutación grande como también para poblaciones de pequeño tamaño combinadas con una probabilidad de mutación pequeña .

Valores pequeños de mutaciones, como Holland indica, garantiza que un individuo producido por mutación no difiera demasiado genéticamente de su antecesor. Esta declaración es cierta para el espacio de genotipos, pero como Bäck señala, solo es compatible con una codificación estándar(binaria) no para una representación con números reales [11].

El gen a mutar es seleccionado aleatoriamente del número total de genes (tamp * L) de la población actual.

Recombinación o Cruce

La recombinación es considerado como el operador más importante de los algoritmos genéticos. La idea es que segmentos útiles de diferentes padres podrían ser combinadas con el fin de dar a un nuevo individuo los beneficios de combinaciones de bits de ambos padres. De esta forma, más y más segmentos de aptitud alta se esperan que emergan, finalmente llegando a una total solución [5, pp. 97-106].

La recombinación es claramente un operador sexual(necesita dos cromosomas o individuos para llevarse a cabo) que con una probabilidad selecciona dos individuos padres de la población, los recombina para formar dos nuevos individuos y descarta uno de los resultantes.

Valores comunes de son los propuestos por De Jong(1975) con   y J.J Grefenstette(1985) con una .

El operador de cruce permite realizar una exploración de toda la información almacenada hasta el momento en la población y combinarla para crear mejores individuos.

El tradicional método de cruce propuesto por Holland se conoce como one-point crossover:

Se elige una posición de cruce 1, … , L-1 dentro de la cadena de bits al azar y se intercambian los bits a la derecha de esa posición entre ambos individuos. Sin embargo, éste método parece ser claramente inferior a los otros métodos con respecto al desempeño de los resultados.

Cruce de n puntos: Es una generalización del método anterior. Se seleccionan varias posiciones (n) en las cadenas de los progenitores y se intercambian los genes a ambos lados de estas posiciones.

Cruce Uniforme: Es radicalmente diferente a la técnica de un punto, cada gen de los descendientes es creado copiando el correspondiente gen de uno o del otro padre, elegido de acuerdo a una máscara de cruce generada aleatoriamente. Cuando existe un 1 en la máscara de cruce, el gen es copiado del primer padre, y cuando la posición de la mascara contiene un 0, el gen es copiado del segundo padre. El proceso es repetido intercambiando a los padres para generar el segundo descendiente. Para cada par de padres se genera una máscara nueva, los descendientes por lo tanto, contienen una mezcla de genes de cada padre. El número de puntos de cruce efectivos no es fijo, pero la media podría ser (donde L) es la longitud de los cromosomas).

Cruce heurístico: Éste operador propuesto por Wright \cite {Wright}, es único debido a las siguientes razones:

1. Utiliza valores de la función objetivo para determinar la dirección de la búsqueda
2. Produce únicamente un descendiente
3. Podría no producir ningún descendiente

El operador genera un descendiente de dos padres  y  de acuerdo siguiente regla:

Donde  r es un número aleatorio entre 0 y 1, y el padre    no es peor que , es decir,   para problemas de minimización.

Es posible que el operador genere un descendiente no viable. En tal caso otro valor aleatorio es generado y otro descendiente creado, si después de w intentos una nueva solución viable no es encontrada, el operador no hace más intentos y no produce ningún descendiente.

Después de que el proceso de selección, mutación y recombinación está completo, la siguiente población puede ser evaluada; este proceso formará una generación o ciclo en la ejecución de un algoritmo genético.

En cuanto el criterio de parada, generalmente viene determinado por criterios a priori sencillos, como un número máximo de generaciones o un tiempo máximo de resolución, o más eficientemente por estrategias relacionadas con indicadores del estado de evolución de la población, como por la pérdida de diversidad dentro de la población o por no haber mejora en un cierto número de iteraciones, siendo por lo general una condición mixta lo más utilizado, es decir, limitar el tiempo de ejecución a un número de iteraciones y tener en cuenta algún indicador del estado de la población para considerar la convergencia antes de alcanzar tal limitación.

Hasta Aqui llega esta breve introducción, esperando a que los aliente a meterse más en este campo, para esto les recomiendo un gran sitio del Dr. Carlos Coello actual investigador del CINVESTAV en el IPN y que resolvió algunas de mis dudas.

De antemano me disculpo si por ahí se me fué alguna expresión mal, es dificil trabajar sin LaTeX directamente. Saludos!!

Bibliografía:

[1] Zbigniew Michalewicz. Genetic algorithms + data structures = evolution programs (3rd ed.).  Springer-Verlag, London, UK, 1996.
[2] Randy L. Haupt and Sue Ellen Haupt. Practical Genetic Algorithms. Wiley-Interscience, 2004.
[3] John R. Koza. Genetic Programming: On the Programming of Computers by Means of Natural Selection (Complex Adaptive Systems). The MIT Press, 1 edition, December 1992.
[4] David E. Goldberg. Genetic Algorithms in Search, Optimization, and Machine Learning. Addison-Wesley Professional, 1 edition, January 1989.
[5] John H. Holland. Adaptation in natural and artificial systems. MIT Press, Cambridge, MA, USA, 1992.
[6] L.B. Booker. Improving Search in Genetic Algorithms. Morgan Kaufmann Publishers, 1987.
[7] Rafael Caballero Fern ́ndez. Algoritmos gen ́ticos para la resoluci ́n de problemas de programación por metas entera. aplicación a la economía de la educación.
[8] Darrell Whitley. A genetic algorithm tutorial. Statistics and Computing, 4(2), June 1994.
[9] Brad L. Miller, Brad L. Miller, David E. Goldberg, and David E. Goldberg. Genetic algorithms, tournament selection, and the effects of noise. Complex Systems, 9, 1995.                                                                                                                                                                                                                [10]Thomas Bäck. Evolutionary Algorithms in Theory and Practice: Evolution Strategies, Evolutionary Programming, Genetic Algorithms. Oxford University Press, 1996.                                                                                                                                                                                                                               [11]Alden H. Wright. Genetic algorithms for real parameter optimization. In Foundations of genetic algorithms. Morgan Kaufmann, San Mateo, CA, 1991.

Para poner estilo a tus proyectos desarrollados en ruby on rails de forma rápida y algo fácil solo necesitas tener ganas y tiempo para hacerlo.

Comencemos creando la estructura de nuestro proyecto con el comando de “rails new nombre_del_proyecto”

Entramos a nuestro proyecto con “cd DragonsCSS “ dentro podemos navegar y ver los archivos que genera automáticamente rails desde el editor que mas les acomode o el que tengan instalado.

" Navengando por nuestro proyecto "

" Vista del archivo q sera el protagonista del tutorial "

Ahora solo basta con crear los controles o paginas de las cuales se compondrá nuestro proyecto con el comando “rails generate controller nombre del control”.

" Generando el Home de nuestro proyecto"

Ahora ejecutamos el servidor que trae por default rails con el comando ” rails s “ y tecleamos en la dirección Url ” http://localhost:3000/ “ o el puerto en el q este corriendo el servidor .

" Lanzando el servidor de rails "

" El servidor de rails activo "

Cuando entremos en el browser y pongamos la dirección del localhost nos mostrara la siguiente pagina.Para que nos muestre directamente nuestro home cuando entremos en esa dirección solo tenemos que borrar el archivo ” index.html ” que se encuentra en la carpeta de public de nuestro proyecto una ves hecho esto solo basta con entrar al archivo de routes.rb que se encuentra en la carpeta config de nuestro proyecto agregando las lineas ( root :to => ‘home#index’ )  ( match ‘home’ => “home#index” ) sin los paréntesis.

" Archivo routes.rb modificado "

Entramos una ves mas al browser y actualizamos con F5 y listo veremos nuestro home muy básico.

" Asi se ve nuestro home "

Ahora viene lo mas interesante poner presentable nuestro proyecto para esto necesitamos descargar el Blueprint (para mayor información checa la documentación ) tambien hara falta un logo para ponerlo en la parte superior de nuestro home puedes usar el que te guste respetando los derechos de autor yo escogi el logo de creative commons. Una ves descargados los archivos descomprimimos el blueprint en nuestro escritorio y copiamos la carpeta blueprint a public/stylesheets y el logo a public/images.

Listo ahora modificaremos el archivo appliation.html.erb cambiando la lineas de stylesheet_link_tag.

" Solo se agrgan las lineas marcadas que son la que indican el uso de los archivos screen y print asi como su ubicacion "

Ahora agreguemos elementos al cuerpo de nuestra aplicación.

" Agregamos una imagen al header y algunos links "

Nota: En la linea de la imagen ” <%= image_tag(“logo.png“, :alt => “Sample App”, :class => “round”) %> ” solo cambiamos el nombre de logo.png por logo_creative_commons.jpg.

Ahora creamos un archivo con el nombre custom.css con el siguiente contenido:

.container {

width: 710px;

}

body {

background: #000;

}

header {

padding-top: 20px;

}

header img {

padding: 1em;

background: #fff;

}

section {

margin-top: 1em;

font-size: 120%;

padding: 20px;

background: #fff;

}

section h1 {

font-size: 200%;

}

/* Links */

a {

color: #09c;

text-decoration: none;

}

a:hover {

color: #069;

text-decoration: underline;

}

a:visited {

color: #069;

}

/* Navigation */

nav {

float: right;

}

nav {

background-color: black;

padding: 0 0.7em;

white-space: nowrap;

}

nav ul {

margin: 0;

padding: 0;

}

nav ul li {

list-style-type: none;

display: inline-block;

padding: 0.8em 0;

}

nav ul li a {

padding: 0 5px;

font-weight: bold;

}

nav ul li a:visited {

color: #09c;

}

nav ul li a:hover {

text-decoration: underline;

}

/* Sign up button */

a.signup_button {

margin-left: auto;

margin-right: auto;

display: block;

text-align: center;

width: 100px;

color: #fff;

background: #006400;

font-size: 150%;

font-weight: bold;

padding: 20px;

}

/* Round corners */

.round {

-moz-border-radius: 10px;

-webkit-border-radius: 10px;

border-radius: 10px;

}

Muy bien ahora basta con separar las partes de tu aplicación en cabeza contenido y pie para esto creamos algunos archivos mas dentro de la carpeta de “layouts”.

Creamos el archivo con el nombre de _stylesheets.html.erb

_stylesheets.html.erb

Ahora creamos el archivo _header.html.erb

_header.html.erb

Y por ultimo creamos el archivo _footer.html.erb

_footer.html.erb

Después de todo esto basta con modificar el archivo application.html.erb

Partial render.

Listo ahora podemos ver el resultado lanzando el servidor de RoR con rails s desde la consola.

Ahora puedes jugar con los colores dentro de tu custom.css que creamos con las dimensiones de las partes de tu aplicación así como toda la apariencia suerte y ha practicar.

Cuando pensamos en programar nos suelen venir a la cabeza ideas como variables, ifs, objetos, funciones, procedimientos, todos esos conceptos presentes en la mayoría de los típicos lenguajes imperativos y que componen la vasta mayoría del software existente hoy en día.

Es bueno, sin embargo, no perder de vista que todo esto son abstracciones más o menos arbitrarias y que puede haber otros enfoques de cómo escribir archivos de texto llenos de código formal que puedan convertirse luego en 1´s y 0´s para que nuestra máquina ejecute las operaciones. Existen muy variados paradigmas de programación, entre los que se encuentra el que nos ocupa en este post: la conocida como programación funcional, que incorpora algunas ideas muy interesantes para todo programador.

Pero….

Qué es la Programación Funcional?

Evaluación de Funciones Matemáticas

Esto es el núcleo detrás de los lenguajes funcionales. En la Programación Orientada a Objetos(POO), tendemos a pensar en funciones como métodos que cambien el estado de nuestros objetos. Ahora, en una función matemática nosotros no realmente tenemos la noción del objeto o incluso ni de su estado. Consideremos una función que calcula la altura de un proyectil con respecto al tiempo:

f(t) = -4.9t² + 19.6t + 3

Con esta función, evaluamos en un valor para t y obtenemos un valor que representa la altura. Aquí no hay un estado que estemos modificando o alterando, hay mucho más alla de este concepto, pero regresaremos a ella más adelante.

Evitar Estados y Datos Mutables

La inmutabilidad de los objetos es central en la programación funcional, en los lenguajes funcionales ,como F#,  no se trabaja con variables. En lugar de ello se trabaja con valores. Las  Variables (como implica su nombre) pueden cambiar, pero los valores permanecen constantes.

La programación funcional, se basa fuertemente en un concepto de función algo diferente al que estamos acostumbrados, más cercano al matemático que su contraparte en los lenguajes imperativos

Trabajemos con un ejemplo para aclarar más el concepto. La función factorial, imperativamente, se definiría como “para calcular el factorial, toma un valor de entrada, réstale uno, asigna este valor a x, calcula el factorial de x, asígnalo a y, y devuelve x por y” . Órdenes, órdenes. En cambio, funcionalmente se definiría como “el factorial de n es n por el factorial de n-1″, mas sencillo,no?.  Es una mera diferencia de abstracción, pero los lenguajes funcionales te fuerzan a pensar en ese alto nivel y no tiene sentido hablar de órdenes.

Básicamente, un programa funcional es aquel que sólo está compuesto de funciones que se limitan a hacer corresponder cada elemento que se le pase como argumento con un valor.

Implementación del algoritmo Quicksort en Haskell

Algunas características típicas

Como consecuencia de todo esto, en los programas funcionales se encuentran algunas características:

• Transparencia referencial. Al no haber variables, no hay efectos laterales, es decir, al ejecutar la función (aunque ya hemos visto que el concepto de ejecutar no existe como tal) no cambiará nada fuera del entorno de ésta. Tampoco dependerá para nada de lo que haya en ese entorno. Se dice que una función tiene transparencia referencial si, para un valor de entrada, produce siempre la misma salida. En programación funcional esto es siempre así por definición.

• Evaluación perezosa (Lazy evaluation). Para una mente acostumbrada a lo imperativo cuesta entender este concepto, así que atención. Al no tener que seguir una serie de órdenes, una tras otra, algunos lenguajes funcionales sólo evalúan lo que les es requerido en cada momento. Esto permite cosas como el código Haskell take 5 [1..], que significa “toma los cinco primeros números de una lista infinita de números empezando por el 1″. En un lenguaje imperativo, esto llevaría a un bucle infinito mientras se genera la lista. En Haskell, sólo se genera lo que se necesita; en este caso, los cinco primeros números. Esto puede redundar en una ejecución más eficiente y un código más claro y cercano al matemático.

• Altísima abstracción. Los lenguajes funcionales implementan muchísimos mecanismos de abstracción que te hacen la vida muy, muy feliz. Un brutal sistema de tipos de datos, polimorfismo en muchos niveles, y un montón de nuevos conceptos como funciones de orden superior, functores, mónadas… Las inevitables operaciones que no son puramente funcionales, como la entrada/salida o los números aleatorios, quedan envueltos en abstracciones que resuelven la papeleta con elegancia.

• Elegancia, legibilidad, flexibilidad. Por lo general, cuanto más abstracto es un lenguaje, más se potencian estas características, por lo que los programas funcionales suelen ser más claros, más concisos y más bellos que sus contrapartidas en lenguajes imperativos (incluso en Python o Ruby).  Además, la ausencia de entorno y de estado permite que, si estás leyendo una función, sólo tengas que retener en tu cabeza esa función, sin preocuparte de más. Esto genera….

• Facilidad para las pruebas y la depuración. Gracias a la transparencia referencial, hacer unit testing en lenguajes imperativos es trivial. Además, el alto nivel hace que los errores lo tengan difícil para esconderse por el código, por lo que suelen salir programas muy fiables.
• Concurrencia. Un programa funcional ésta listo para la concurrencia sin demasiadas modificaciones. Tú no tendrás que preocuparte por los famosos  “deadlock” ya que tu no necesitas usarlos!. Ningún dato es modificado dos veces por el mismo hilo, mucho menos por dos hilos diferentes. Los beneficios no paran aqui. Si tenemos una aplicación que inherentemente es manejable con un solo subproceso el compilador puede optimizar los programas funcionales para que sean ejecutados en múltiples CPU´s. Observemos el siguiente código de ejemplo

String s1 = somewhatLongOperation1();
String s2 = somewhatLongOperation2();
String s3 = concatenate(s1, s2);

En un lenguaje funcional el compilador puede analizar el código, clasificar las funciones que crean las cadena s1 y s2 como operaciones que consumen mucho tiempo y ejecutarlas concurrentemente. Esto en la programación imperativa es imposible de llevar a cabo porque cada función puede modificar  el estado fuera de su alcance y la siguiente función podría depender de ésta.

¿Y por qué no se usa a gran escala?

No todo es tan bonito, claro. En la práctica, existen algunos inconvenientes a tener en cuenta.

• Mayor dificultad inicial. Aunque sean muy fáciles de entender y mantener, suele ser más difícil escribir un programa funcionalmente, sobre todo para mentes acostumbradas a lo imperativo. La gran variedad de conceptos complejos a tener en cuenta hace difícil dominar el lenguaje y producir buen código. La ausencia de variables de estado, aunque nos facilite la vida a posteriori, hace que tengas que comerte más la cabeza al sentarte a picar líneas y planificar muy bien lo que vas a hacer, y esto en entornos de producción puede no ser lo más conveniente. De hecho, esto despierta hasta algunos odios.

• Falta de recursos. Al estar tan poco extendidos, faltan la gran cantidad de recursos (librerías, frameworks, etc.) existentes para otros lenguajes; aunque últimamente, se están volviendo a poner relativamente de moda, cada vez salen más soluciones.

Quiero aprender más…

Como ya se pudieron dar cuenta, este post solo fue una brevísima introducción a la programación funcional, no se hablo de lenguajes, compiladores, interpretes, relacionados con el mundo de la PF, sin embargo, navegando por la red podemos encontrar una gran cantidad de material que nos guiarán a través del mundo de la programación funcional, y a que les dejo un pequeño compendio de referencias que pueden visitar(mismas que utilicé para armar este post).

• Try Haskell, una amena introducción interactiva online que te dejará con ganas de más.
• Learn you a Haskell, uno de los mejores tutoriales de todos los tiempos, extremadamente divertido.
• En Haskell.org tienes infinidad de documentación, incluido el fantástico buscador Hoogle, y una comunidad muy dispuesta a ayudar.
• Página de un profesor de la Universidad Complutense de Madrid
• Charla impartida por John Backus al ser galardonado en 1977 con el premio Turing. Su conferencia Can Programming be Liberated from the Von Neumann Style? A Functional Style and Its Algebra of Programs
• Parte del contenido del Libro:Programming in Haskell
• What is Functional Programming?, un sitio en el que podrás aprender un poco más de la programación funcional
  
• Breve Introducción a Haskell

CKEditor es un editor de texto para ser utilizado dentro de las páginas web. Es un editor WYSIWYG es el acrónimo de What You See Is What You Get (en inglés, “lo que ves es lo que obtienes”) . Reúne las características de edición web común que se encuentran en aplicaciones de edición de escritorio como Microsoft Word y OpenOffice.

Y ahora lo usaremos dentro de Ruby on Rails así como su configuración y aparecía básica.

Empecemos !!!!

1. Para usar CKEditor necesitamos instalarlo para lo cual descargaremos la gema desde http://rubygems.org/gems/ckeditor
2. Ahora instalemos la gema desde la terminal escribimos gem install ckeditor-3.5.2.gem
3. Creemos un proyecto nuevo de rails.
4. Ahora basta con modificar el Gemfile agregando la lineagem ‘ckeditor’ o gem ‘ckeditor’, :git => ‘git://github.com/galetahub/rails-ckeditor.git’, :branch => ‘rails3′
   
5. Para que nuestra aplicación reconosca esta linea usemos el bundle.
6. El siguiente paso es descargar los archivos de base CKEditor y generar el archivo de configuración “config/initializers/ckeditor.rb”
7. Generar los modelos CKEditor para subir ficheros.
8. Ahora hacemos la migración.
9. Listo ahora podemos usar el CKEditor en nuestra aplicación para ello basta con incluirlo en la vista: Primero en el archivo de “/app/views/layouts/application.html.erb” se agraga la linea “<%= javascript_include_tag :ckeditor %>” despues basta con poner la siguiente linea en la vista que se usara el CKEditor : “<%= ckeditor_textarea(“object”, “field”, :width => ’100%’, :height => ’200px’) %>” . Si se utilizara en un formulario la linea es la siguiente : ” <%= form.cktext_area :notes, :toolbar=>’Full’, :width=>’400px’, :height=>’200px’ %> <%= form.cktext_area :content, :swf_params=>{:assetable_type=>’User’, :assetable_id=>current_user.id} %>”
10. Nos deve de quedar algo masomenos asi:
11. Para agregar o quitar opciones de la barra de herramientas del CKEditor simplemente se edita el fichero “public/javascripts/ckeditor/config.js”Good Luck!!

-

Jason Fagone publicó en Wired un interesante y detallado artículo titulado Teen Mathletes Do Battle at Algorithm Olympics sobre la Olimpiada de programación que se celebra desde hace más de veinte años en distintos lugares del mundo, al estilo de las olimpiadas matemáticas, de física y similares: hormonas nerd a tope, vamos. En 2010 tuvo lugar en Canadá y la 23ª edición se celebrará en Tailandia. Este año pasado compitieron 315 participantes de 83 países, en categorías tanto individuales como de equipo.

Una curiosidad de este concurso es que se compite para resolver ocho problemas de programación, pero como son tantos los que encuentran la solución y resuelven los problemas a la perfección (269 de los 315 el año pasado), la competición incluye el «factor tiempo»: quien más rápido entregue los resultados, gana el concurso. Así que ese aspecto no es baladí en este caso.

Entre los problemas del año pasado estaban incluidos:

• Cluedo: Diseñar el código más eficiente para resolver una partida de Cluedo con 6 personajes, 10 lugares y 6 armas. El ganador: 22 líneas en Pascal.
• Lenguajes: Dadas 10.000 cadenas de texto seleccionadas al azar de la Wikipedia, crear un programa que identifique en qué idioma están escritas. El ganador: 227 líneas de código, con una eficiencia del 85 por ciento de aciertos.
• Laberinto: Diseñar un programa que dibuje laberintos de diversos tamaños y grados de complejidad.
• Tráfico: Encontrar el camino más corto en una red de transporte con miles de ciudades conectadas a través de algunos nodos centrales. Es un problema de gran complejidad de esos que sólo suelen resolverse mediante una aproximación a la solución óptima, a menos que el tamaño de la red sea razonable y tengas un superordenador a mano.

Los lenguajes de programación oficiales de la competición son tres: Pascal, C y C++. Los participantes suelen practicar en sitios como TopCoder, así como en las «zonas de práctica» de los equipos regionales. A efectos prácticos, en la competición por 200 euros los chicos pasan una semana en la ciudad donde se celebra la competición oficial, concentrada en dos días de tensión. A los ganadores les pagan el viaje. (Anecdóticamente, respecto al tema chicos-chicas, el lugar resulta ser el un proverbial BDN, con solo un 10-15% de participantes femeninas).

Uno de los detalles que me pareció más curioso –y apropiado– es que hay todo un complejo sistema informático encargado de controlar los tiempos, recibir los programas y ejecutarlos para dar en tiempo real los resultados a los participantes y mostrarlos en un gran panel al público asistente. Dicen que el ambiente para los más geeks y los acompañantes llega a volverse «emocionantemente eléctrico» a medida que pasa el tiempo, una sensación seguramente difícil de describir para los no-iniciados en el mundo de la programación.

Entre las «estrellas» del año pasado estaba Neal Wu del equipo de los Estados Unidos, al que le montaron hasta una página en Facebook a modo de club de fans y Gennady Korotkevich de Bielorrusia, que comenzó a competir con 11 años y que con 15 parece tener Jolt en las venas, chips de Deep Blue por neuronas y concentra su vida en programar, dejando de lado chorradas para nenazas como tener un blog, una cuenta de Twitter o una página en Facebook. Dado que en la rrrussia sssoviética tú no programas el código sino que el código programa tu cerebro, el muchacho arrasó en la competición como era de esperar y se hizo con el primer premio. Pero seguramente mejor premio será que lo fiche alguno de los espónsores que envían «ojeadores» a la olimpiada, como IBM, Amazon, Google, BlackBerry o Lenovo, y le ofrezcan un buen sueldo a cambio de su increíble capacidad para picar código e inventar algoritmos ingeniosos.

Para mas informacion: http://www.ioi2010.org/

Para aquellos que les gusta programar en Java en cualquier momento, aquí les dejo un tutorial sobre como programar en java en tu iPhone ó iPod Touch.

Elementos con los que se realizaron este tutorial.

• iPod Touch 4.
• JailBreak
• Cydia

Bién, vamos a instalar los componentes para poder Crear, Compilar y Ejecutar nuestros archivos .java.

Entramos a Cydia y nos vamos a la opción “Manage”, seleccionamos “Settings” y seleccionamos la opción “Developer (No Filters)”.

Seleccionamos "Settings"

Seleccionamos "Developer (No Filters)"

Ahora nos vamos a la opción “Sections” y buscamos “Java”, una vez dentro instalamos Classpath, JamVM y Jikes.

Seleccionamos "Java"

Instalamos Classpath y JamVM

Instalamos Jikes

Ahora vamos a instalar el iEdit que es el que nos va a servir para crear nuestros archivos desde el iPod/iPhone y también instalaremos MobileTerminal que es donde vamos a ejecutar nuestros programas. Abrimos el “Search” de Cydia y buscamos cada programa y los instalamos.

Programa para crear los archivos .java

Terminal para compilar y ejecutar nuestros programas

Una vez instalado Todo, vamos a entrar al iEdit para empesar a programar.

Cuando abrimos el iEdit nos posiciona en la carpeta Documents de nuestro dispositivo, vamos a crear una carpeta llamada “Java” donde crearemos nuestros programas. Para ello solo tocamos el simbolo de “+” y cuando nos pida el nombre seleccionamos la opción “Folder” que indicará que crearemos una carpeta.

Seleccionamos la opción "+"

Activamos la opción "Folder"

Carpeta "Java" Creada

Ahora seleccionamos “Java” para acceder a la carpeta y crear nuestro programa.

En esta ocación vamos a crear un programa para calcular el factorial de un número. Lo haremos en dos archivos, uno se llamará Operations.java que contendrá la función para calcular el factorial y el otro se llamará Factorial.java que será nuestro programa principal.

Para crear un archivo lo hacemos de la misma manera que creamos la carpeta, solo que activamos la opción File.

Creamos el archivo Operations.java

Seleccionamos la opción File

Seleccionamos el archivo para abrirlo

Código del archivo Operations.java

Creamos el archivo Factorial.java

Activamos la opción File

Código del archivo Factorial.java

Ya que tenemos los archivos creados vamos a compilarlos y ejecutarlos. Para ellos abrimos el programa Terminal y nos vamos a desplazar hasta la carpeta Java que creamos dentro de documents.

Nos desplazamos hasta la carpeta Java

Ahora compilamos nuestros archivos con el comando jikes archivo.java

Compilamos los archivos

Y finalmente ejecutamos el programa con el comando java archivo

Compilamos nuestro programa

Listo!!

Espero sea de grán ayuda..

Dudas, comentarios y/ó sugerencias no duden en hacerlas llegar..

Saludos!!

Existe una aplicación bastante facil de manejar, para cuendo tengamos la necesidad de conectarnos a algunas de nuestras bases de datos MySQL montadas en la red..

DataGlass MySQL

Esta aplicación nos ayudará en ese trabajito..

Aquí algunas imágenes..

Datos de Conexión

Lista de tablas de la base de datos

Acceso a los datos de la tabla "videos"

La aplicación es gratuita y la pueden bajar de la App Store

Más info: http://itunes.apple.com/es/app/dataglass-mysql/id397060484?mt=8

Espero sea de grán ayuda..

Dudas, comentarios y/ó sugerencias, no duden en hacerlas llegar..

Saludos!!

Vamos a explicar como hacer una paginación de datos en CodeIgniter.

Para ello a mi proyecto lo llamaré CI..

Supongamos que tenemos una tabla llamada customers.

DROP TABLE IF EXISTS `customers`;
CREATE TABLE  `customers` (
  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(45) NOT NULL,
  `lastname` VARCHAR(45) NOT NULL,
  `phone` VARCHAR(45) NOT NULL,
  `address` VARCHAR(45) NOT NULL,
  `email` VARCHAR(45) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;

Habrimos el archivo database.php y configuramos nuestra conexión de base de datos.

Luego dentro de config.php en el parametro $config['base_url'] ponemos algo así $config['base_url']    = “http://127.0.0.1/CI/”;

Despues en el archivo database.php solo indicamos que cargue la base de datos desde el inicio con $autoload['libraries'] = array(‘database’);

Todo esto dentro la carpeta config.

Ahora vamos a crear un modelo para trabajar con la base de datos (los modelos van dentro de la carpeta model).

customers_model.php

<?php
	class Customers_model extends Model {
		function getAllPaginated($per_page,$segment) {
			$this->db->order_by('id ASC');
			$q = $this->db->get('customers',$per_page,$segment);
			$data["customers"]=array();
			if ($q->num_rows() > 0)
			{
				foreach ($q->result() as $row)
				{
					$data["customers"][$row->id]["id"] = $row->id;
					$data["customers"][$row->id]["name"] = $row->name;
					$data["customers"][$row->id]["lastname"] = $row->lastname;
					$data["customers"][$row->id]["phone"] = $row->phone;
					$data["customers"][$row->id]["address"] = $row->address;
					$data["customers"][$row->id]["email"] = $row->email;
				}
			}
			return $data["customers"];
		}
 
		function totalCustomers()
		{
			 $q = $this->db->get('customers');
			return  $q->num_rows() ;
		}
	}
?>

El método getAllPaginated nos regresa los registros paginados, y el método totalCustomers nos devuelve la cantidad de registros totales.

Ahora vamos a crear un controlador con un metodo index (los controladores van dentro de la carpeta controllers)

customers.php

<?php
	class Customers extends Controller {
 
		function Customers()
		{
			parent::Controller();	
			$this->load->helper(array('text','form','url'));
			$this->load->model(array('customers_model'));
		}
 
		function index()
		{
			$pages=10; //Numero de registros mostrados por páginas
			$this->load->library('pagination'); //Cargamos la librería de paginación
			$config['base_url'] = base_url().'index.php/customers/index'; // parametro base de la aplicación, si tenemos un .htaccess nos evitamos el index.php
			$config['total_rows'] = $this->customers_model->totalCustomers() ;  
			$config['per_page'] = $pages; 
			$config['num_links'] = 2; //Numero de links mostrados en la paginación
 
			$this->pagination->initialize($config); 
 
			$data["customers"] = $this->customers_model->getAllPaginated($config['per_page'],$this->uri->segment(3));
 
			$this->load->view('customers',$data); //Cargamos la vista llamada customers.
		}
	}
?>

Ahora creamos la vista para mostrar los datos (las vistas van en la carpeta views).

customers.php

<html>
	<head>
		<title>Customers</title>
	</head>
	<body>
		<table border='1'>
			<tr>
				<td>Name</td>
				<td>Lastname</td>
				<td>Phone</td>
				<td>Address</td>
				<td>Email</td>
			</tr>
		<?php foreach($customers as $customer) { ?>
			<tr>
				<td><?php echo $customer['name']; ?></td>
				<td><?php echo $customer['lastname']; ?></td>
				<td><?php echo $customer['phone']; ?></td>
				<td><?php echo $customer['address']; ?></td>
				<td><?php echo $customer['email']; ?></td>
			</tr>
		<?php } ?>	
		</table>
		<?php echo $this->pagination->create_links(); //Imprime la numeración de páginas ?>
	</body>
</html>

Listo!!

Queda como se muestra en las imágenes..

Listo..
Dudas, sugerencia y/ó comentarios, son bién recibidos..

Saludos..

Introduccion

Una revista de autos una vez declaró que un vehículo tiene “carácter”, si se necesitan 15 minutos para explicar su idiosincrasia antes de que pueda ser prestado a un amigo. Mediante esa norma, cada pieza de software tiene un carácter – con demasiada frecuencia, apenas sale de la caja.

La mayoría de las “peculiaridades” de la programación son propias de un contexto particular, lo que hace que sean muy oscuras. Los sitios web que ofrecen datos XML, por ejemplo, no puede haber sido codificados para decirle al navegador que espere los datos XML, causando una demorade todas las funciones hasta que el valor correcto encaje en su lugar..

Sin embargo, ciertas prácticas de programación hacen que la mayoría de los desarrolladores se tire de los cabellos al abrir un archivo que ha estado exhibiendo demasiada “personalidad”. Pase un tiempo en un bar cerca de cualquier compañía de tecnología, y escuchará los gritos: ¿Por qué el programador sigue utilizando esa estructura anticuada? ¿Dónde estaba el mecanismo de defensa contra los ataques de la web? ¿No había ninguna reflexión sobre lo que un novato haría con el programa?

Criaturas de hábitos, nosotros los desarrolladores parecemos encerrados en ciertos modos de falla que no pueden ser evitados, como es la frecuencia con la que somos víctimas de una particular práctica pobre de programación.

A continuación encontrará las dificultades de programación más comunes, cada una de ellas está acompañada por su opositora, dejando una prueba de que la programación, de hecho, se está convirtiendo en un arte -que requiere una mano hábil y una mente creativa para lograr un justo medio entre los extremos problemáticos.

Error de programación Nº 1: Acelerándolo y haciéndolo fallar
Apuntalar las bases es la forma más fácil de socavar el código. Con frecuencia esto significa perder de vista cómo el comportamiento arbitrario del usuario afectará su programa. ¿La entrada de un cero encontrará su camino en una operación de división? ¿El texto introducido es de la longitud correcta? ¿Los formatos de fecha han sido controlados? ¿El nombre del usuario ha sido verificado en la base de datos? Los errores en los lugares más pequeños hacen que el software falle.

La peor parte de la programación descuidada es que los avances en el diseño de lenguaje destinados a solucionar estos problemas no hacen su trabajo. Tome la última versión de Java, que trata de hacer la comprobación de puntero nulo más fácil, ofreciendo sintaxis abreviada para la prueba sin fin de puntero. Simplemente añadiendo un signo de interrogación a cada invocación de método, incluye automáticamente una prueba de punteros nulos, en sustitución de un nido de ratas de las posibles declaraciones, tales como:

public String getPostcode(Person person) {
String ans= null;
if (person != null) {
Name nm= person.getName();
if (nm!= null) {
ans= nm.getPostcode();
}
}
return ans
}

Con esto:

   public String getFirstName(Person person) {
      return person?.getName()?.getGivenName();
    }

Al final, sin embargo, estas mejoras de sintaxis solo se puede evitar que el código se estrelle, no aseguran que sea útil. Después de todo, no eliminan la raíz del problema: la proliferación de los valores nulos debido a la programación rápida y suelta.

Error de programación Nº 2: La sobrecarga de detalles en la otra cara
El software excesivamente abotonado puede frenarlo hasta hacer que se arrastre. La comprobación de unos pocos punteros nulos no puede hacer mucha diferencia, pero algunos software se escriben para ser como un obsesivo-compulsivo, que debe verificar que las puertas estén bloqueadas una y otra vez, de tal modo que el sueño no llega nunca.

La dedicación incansable a los detalles, incluso puede bloquear el software si el control obsesivo requiere comunicarse con un sitio web a distancia sobre la red. Tengo varios paquetes que se frenan a paso de tortuga si los utilizo en una laptop sin conexión a Internet W-iFi, ya que están tratando desesperadamente de llamar a casa para ver si una nueva versión puede estar disponible. El Wi-Fi LED parpadea, y el software se bloquea, buscando constantemente un punto de acceso que no está allí.

En esta ocasión aquí les dejo un tutorial de cómo realizar un pequeño Syntax Highlight en C#, ya que realizarlo completo seria muy complejo, aquí lo básico para iniciar a crear un Syntax Highlight. 

Lo primero que necesitamos es insertar un RichTextBox y poner las siguientes propiedades del RichTextBox como se indican 

AcceptsTab = True 

Para que mientras escribamos se pueda usar la tecla TAB en lugar de que con ella se pase al siguiente componente en el formulario. 

DetectUrls = False 

Voy a desactivar esta opción para que no se mezcle con la forma de resaltar código. 

Font-name = Consolas  

Utilizo esta fuente para que se vea como código y no como texto normal. 

Cada vez que el texto cambie, tenemos que volver a darle formato al texto. Es por esta razón que todo el código necesario lo vamos a programar en el evento Text_Changed del RichTextBox. 

Lo que tenemos que hacer en este evento es ir seleccionando porciones de texto y cambiándole valores como color, fuente, etc. Podemos seleccionar todo el texto usando el comando SelectAll o porciones de texto usando el atributo SelectionStart y SelectionLength que marcan el inicio y longitud del pedazo seleccionado. Una vez que seleccionamos un pedazo de texto, podemos aplicarle formato utilizando una serie de propiedades, pero la que usaremos en este ejemplo es simplemente SelectionColor que nos permitirá cambiarle el color al texto seleccionado. 

Para poder utilizar expresiones regulares en nuestro Sintax Highlight es necesario utilizar el siguiente nameSpace : 

using System.Text.RegularExpressions;

Ponemos el siguiente código dentro del evento Text_Changed del RichTextBox. 

// Esta primer linea es necesari para evitar el parparpadeo que se produce al seleccionar texto en diferentes partes, lo cual se produce demasioadp rapido y solo vemos el parpadeo richTextBox1.Enabled = false; //Desabilitamos el RichTextBox int selStart = richTextBox1.SelectionStart; int selLength = richTextBox1.SelectionLength;

// Nos aseguramos de que todo el texto
// este negro antes de ponerle color
richTextBox1.SelectAll();
richTextBox1.SelectionColor = Color.Black;

Regex reg;
MatchCollection partes;

// validamos palabras reservadas
reg = new Regex(“(drop|select|table|insert into|from|update|values|where|alter|create|if|exists|foreign key|primary key|constraint|default|engine|InnoDB|charset|not|null)”);
partes = reg.Matches(richTextBox1.Text.ToLower());
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Blue;
}
reg = new Regex(“(int|float|double|varchar|date)”);
partes = reg.Matches(richTextBox1.Text);
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Blue;
}

// Validamos los numero
reg = new Regex(“(1|2|3|4|5|6|7|8|9|0)”);
partes = reg.Matches(richTextBox1.Text);
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Magenta;
}
// Validamos cadenas
reg = new Regex(“[\"][^\"]*[\"]“);//|[\'][^\']*[\']“);
partes = reg.Matches(richTextBox1.Text);
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Orange;
}

// Validamos cadenas
reg = new Regex(“[\'/')][^\'/']*[\'/']“);
partes = reg.Matches(richTextBox1.Text);
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Gray;
}

// Regresamos todo a su sitio, también volvemos a habilitar el RichTextBox que fue desabilitado para evitar el parpadeo
richTextBox1.SelectionStart = selStart;
richTextBox1.SelectionLength = selLength;

richTextBox1.Enabled = true;
richTextBox1.Focus();

Obtendriamos el siguiente resultado:

Este pequeño tutorial esta basado en la sintaxis de MySql lo complejo de SyntaxHighlight depende de la sintaxis que te quieras basar y todo lo que quieras abarcar, como mencione anteriormente este es un tutorial sumamente sencillo basado en lo mas básico. 
Espero y les sea de ayuda!