¿Deseas emprender con éxito?

El Viceministerio de fomento a las PYMES del Ministerio de Industria y Comercio de la República Dominicana (MIC) junto al Centro Regional de Promoción de la MIPYME (CENPROMYPE) convoca a personas o grupos que cumplan con los siguientes requerimientos:

• Que posea una idea de negocios innovadora o una empresa de reciente creación.
• Que tenga deseos de desarrollar su iniciativa y hacer crecer su mercado con el apoyo de especialistas nacionales e internacionales.
• Que esté interesada en acceder a capital semilla no reembolsable de hasta US$7,000.00 para llevar a cabo su proyecto.

¿Quiénes pueden participar?

1. Emprendedores(as) potenciales: Personas y equipos que cuenten con ideas de negocios y con la motivación por emprender a tiempo completo, pero que aún no han avanzado hacia la fase de comercialización de su producto o solución.
2. Empresas de origen reciente: Con no más de 36 meses o 3 años de existencia (a partir de la primera venta).

Tanto para emprendedores potenciales, como para empresas, se buscan equipos mixtos, es decir, que cuenten con al menos una integrante mujer. Esto se realiza siguiendo los lineamientos sugeridos por el BID como forma de aumentar la inclusión social de las mujeres.
Todos los miembros del equipo emprendedor debe tener 18 o más años de edad. Se aceptan ideas de todos los sectores económicos con excepción de: comercio (tiendas, ferreterías, farmacias, etc.) y siembra o venta de productos agrícolas.

Se evaluará favorablemente:

• Aquellos proyectos que tengan al menos una mujer dentro de su equipo.
• Las iniciativas que hayan identificado una oportunidad y se basan en necesidades de los clientes.
• Iniciativas que aprovechen las capacidades y experiencia de uno o más miembros del equipo emprendedor.
• Iniciativas que proporcionen acceso a la solución a mercados tradicionalmente desatendidos.
• Proyectos que presenten evidencia de que la solución es acogida por sus clientes potenciales. No se exigen planes de negocios.

Para participar en este programa debe registrarse en el Formulario de Inscripción en el siguiente link: Reto Emprendedor 2013

Para recibir mayor información, incríbanse y se la estaremos enviando próximamente.

El pasado martes 7 de mayo, Python Dominicana tuvo su 16ta. reunión. Para esta ocasión el punto central fue el planteamiento de realizar un proyecto que sirva como plataforma para que la comunidad de desarrolladores dominicanos para darse a conocer.

Dicha propuesta se trata de elaborar un proyecto web similar a AngelList y que este sea realizado en los diferentes web frameworks que existen para python. Para esto se crearan grupos de trabajos y cada uno seleccionaran un web framework distinto. Esto servirá para compartir en diferentes charlas las experiencias de trabajos con los mismos, planteamientos de ventajas y desventajas de cada web framework y los resultados del desarrollo.

Pronto se estará publicando en Python Dominicana los detalles para el inicio del desarrollo del proyecto.

Para mayores detalles:

• Fotos: Las fotografias de la reunion las pueden ver aquí.

En la 5ta charla de Ruby.do continuamos con lo visto en la charla anterior y nos fajamos con la introducción a Ruby on Rails parte II. En esta ocasión contamos con la presencia de Josue Abreu de Pixel Perfect Tree para impartir la charla.

• Demo: Los demos de la charla lo pueden encontrar en github en el repositorio de ruby.do
• Fotos: Las fotos del evento estan publicadas en G+ en este album.

En nuestra próxima charla estaremos tratando dos temas:

• Debugging Ruby on Rails by Josue Abreu
• Hacking Haml by Gabriel González Mañaná

Ya la invitación esta creada, puedes inscribirte en este link.

El pasado martes 23 de Abril, Python Dominicana tuvo su decimo quinta reunión.  Para esta ocasión el tema tratado fue API’s. La charla sirvió de introducción al API’s cubriendo sus características principales, se hablo un poco de Pyramid para aquellos que no lo conocían, esto sumando a varios ejemplos de API.

Para mayores detalles:

• Código: Para visualizar parte del código empleado usado en la presentación lo pueden ver aquí.

• Fotos: Las fotografías de la reunión las pueden ver aquí.

Noe Branagan tiene dos entradas para el BlackBerry Jam que esta obsequiando.El evento será llevado a cabo del 14 al 16 de mayo en Orlando. Cada entrada tiene un valor aproximado de US$599.00

• Nota: es solamente la entrada, usted es responsable por sus gastos de transporte, hospedaje y demás.

Veremos si el año que viene podemos conseguir un paquete completo que lo cubra todo, pero por el momento es una buena oportunidad para un developer que se encuentre en esa área para la fecha.

Si esta interesado debe enviarle un email a noe.branagan@gmail.com con sus datos y el le contactara.

Esta es la cuarta entrega en esta serie, para los que no lo han hecho o llegaron a este link directamente tienen que leer el primer post para que entiendan el contexto y luego echenle un vistazo al segundo y tercero para que se entienda bien.

Task:

• Dado un archivo de ejemplo que contiene rango de numeros.
• Debe determinar cuantos numeros dentro de cada rango son palindromos
• Mostrar el total

Para hacer las comparaciones entre los diferentes lenguajes estoy usando una Macbook Pro con las siguientes specs:

• 2.4 Ghz Intel Core 2 Duo
• 8 GB 1067 MHz DDR3
• OS X 10.8.3

Le toca el turno a JavaScript. Para eso vamos a tomar un ejemplo en nodejs.

nodejs 0.10.4 by Rene Olivo

var tiempoInicio	= new Date().getTime();


function esPalindromo(cadena) {
	cadena = cadena.toString();
	
	return cadena == cadena.split('').reverse().join('');
}


var fs = require('fs');


fs.readFile('seed.txt', function(error, archivo) {
	var contador	= 0;

	var lineas	= archivo.toString().split("\n");
	
	for (var num in lineas) {
		var rango	= lineas[num].split(' ');
		
		rango[0]	= parseInt(rango[0]);
		rango[1]	= parseInt(rango[1]);
		
		for(var i = rango[0]; i <= rango[1]; i++)
			if (esPalindromo(i))
				contador++;
	}
	
	var tiempoFin		= new Date().getTime();
	var tiempoTotal		= (tiempoFin - tiempoInicio) / 1000;
		
	console.log( 'Encontradas    : ' + contador );
	console.log( 'Inicio         : ' + tiempoInicio );
	console.log( 'Fin            : ' + tiempoFin );
	console.log( 'Tiempo Total   : ' + tiempoTotal );		
});

• Total: 106,814
• Tiempo: 51.894 segundos

El tiempo de corrida no esta mal para ser un lenguaje interpretado y el algoritmo que se esta utilizando, yo esperaba que fuera mas lento. Tengo otra versión que mandaron en JS puro, pero aun la estoy depurando, cuando la termine la voy a incluir tambien.

Aqui vamos con el tercer post en esta serie, para los que no lo han hecho o llegaron a este link directamente tienen que leer el primer post para que entiendan el contexto y el segundo para que tengan una mejor referencia.

Task:

• Dado un archivo de ejemplo que contiene rango de numeros.
• Debe determinar cuantos numeros dentro de cada rango son palindromos
• Mostrar el total

Para hacer las comparaciones entre los diferentes lenguajes estoy usando una Macbook Pro con las siguientes specs:

• 2.4 Ghz Intel Core 2 Duo
• 8 GB 1067 MHz DDR3
• OS X 10.8.3

Ahora voy con Ruby, para los que aun no lo saben tenemos un user group de Ruby que se reune cada dos jueves en Pulso Colectivo donde pueden aprender mas sobre este lenguaje y todo el ecosistema que lo rodea.

Ruby 2.0.0 by Hector Minaya

def is_palindrome?(num)
  	s = num.to_s
	s == s.reverse
end

count = 0
File.open("seed.txt") do |f|
	while line = f.gets
		one = line.split[0]
		two = line.split[1]

		(one..two).each do |x|
			if is_palindrome?(x)
				count += 1
			end
		end

	end
end

puts "\nFound: #{count}"

• Total: 106,814
• Tiempo: 2 minutos 19 segundos

Vamos por parte. Para mi, esta es una de las soluciones mas sencillas de todos los ejemplos que vi en los diferentes lenguajes. El problema esta en que es de las mas lentas. ¿Porque es lenta? ¿Ruby es lento?, la respuesta es no a ambas preguntas. Yo diria mas bien que mientras mas *chuleria* tu utilices del lenguaje, mientras mas comodidad tengas al escribir tu codigo, generalmente mas lento va a ser. Paso casi lo mismo con el ejemplo de python donde la primera solución era mucho mas entendible, pero tambien era la mas lenta.

jRuby 1.7.3 by Hector Minaya

def is_palindrome?(num)
  	s = num.to_s
	s == s.reverse
end

count = 0
File.open("seed.txt") do |f|
	while line = f.gets
		one = line.split[0]
		two = line.split[1]

		(one..two).each do |x|
			if is_palindrome?(x)
				count += 1
			end
		end

	end
end

puts "\nFound: #{count}"

• Total: 106,814
• Tiempo: 1 minuto 27 segundos

Bien, aqui vamos progresando. En ruby existen diferentes implementaciones para cubrir necesidades especificas. Probe el mismo codigo pero utilizando jRuby y el tiempo bajo considerablemente.

Ruby 2.0.0 by Hector Minaya

count = 0

File.open("seed.txt") do |f|
	while line = f.gets
		one, two = line.split(" ").map(&:to_i)

		while (one <= two) do
			one += 1

			muestra = one.to_s
			
			if muestra == muestra.reverse
				count += 1
			end

		end
	end
end

puts "\nFound: #{count}"

• Total: 106,814
• Tiempo: 50 segundos

Este fue la segunda vuelta, luego de secarme las lagrimas por lo lento que corrio el primer intento aqui lo baje a menos de la mitad. Si se fijan estoy haciendo varias optimizaciones, pero aun el codigo se mantiene legible, lo cual es muy importante.

jRuby 1.7.3 by Hector Minaya

count = 0

File.open("seed.txt") do |f|
	while line = f.gets
		one, two = line.split(" ").map(&:to_i)

		while (one <= two) do
			one += 1

			muestra = one.to_s
			
			if muestra == muestra.reverse
				count += 1
			end

		end
	end
end

puts "\nFound: #{count}"

• Total: 106,814
• Tiempo: 38 segundos

Este es el segundo ejemplo, pero con jRuby. Ahora corre en 38 segundos. Todavia le falta para correr igual que lo implementado por Ivan Miric en Python, pero el algoritmo que el utilizo fue mucho mejor. Estoy seguro que si se sigue optimizando podemos llevarlo a correr igual de rapido que python, pero ya le dejare esa tarea a los demás miembros del user group de ruby.do

Ruby 2.0.0 by Omar Rodriguez

class Fixnum
  def palindrome?
    to_s == to_s.reverse
  end
end

def parse_range line
  Range.new *line.split.map(&:to_i)
end

def count_palindromes file
  file.reduce(0) do |total, line|
    total + parse_range(line).count(&:palindrome?)
  end
end

p "Found #{count_palindromes File.open("seed.txt", "r")}"

# ruby-1.9.3

# $ time ruby palindrome.rb 
# "Found 106814"

# real  1m6.513s
# user  1m6.452s
# sys 0m0.020s

• Total: 106,814
• Tiempo: 1 minuto 48 segundos

Este ejemplo es interesante, esta escrito de forma elegante.

Ruby 2.0.0 by Rafael George

def reverse number
  inverse = 0
  while number > 0
    inverse = inverse * 10 + (number % 10)
    number = number / 10
  end
  inverse
end

pals = [] 
count = 0
25192.upto(2000000) { |n| pals << n if reverse(n) == n }
File.open('seed.txt').each_line do |line|
  start, finish = line.split(/\s+/,2).map(&:to_i)
  pals.each { |n| count += 1 if (start..finish).include? n }
end

puts count

• Total: 106,814
• Tiempo: 2.117 segundos

Con este ya #python se puede cuidar, aqui tenemos una muestra que lo importante no es el lenguaje, es el algoritmo. Y eso es sin utilizar un compilador como el PyPy.

Este es el segundo post en una serie donde comparamos varios lenguajes realizando la misma tarea. Para que entiendan mejor el contexto los invito que lean el primero.

Task:

• Dado un archivo de ejemplo que contiene rango de numeros.
• Debe determinar cuantos numeros dentro de cada rango son palindromos
• Mostrar el total

Para hacer las comparaciones entre los diferentes lenguajes estoy usando una Macbook Pro con las siguientes specs:

• 2.4 Ghz Intel Core 2 Duo
• 8 GB 1067 MHz DDR3
• OS X 10.8.3

En esta oportunidad voy con PHP, vamos a ver si PHP se saca esa mala fama que tiene arriba o si sigue siendo la oveja negra.

PHP 5.3.15 by Rene Olivo

<?php
	function esPalindromo($cadena) {
		return $cadena == strrev($cadena);
	}
	
	
	$contador		= 0;
	
	$tiempoInicio		= microtime(TRUE);
	
	
	$urlArchivo		= 'seed.txt';
	$puntero		= fopen($urlArchivo, 'r');
	
	while(!feof($puntero)):
		$linea		= fgets($puntero);
		
		$rango		= explode(' ', $linea);
		
		$rango[0]	= (int) $rango[0];
		$rango[1]	= (int) $rango[1];
		
		for($i = $rango[0]; $i <= $rango[1]; $i++)
			if (esPalindromo($i))
				$contador++;
		
	endwhile;
	
	$tiempoFin		= microtime(TRUE);
	$tiempoTotal		= $tiempoFin - $tiempoInicio;
	
	echo "<pre>
	
Encontradas    : {$contador}
Inicio         : {$tiempoInicio}
Fin            : {$tiempoFin}
Tiempo Total   : {$tiempoTotal}
		
	</pre>";
?>

• Total: 106,815 (ehhh, si dio un numero de mas)
• Tiempo: 1 minuto 40 segundos

Yo no soy programador de PHP, asi que mejor no voy a opinar mucho, pero esto tiene que poderse correr mas rapido de ahi.

PHP 5.3.15 by Joel J. Blandino

<?php
class Palindromo{
  public static function empezar(){
    $archivo  	=	fopen("file.txt","r");
    $encontrados	=	0;
    while(!feof($archivo)){
      $registro	=	fgets($archivo);
      $rango	 	= 	explode(" ", $registro);
      for($for = (int)$rango[0]; $for <= (int)$rango[1]; $for++){
        if($for == strrev($for)){
          $encontrados++;
        }
      }
    }
    echo "Encontradas: ".number_format($encontrados)."<br/>";
  }
}
Palindromo::empezar();
?>

• Total: 106,815 (tambien da un numero de mas, el correcto es 106,814)
• Tiempo: 1 minuto 18 segundos

En este segundo intento de Joel el tiempo bajo alrededor de 22 segundos, pero aun le falta. Si alguno de ustedes cree que puede mejorar el performance de este script y llevarlo a un nivel parecido a lo obtenido con python en el post anterior sientase en la libertad de contactarme y con mucho gusto actualizo el post.

PHP 5.3.15 by Juan Manuel Boehme

<?php
$time=time();
class Palindromo{
    public static function empezar(){
        $archivo    =  fopen("file2.txt","r");
        $primero=array();
        $segundo=array();
        $final=array();
        $total=0;
        while(!feof($archivo)){
            $registro    =	fgets($archivo);
            $rango	 	= 	explode(" ", $registro);
            array_push($final, $rango);
            array_push($primero, trim($rango[0]));
            array_push($segundo, trim($rango[1]));
        }
        sort($primero);
        sort($segundo);
        $Primer_numero=(int)$primero[0];
        $Segundo_numero=(int)$segundo[count($segundo)-1];
        for($x=$Primer_numero;$x<$Segundo_numero;$x++)

        {
            if($x==strrev($x))
            {

                $cantArray=count($final);
                for($z=0;$z<$cantArray;$z++)
                {

                    /*Validate When Range is from x to x like 2002 2002*/
                    if($final[$z][1]>=$x)
                    {

                        if($final[$z][0]<=$x)
                        {
                            $total++;
                        }
                    }
                }
            }
        }
        echo $total.'<br>';

    }
}

Palindromo::empezar();
echo time()-$time;
?>

• Total: 106,815 (tambien da un numero de mas, el correcto es 106,814)
• Tiempo: 1.383 segundos

Ahora si estamos hablando, ya tenemos un programador PHP que puso el lenguaje a valer. Corre mucho mas rapido, pero es mucho menos legible para un Programador Junior.

Inicialmente este post era una comparación simple entre diferentes lenguajes, algo parecido al anterior donde leiamos un JSON desde un API via HTTP. Pero luego me fui dando cuenta que debia tratar los lenguajes por separado en diferentes posts para mostrar diferentes versiones dentro de un mismo lenguaje. El objetivo de estos ejercicios es mostrar las fortalezas y debilidades de diferentes lenguajes con ejemplos practicos y dejar que cada quien luego saque sus conclusiones sobre cual lenguaje le conviene realizar en cada escenario.

Para entrar en detalle el task de hoy incluye:

• Dado un archivo de ejemplo que contiene rango de numeros. Contiene 100 rangos, mucho mas que el archivo de ejemplo que puse en el post de FB.
• Debe determinar cuantos numeros dentro de cada rango son palindromos
• Mostrar el total

Para hacer las comparaciones entre los diferentes lenguajes estoy usando una Macbook Pro con las siguientes specs:

• 2.4 Ghz Intel Core 2 Duo
• 8 GB 1067 MHz DDR3
• OS X 10.8.3

Si usted lo esta corriendo en una maquina con mejores specs es obvio que sus pruebas le van a dar mas rapido, de igual forma si lo hace en una con menos poder le va a resultar mas lento. Ahora vamos con los ejemplos, ejecute cada uno multiple veces y tome la corrida mas rapida. Generalmente la variación era muy poca, 1 o 1.5 segundos. Voy a comenzar con python

Python 2.7.2 by danielgpm

import time
start = time.time()
total_count = 0
with open (r'seed.txt') as file:
  rangos = ((int(rango) for rango in line.split()) for line in file)
  for rango_ini, rango_final in rangos:
    nums = (str(num) for num in xrange(rango_ini, rango_final + 1))
    total_count += sum(1 for num in nums if num == num[::-1])
  end = time.time()
  print ("Total de palimdromes: {0}".format(total_count))
  print ("Duracion: {0:.3f} secs".format(end-start))

• Total: 106,814
• Tiempo: 79.526 segundos

Esta versión la trabajo Daniel Paniagua. Esta mucho mejor que lo que yo hubiese hecho en python, asi que la mia supongo que hubiese durado como media hora en correr.

Python 2.7.3 con PyPy 2.0.0-beta2 by danielgpm

import time
start = time.time()
total_count = 0
with open (r'seed.txt') as file:
  rangos = ((int(rango) for rango in line.split()) for line in file)
  for rango_ini, rango_final in rangos:
    nums = (str(num) for num in xrange(rango_ini, rango_final + 1))
    total_count += sum(1 for num in nums if num == num[::-1])
  end = time.time()
  print ("Total de palimdromes: {0}".format(total_count))
  print ("Duracion: {0:.3f} secs".format(end-start))

• Total: 106,814
• Tiempo: 21.399 segundos

Ok, ahora si estamos hablando. Sin hacerle cambio al codigo fuente, solo usando PyPy el tiempo bajo en alrededor de un 70%.

Python 2.7.2 by imiric

#!/usr/bin/env python

def is_palindrome(num):
    return str(num) == str(num)[::-1]

def closest_higher(target, collection) :
    """Return the closest number to `target` in `collection`
    that is higher than `target`"""
    return max((target - i, i) for i in collection if (target - i) < 0)[1]

def main():
    palindromes = []
    ranges = [[int(i) for i in line.split()] for line in open('seed.txt')]
    ranges_flat = [i for r in ranges for i in r]
    lo, hi = min(ranges_flat), max(ranges_flat)
    while hi >= lo:
        if is_palindrome(lo):
            palindromes.append(lo)
        lo += 1

    total = 0
    for lo, hi in ranges:
        x = palindromes.index(closest_higher(lo, palindromes))
        if hi > palindromes[-1]:
            y = len(palindromes)
        else:
            y = palindromes.index(closest_higher(hi, palindromes))
        p = palindromes[x:y]
        c = len(p)
        total += c
        print '%6d => %7d : %d' % (lo, hi, c)
    print 'TOTAL: %d' % total

if  __name__ =='__main__':
    main()

.

• Total: 106,814
• Tiempo: 2.611 segundos

Esta versión la trabajo Ivan Mirić, su gist original es este, tuve que hacerle un fork por razones de formato. Es una muestra de como un lenguaje dinamico (python/ruby/etc) puede llegar a ser tan eficiente como un lenguaje estatico. La desventaja es que mientras mas optimización le aplicamos mediantes algoritmos “empipados con moringa“, mas enredado se vuelve para nosotros los mortales y llega a un punto donde un developer Senior facilmente se pierde.

Python 2.7.3 con PyPy 2.0.0-beta2 by imiric

#!/usr/bin/env python

def is_palindrome(num):
    return str(num) == str(num)[::-1]

def closest_higher(target, collection) :
    """Return the closest number to `target` in `collection`
    that is higher than `target`"""
    return max((target - i, i) for i in collection if (target - i) < 0)[1]

def main():
    palindromes = []
    ranges = [[int(i) for i in line.split()] for line in open('seed.txt')]
    ranges_flat = [i for r in ranges for i in r]
    lo, hi = min(ranges_flat), max(ranges_flat)
    while hi >= lo:
        if is_palindrome(lo):
            palindromes.append(lo)
        lo += 1

    total = 0
    for lo, hi in ranges:
        x = palindromes.index(closest_higher(lo, palindromes))
        if hi > palindromes[-1]:
            y = len(palindromes)
        else:
            y = palindromes.index(closest_higher(hi, palindromes))
        p = palindromes[x:y]
        c = len(p)
        total += c
        print '%6d => %7d : %d' % (lo, hi, c)
    print 'TOTAL: %d' % total

if  __name__ =='__main__':
    main()

.

• Total: 106,814
• Tiempo: 0.787 segundos

Wow!. En menos de un segundo. Esta es una combinación muy buena, tenemos un algoritmo eficiente combinado con una implementación alternativa de python hecha especificamente para aumentar el rendimiento. Va a ser una tarea muy dificil para los demas lenguajes/plataformas mejorar este tiempo.

Les recuerdo que este es solo el primer post en esta serie voy a continuar con:

• PHP
• Ruby
• Java
• JavaScript
• Scala
• C#
• C++

Al final cuando esten todos publicados voy a publicar un resumen con una tabla de resultado para que puedan hacer las comparaciones de forma directa.

En la 4ta charla de Ruby.do tuvimos una introducción a Ruby on Rails impartida por Jose Gregorio Taveras.

• Demo: Los demos de la charla lo pueden encontrar en github en el repositorio de ruby.do
• Fotos: Las fotos del evento se publicaron en G+ en este album.

Si aun no has tenido la oportunidad de asistir a una de las charlas de este user group te invitamos a que compartas con nosotros en nuestra próxima charla el 2 de Mayo a las 6:30 en Pulso Colectivo. Nuestra proxima charla sera impartida por Josue Abreu, CEO de Pixel Perfect Tree, y será la 2da parte nuestra Intro a Ruby on Rails. Para registrarte lo puedes hacer por via este link.