Tras dos horas probando opciones, distintas configuraciones y activando y desactivando todo. Creo haber encontrado una solución al problema del 3G que al menos en mi caso, y el de un compañero, ha funcionado.

 Ayer actualicé a iOS 6.1 en mi iPhone 4 Libre de 16Gb. Como me pasé toda la tarde y noche con el Wifi, no caí en la cuenta de que había perdido el 3G, que si bien el iPhone me marcaba como conectado, no recibía señal alguna.

 Decir que estoy en la compaía Ono móvil, que no se lleva muy bien normalmente con mi iPhone.

 Una de las primeras cosas que he hecho, y no sé si ha influido, es retirar la microSIM de Ono, con el iPhone en marcha, y meter una de Movistar.

 Con ella dentro he ido a:

 Ajustes -> General -> Restablecer -> Restablecer ajusted de red.

Estará como un minuto trabajando con el logo de Apple en la pantalla.

 Como me imaginaba, al meter mi microSIM de Ono, seguía sin funcionar el 3G.

Sin embargo se me ha ocurrido ir a:

 Ajustes -> General -> Datos Móviles – Red de datos móviles

 Ahí he visto que los puntos de acceso de “datos móviles” estaban en blanco.

 En mi caso he puesto el de ONO:

 Punto de acceso: internet.ono.com

 Nombre de usuario: (dejar en blanco)

 Contraseña: (dejar en blanco)

 He activado y desactivado el modo avión y…Voilà!

3G FUNCIONANDO EN MI IPHONE 4 CON IOS 6.1

Comentar todo lo que os ocurra, que seguro será de utilidad para otros.

Cuando tenemos aplicaciones que se comunican con servicios web, las respuestas suelen por normal general en XML o JSON.

En este tutorial vamos a apprender como parsear (recorrer y analizar) este XML, mostrando los datos en una tabla.

Supongamos que enviamos con nuestra aplicación una petición a un servidor que en función del parámetro nos devuelve unos resultados u otros, pero siempre con el mismo formato.

Pongamos que queremos recuperar la lista de peliculas de dos actores distintos.

Nuestra aplicación cuenta con una lista de actores que tienen unos “id_cator” asociado.

Si por ejemplo queremos saber las películas de Bruce Willis, pasaremos al servicio el id_actor de Bruce, de forma similar a esto:

http://www.apprendemos.com/webservices/get_peliculas?id_actor=145 

Pero si queremos las películas de Nicolas Cage, será:

http://www.apprendemos.com/webservices/get_peliculas?id_actor=37

*Estas url no existen, son solo ejemplos.

La respuesta podría ser similar a:

<listado>
    <pelicula id="1">
        <titulo>La Jungla 4.0</titulo>
        <descripcion>La mejor pelicula de los ultimos tiempos. El agente Jonh McCain...</descripcion>
        <anio>2010</anio>
    </pelicula>
    <pelicula id="2">
        <titulo>El sexto sentido</titulo>
        <descripcion>La película con un final prometedor e insesperado.</descripcion>
        <anio>1998</anio>
    </pelicula>
    <pelicula id="3">
        <titulo>Falsas Apariencias</titulo>
        <descripcion>Mezcla de acción y comedia junto a Mathew Perry</descripcion>
        <anio>2004</anio>
    </pelicula>
</listado>

Como vemos la respuesta contiene un Nodo principal. Por norma, todo XML debe tener un nodo padre principal.

Después vemos claramente cuales son los distintos items, en este caso, delimitados por “película”

Dentro tenemos 4 elementos: 

    – El id de la pelicula (dentro de “pelicula id=”id_pelicula”" Utilizamos un atributo para mostrar después como recuperarlo. Los atributos hacen ahorrar bastante código en el XML, lo que para las respuestas web son más eficientes).

    – El título (‘<'titulo'>”<'/titulo'>‘).

    – La descripción (‘<'descripcion'>”<'/descripcion'>‘).

    – El año de estreno (‘<'anio'>”<'/anio'>‘).

Para realizar este tutorial será necesario tener conocimiento de UITableview (tutorial disponible) y UINavigationController (tutorial disponible)

En otro tutorial explicaremos como conectar a un servicio web de forma asíncrona y recuperar sus valores parapoder interacturar.

En este ejemplo, pondemos crear en un NSString cada XML.

Creamos un nuevo proyecto de tipo Single View Application.

Lo primero que vamos a hacer es crear una clase que contendrá los valores de las películas.

Creamos un NSObject.

En Pelicula.h:

#import <Foundation/Foundation.h>
 
@interface Pelicula : NSObject
{
 
}
 
@property(nonatomic) int id_pelicula;
@property(nonatomic, retain) NSString *titulo;
@property(nonatomic, retain) NSString *descripcion;
@property(nonatomic) int anio;
 
@end

En Pelicula.m:

#import "Pelicula.h"
 
@implementation Pelicula
@synthesize id_pelicula, titulo, descripcion, anio;
 
 
@end

Como nuestra aplicación va a navegar entre ventanas le añadimos al AppDelegate un UINavigationController, como ya se ha hecho en el tutorial correspondiente.

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
    // Override point for customization after application launch.
 
    self.viewController = [[ViewController alloc] initWithNibName:nil bundle:nil];
 
    UINavigationController *navController = [[UINavigationController alloc]initWithRootViewController:self.viewController];
 
    self.window.rootViewController = navController;
    [self.window makeKeyAndVisible];
    return YES;
}

Én viewController.xib insertamos dos botones.

Y les asignamos el tag 0 y 1 respectivamente.

Creamos un UIViewController ListadoViewController en el proyecto.

Dejaremos el código de ListadoViewController.h así:

#import <UIKit/UIKit.h>
#import "Pelicula.h"
 
@interface ListadoViewController : UIViewController <NSXMLParserDelegate, UITableViewDataSource, UITableViewDelegate>
{
    NSMutableArray *peliculas;
    Pelicula *auxPelicula;
 
    NSMutableString *currentElementValue;
 
    IBOutlet UITableView *tableView;
}
 
@property(nonatomic, retain) NSString *stringXML;
 
 
@end

Como vemos hemos importado el objeto Pelicula. Hemos declarado al controlador como delegado de UITableView y de NSXMLParser, que será el que implementaremos en el tutorial.

Además declaramos el array que contendrá las películas del actor, el string que almacenará el contenido de cada etiqueta del XML, y la tabla para mostrar los resultados.

stringXMl hará del contenido XML que en una situación real  recuperaríamos de un servicio web (o de un fichero local).

Ahora volvemos a viewController.m, y creamos un método que llame al listado, y en función del tag que tenga el botón que hace la llamada, mostraremos un xml u otro. 

- (IBAction)mostrarPeliculasPorActor:(id)sender
{
    UIButton *auxButton = (UIButton*)sender;
 
    NSString *stringXML = @"";
 
    switch (auxButton.tag) {
        case 0:
        {
            stringXML = [stringXML stringByAppendingString:@"<listado>"];
                stringXML = [stringXML stringByAppendingString:@"<pelicula id=\"1\">"];
                    stringXML = [stringXML stringByAppendingString:@"<titulo>La Jungla 4.0</titulo>"];
                    stringXML = [stringXML stringByAppendingString:@"<descripcion>La mejor pelicula de los ultimos tiempos. El agente Jonh McCain...</descripcion>"];
                    stringXML = [stringXML stringByAppendingString:@"<anio>2010</anio>"];
                stringXML = [stringXML stringByAppendingString:@"</pelicula>"];
                stringXML = [stringXML stringByAppendingString:@"<pelicula id=\"2\">"];
                    stringXML = [stringXML stringByAppendingString:@"<titulo>El sexto sentido</titulo>"];
                    stringXML = [stringXML stringByAppendingString:@"<descripcion>La película con un final prometedor e insesperado.</descripcion>"];
                    stringXML = [stringXML stringByAppendingString:@"<anio>1998</anio>"];
                stringXML = [stringXML stringByAppendingString:@"</pelicula>"];
                stringXML = [stringXML stringByAppendingString:@"<pelicula id=\"3\">"];
                    stringXML = [stringXML stringByAppendingString:@"<titulo>Falsas Apariencias</titulo>"];
                    stringXML = [stringXML stringByAppendingString:@"<descripcion>Mezcla de acción y comedia junto a Mathew Perry</descripcion>"];
                    stringXML = [stringXML stringByAppendingString:@"<anio>2004</anio>"];
                stringXML = [stringXML stringByAppendingString:@"</pelicula>"];
            stringXML = [stringXML stringByAppendingString:@"</listado>"];
 
            break;
        }
 
        case 1:
        {
            stringXML = [stringXML stringByAppendingString:@"<listado>"];
                stringXML = [stringXML stringByAppendingString:@"<pelicula id=\"35\">"];
                    stringXML = [stringXML stringByAppendingString:@"<titulo>Cara a Cara</titulo>"];
                    stringXML = [stringXML stringByAppendingString:@"<descripcion>Dos personas enfrentadas, a si mismas...</descripcion>"];
                    stringXML = [stringXML stringByAppendingString:@"<anio>1995</anio>"];
                stringXML = [stringXML stringByAppendingString:@"</pelicula>"];
                stringXML = [stringXML stringByAppendingString:@"<pelicula id=\"56\">"];
                    stringXML = [stringXML stringByAppendingString:@"<titulo>El motorista fantasma</titulo>"];
                    stringXML = [stringXML stringByAppendingString:@"<descripcion>Porque morir con una moto no es decir adios</descripcion>"];
                    stringXML = [stringXML stringByAppendingString:@"<anio>2007</anio>"];
                stringXML = [stringXML stringByAppendingString:@"</pelicula>"];
                stringXML = [stringXML stringByAppendingString:@"<pelicula id=\"42\">"];
                    stringXML = [stringXML stringByAppendingString:@"<titulo>La búsqueda</titulo>"];
                    stringXML = [stringXML stringByAppendingString:@"<descripcion>Nicolas Cage hace temblar al Sr.Jones</descripcion>"];
                    stringXML = [stringXML stringByAppendingString:@"<anio>2002</anio>"];
                stringXML = [stringXML stringByAppendingString:@"</pelicula>"];
            stringXML = [stringXML stringByAppendingString:@"</listado>"];
            break;
        }
 
        default:
            break;
    }
 
    ListadoViewController *listadoController = [[ListadoViewController alloc]initWithNibName:nil bundle:nil];
    NSLog(@"XML = %@", stringXML);
    [listadoController setStringXML:stringXML];
 
    [self.navigationController pushViewController:listadoController animated:YES];
 
 
 
}

Ahora tenemos que llamar desde el listado al parser XML (NSXMLParser).

Vamos a ListadoViewController.m y en viewDidLoad añadimos lo siguiente:

- (void)viewDidLoad
{
    [super viewDidLoad];
 
    // Establecemos el delegate de la tabla, el dataSource y el alto de tabla.
    tableView.delegate = self;
    tableView.dataSource = self;
    tableView.rowHeight = 90.0;
 
 
 
    // Simulamos la respuesta del servidor con nuestro stringXML.
    // Lo convertimos a NSData para evitar errores de codificación.
    NSData *responseData = [stringXML dataUsingEncoding:NSUTF8StringEncoding];
 
    // Si tuvieramos el XML en un archivo local se podría hacer así:
    // NSData *responseData = [NSData dataWithContentsOfFile:[[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:@"peliculas.xml"]]
 
    // Creamos el parser:
    NSXMLParser *parser = [[NSXMLParser alloc] initWithData:responseData];
 
    // Lo establecemos como delegado, ya que nuestro ListadoViewController implementará el protocolo.
    [parser setDelegate:self];
 
    // Y parseamos el XML, a falta de algún error:
    // - Etiquetas sin cerrar
    // - Mala sintaxis
    // - Problemas de codificación
    // - XML sin etiqueta raiz
 
    if(![parser parse])
        NSLog(@"Error al parsear");
    else
        NSLog(@"OK Parsing");
 
 
}

Añadimos el método que detecta las aperturas de los nodos (listado,pelicula,titulo,descripcion y anio):

// Este método detecta las etiquetas que abren.
-(void)parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qualifiedName attributes:(NSDictionary *)attributeDict
{
    // Comprobamos que etiqueta se ha detectado
    if([elementName isEqualToString:@"listado"]){
 
        // Iniciamos el listado
        // En principio este objeto es nil, pero no está de más comprobar.
        if(peliculas == nil)
        {
            peliculas = [[NSMutableArray alloc]init];
 
        } else {
 
            [peliculas removeAllObjects];
 
        }
 
    } else if([elementName isEqualToString:@"pelicula"]){
 
        // Al detectar que abre la etiqueta película creamos el objeto que contendrá los datos.
        auxPelicula = [[Pelicula alloc] init];
 
        // En XMl los datos puedes formar parte de una etiqueta, siendo su atributo. Esto ahorra en tamaño para el XML cuando tenemos muchos datos.
        if([attributeDict objectForKey:@"id"] != nil)
        {
            // Obtenemos el id de la película.
            auxPelicula.id_pelicula = [[attributeDict objectForKey:@"id"]intValue];
        }
    }
 
}

Añadimos ahora el método que lee y almacena el contenido de las etiquetas. Este podemos dejarlo tal cual en cualquier aplicación que hagamos:

// Este método detecta contenido entre etiquetas, siempre lo dejaremos así.

-(void)parser:(NSXMLParser *)parser foundCharacters:(NSString *)string
{
    if(!currentElementValue)
    {
        currentElementValue = [[NSMutableString alloc]initWithString:string];
    }
    else
    {
        [currentElementValue appendString:string];
    }
 
}

Pasamos ahora al que seguro es más importante. 

// Este método detecta las etiquetas que cierran y es donde se comprueban los valores entre etiquetas para completar los objetos inicializados.
-(void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName
{
    // Si es el raiz, sabemos que ha terminado el XML, y por tanto es tonteria, seguir haciendo comprobaciones. Finalizamos el parser.
    if([elementName isEqualToString:@"listado"]){
        return;
 
        // Si es el objeto el que cierra, podemos añadir el objeto al listado y finalizarlo, pues ya tendrá todas las propiedades.
    }  else if([elementName isEqualToString:@"pelicula"]){
 
 
        [peliculas addObject:auxPelicula];
        auxPelicula = nil;
 
        // Si es un parametro del objeto, se lo añadimos.
    } else if([elementName isEqualToString:@"titulo"])
    {
        [auxPelicula setTitulo:currentElementValue];
 
        // Y así con todos....
    } else if([elementName isEqualToString:@"descripcion"])
    {
        [auxPelicula setDescripcion:currentElementValue];
 
    } else if([elementName isEqualToString:@"anio"])
    {
        [auxPelicula setAnio:[currentElementValue intValue]];
 
    }
 
    // Es importante liberar el contenido de currentElementValue para que no siga concatenando el valor actual con el siguiente.
    currentElementValue = nil;
 
}

Una vez finalizado solo hay que mostrar los resultados en la tabla, estos métodos están explicados en el correspondiente tutorial de listar datos en iOS con UITableView.

-(NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return[peliculas count];
}
 
-(NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
    return 1;
}
 
-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    // Normalmente recuperaremos del array, según la posicion de la fila..
    Pelicula *aPelicula = [peliculas objectAtIndex:indexPath.row];
 
    // Creamos la celda (o fila).
    UITableViewCell *cell = [[UITableViewCell alloc]initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"Cell"] ;
 
    /*-------------------------------------*/
    /* TÍTULO DE PELÍCULA                  */
    /*-------------------------------------*/
    // Creamos una etiqueta para la celda.
    UILabel *tituloLabel =  [[UILabel alloc] initWithFrame: CGRectMake( 10.0, 0.0, self.view.frame.size.width - 20.0, 20.0)];
 
    tituloLabel.textAlignment = NSTextAlignmentCenter;
 
    // Insertamos el texto de la etiqueta.
    tituloLabel.text = [NSString stringWithFormat:@"%@",aPelicula.titulo];
 
    // Añadimos el label a la celda.
    [cell.contentView addSubview:tituloLabel];
 
 
    /*-------------------------------------*/
    /* DESCRIPCIÓN DE PELÍCULA             */
    /*-------------------------------------*/
    // Creamos una etiqueta para la celda.
    UILabel *descTextView =  [[UILabel alloc] initWithFrame: CGRectMake( 10.0, 25.0, self.view.frame.size.width - 20.0, 40.0)];
 
    descTextView.numberOfLines = 2;
 
    // Insertamos el texto de la etiqueta.
    descTextView.text = [NSString stringWithFormat:@"%@",aPelicula.descripcion];
 
    // Añadimos el label a la celda.
    [cell.contentView addSubview:descTextView];
 
    /*-------------------------------------*/
    /* AÑO DE PELÍCULA                     */
    /*-------------------------------------*/
    // Creamos una etiqueta para la celda.
    UILabel *anioLabel =  [[UILabel alloc] initWithFrame: CGRectMake( self.view.frame.size.width - 60.0, 70.0, 60.0, 20.0)];
 
    // Insertamos el texto de la etiqueta.
    anioLabel.text = [NSString stringWithFormat:@"%d",aPelicula.anio];
 
    // Añadimos el label a la celda.
    [cell.contentView addSubview:anioLabel];
    /*-------------------------------------*/
 
 
 
 
    // Y finalizamos devolviendo la celda 
    return cell;
}

Antes de terminar el código, vamos a viewDidLoad y justo después del parseo recargamos los datos de la tabla:

if(![parser parse])
        NSLog(@"Error al parsear");
    else
        NSLog(@"OK Parsing");
 
    [tableView reloadData];

Por último queda ir al ListadoViewController.xib y arrastrar un tableView.

Le asignamos el IBOutlet de tableView, y las propiedades delegate y datasource:

Podéis probar como al iniciar al simulador.

Si pulsamos sobre el botón de Bruce Willis, nos muestra las que hemos añadido a su xml. Lo mismo pasa con Nicolas Cage.

Esperamos que os haya gustado este tutorial de recorrido y análisis de XML en iOS, pues el parseo XML es muy útil para cualquier comunicación con servidores.

Recordar que si os gustan nuestros tutoriales, a nosotros nos gusta más aún que se difundan, compartir en las redes sociales nos viene bien a todos

 Hace algo más de un mes, un buen amigo me comentó a cerca de una nueva plataforma que estaba empezando. Me pidió que le echara un vistazo ya que estaba creada por conocidos suyos, los cuales vienen de la misma universidad que yo, la Universitat Politécnica de Valencia, y han sido impulsados por el instituto IDEAS, en el que estuve en su dia, a punto de participar.

Finalmente he encontrado un hueco para echarle un vistazo, y la sorpresa ha sido  bastante grata.

Por ese motivo, hoy os vamos a presentar esta plataforma que consideramos ha de convertirse en indispensable para cada uno de vosotros, desarrolladores, diseñadores, publicistas y otros expertos, así como para las empresas que están por ahí buscando profesionales sin llegar a encontraros (si, a vosotros). 

Yeeply es el nombre de esta plataforma online que pone en contacto a profesionales en busca de proyectos en los que participar, y a empresas que buscan soluciones en el campo de la tecnología de mayor alza del mercado, la tecnología móvil.

Es decir, está pensada para el desarrollo de apps móviles de todos los niveles y plataformas, publicidad móvil interactiva, etc. 

En un momento en que la tecnología móvil es un indispensable en las vidas y negocios, a veces (y como desarrollador doy fe de ello), es dificil encontrar algunos proyectos en los que participar, aunque en realidad, haya empresas de sobra buscando programadores para esta tarea. Yeeply se encarga de citar ambas partes: profesional y empresa, de forma online para llegar a un acuerdo de desarrollo.

Los expertos,  tienen disponible un importante catálogo de proyectos registrados por los Clientes o Empresas,que tienen una idea o necesidad que necesitan sea llevada a cabo por estos Expertos.

 Los desarrolladores realizan ofertas para los proyectos presentados, hasta que finalmente la empresa se decanta por un profesional. 

En este sentido hay un punto muy a favor en lo que a calidad se refiere: ambas partes serán evaluada por la otra. Esto, llegado a un número considerable de votos, puede darnos una fiabilidad muy importante, del nivel de confianza que por ejemplo, nos pueden dar los votos de eBay en su proceso de compraventa, donde los votos de un vendedor siempre son decisivos.

Además Yeeply cuenta de inicio con todo el apoyo de Plug and Play, la potente aceleradora de Silicon Valley, lo que otorga una calidad superior al proyecto.

Pero esto no es un portal de búsqueda de empleo. Es la reinvención de este tipo de portales, ya que aquí los profesionales, tendrán un perfil atractivo en el que mostrar de forma elegante y llamativa, que proyectos han realizado, pudiendo demostrar su valía para destacar por encima de otros.

Así mismo las empresas podrán detallar sus proyectos y la cuantía que tienen pensada para el proyecto planteado.

Como vemos la lista de perfiles no es tan cerrada como puede ser, podemos encontrar:

    – Desarrolladores de aplicaciones

    – Diseñadores

    – Expertos SEO

    – Publicistas

O simplemente, expertos en “algo” referente a estos campos, ya que el abanico sería dificil de cerrar a solo unos perfiles.

El perfil del profesional, así como sus proyectos son públicos en la red, incluídas las búsqueda de Google, a menos que se solicite lo contrario. 

Así mismo los datos de contactos solo estarán disponibles para la empresa registrada en Yeeply, en caso de llegar Empresa y Experto a un acuerdo.

Yeeply funciona con un sencillo sistema de créditos en el que tanto realizar una oferta (en el caso del experto), como aceptar una oferta (en el caso del cliente) tiene un coste fijo de 10 créditos por oferta.

Se pueden conseguir créditos de diferentes maneras:

• Invitando a expertos a unirse a la plataforma = 25 créditos por cada experto
• Invitando a clientes que publican proyectos = 50 créditos por cada cliente
• Registrarse en Yeeply siendo recomendado = 25 créditos
• Comprando créditos a través de Paypal.
  • 9,90 € = 100 créditos
  • 15,90 € = 200 créditos
  • 24,90 € = 400 créditos

Además Yeeply paga un 10% de comisión por todos los gastos realizados por tus recomendados en la plataforma, por lo que recomendamos únicamente invitar a expertos o clientes reales. Todas las invitaciones serán comprobadas y acreditadas.

Así mismo publicar proyectos en Yeeply es totalmente gratuito y no consume ningún crédito, de forma que el aumento de proyectos crezca de forma considerable.

Registrase en Yeeply es muy sencillo y apenas requiere unos pasos y la confirmación por email.

Además el proyecto que actualmente está disponible solo en Español, muestra claramente su intención por añadir Inglés, Francés y Alemán a su interfaz, lo cual, hace crecer las posibilidades de alcance de empresas y profesionales. Estaremos muy atentos.

Para finalizar os dejamos con un vídeo en el que el propio equipo de Yeeply nos explican mejor que nosotros, en que consiste esta gran plataforma.

Bueno, hasta aquí nuestra visión de Yeeply en Apprendemos.com

Ahora solo queda lo más importante, conocer vuestra opinión. Os animamos a todos a probarlo y a comentar aquí vuestra experiencia.

Últimamente, cuando echo un vistazo en el trabajo a los blogs que sigo en Google Reader, me canso con facilidad porque el porcentaje de artículos sobre rumores y denuncias de patentes es ciertamente muy elevado.

Sin embargo de vez en cuando encuentras cosas muy interesantes como en esta ocasión, una herramienta, que si bien había oído hablar de ella, no me había parado aún a mirar.

Se trata de MonoTouch, un framework que viene para deleitar a aquellos developers que ya sea por falta de tiempo, de medios o de conocimiento, no ven el momento de empezar a desarrollar una aplicación para dispositivos iOS (iPhone – iPad).

MonoTouch permite programar en un lenguaje tan conocido y extendido como es C# o .NET. Como muchos sabrán, y si no, es el momento, las aplicaciones iOS se programan en Xcode en un lenguaje de alto nivel no demasiado parecido a ningún otro, el cada vez más conocido Objective-C.

El número de desarrolladores .NET es más que elevado así como las ofertas de trabajo, que si bien no tan bien pagadas como las ofertas de iOS, es evidente que es una apuesta segura en toda empresa de desarrollo.

Ahora los desarrolladores que vengan de .NET, o incluso de Java, que no diferencia demasiado del lenguaje elegido por Microsoft, podrán crear sus propias aplicaciones e incluso reutilizar muchas de sus librerías ya creadas para sus nuevas aplicaciones iPhone.

Y lo mejor del framework es que no solo permite realizar las aplicaciones para iOS, también nos permite crear aplicaciones Android o Windows Phone  lo que hasta cierto punto puede ahorrar muchísimo tiempo de desarrollo a quien no sea experto en estas plataformas.

Así mismo el diseño de interfaces se puede realizar en Xcode (Interface Builder) e importarlo en MonoTouch, ya que como sabréis el diseño de interfaces iOS es muy agradable, no siendolo tanto el de Android.

 La mayoría pensaréis que con este tipo de Frameworks no es posible crear aplicaciones suficientemente útiles o atractivas. En este punto, como desarrollador iOS he de decir que obviamente no vamos a conseguir los mismos resultados. Pero cabe destacar dos tipos de finalidad. 

Si la finalidad es conseguir hacer alguna que otra aplicación con ciertas funcionalidades, que ojo, no son pocas, pues usaremos MonoTouch (o Mono for Android).

Si en cambio lo que queremos es dedicarnos a realizar aplicaciones explotando al máximo el SDK de cada plataforma, lógicamente necesitamos programar en Xcode, o el SDK de la plataforma elegida.

Así mismo, os dejo con un enlace a los ejemplos de aplicaciones creadas con MonoTouch iOS y Mono para Android

App Samples with MonoTouch

App Samples with Mono for Android

Además podéis echar un ojo a estas apps de Rdio, creadas con Mono.

Comentar que MonoTouch cuenta con los siguientes precios por año:

• Gratis: solo en simulador
• Profesional: 399$
• Empresa: 999$

Además de otros planes de empresa y de renovación.

Si alguno se anima con MonoTouch, por favor os pedimos, nos comentéis como os ha ido la experiencia de iOS & Android en .NET

Hoy os traemos un recurso que estoy seguro vais a utilizar más de una vez.

Cuando queremos personalizar un elemento de nuestra UI que incorpore texto, y por tanto queremos utilizar una fuente personalizada como ya vimos en este tutorial anterior, solemos recurrir al típico: 

UIFont *altFont = [UIFont fontWithName:@"Courier-Bold" size:14.0];

Donde la inmensa mayoría de las veces el nombre de nuestro fichero de fuente NO COINCIDE con el nombre real de la fuente, y por tanto si no lo conocemos, nos cuesta un rato conseguir el correcto o muchos intentos probando combinaciones lógicas, en los que alguna vez llegamos a desistir.

Para solucionar este problema os traigo este listado de nombres de fuentes, que aunque no he probado el 100%, la mayoría de ellos me han funcionado.

La idea es que todos aquellos que conozcáis o encontréis otros que no estén en la lista, lo compartáis en los comentarios, de forma que podamos seguir ampliando este recurso, que sé que será de utilidad, como mínimo para mi, y espero que para todos vosotros.

•  Courier
  • @”Courier”
  • @”Courier-BoldOblique”
  • @”Courier-Oblique”
  • @”Courier-Bold”

•  AppleGothic
  • @”AppleGothic”

•  Arial
  • @”ArialMT”
  • @”Arial-BoldMT”
  • @”Arial-BoldItalicMT”
  • @”Arial-ItalicMT”

•  STHeiti TC
  • @”STHeitiTC-Light”
  • @”STHeitiTC-Medium”

•  Hiragino Kaku Gothic ****
  • @”HiraKakuProN-W6″
  • @”HiraKakuProN-W3″

•  Courier New
  • @”CourierNewPS-BoldMT”
  • @”CourierNewPS-ItalicMT”
  • @”CourierNewPS-BoldItalicMT”
  • @”CourierNewPSMT”

•  Zapfino
  • @”Zapfino”

•  Arial Unicode MS
  • @”ArialUnicodeMS”

•  STHeiti SC
  • @”STHeitiSC-Medium”
  • @”STHeitiSC-Light”

•  American Typewriter
  • @”AmericanTypewriter”
  • @”AmericanTypewriter-Bold”

•  Helvetica
  • @”Helvetica-Oblique”
  • @”Helvetica-BoldOblique”
  • @”Helvetica”
  • @”Helvetica-Bold”

•  Marker Felt
  • @”MarkerFelt-Thin”

•  Helvetica Neue
  • @”HelveticaNeue”
  • @”HelveticaNeue-Bold”
•  DB LCD Temp
  • @”DBLCDTempBlack”

•  Verdana
  • @”Verdana-Bold”
  • @”Verdana-BoldItalic”
  • @”Verdana”
  • @”Verdana-Italic”

•  Times New Roman
  • @”TimesNewRomanPSMT”
  • @”TimesNewRomanPS-BoldMT”
  • @”TimesNewRomanPS-BoldItalicMT”
  • @”TimesNewRomanPS-ItalicMT”

•  Georgia
  • @”Georgia-Bold”
  • @”Georgia”
  • @”Georgia-BoldItalic”
  • @”Georgia-Italic”

•  STHeiti J
  • @”STHeitiJ-Medium”
  • @”STHeitiJ-Light”

•  Arial Rounded MT Bold
  • @”ArialRoundedMTBold”

•  Trebuchet MS
  • @”TrebuchetMS-Italic”
  • @”TrebuchetMS”
  • @”Trebuchet-BoldItalic”
  • @”TrebuchetMS-Bold”

•  STHeiti K
  • @”STHeitiK-Medium”
  • @”STHeitiK-Light”

• Helvetica
  • @”Helvetica-Oblique”
  • @”Helvetica-BoldOblique”
  • @”Helvetica”
  • @”Helvetica-Bold”

• Marker Felt
  • @”MarkerFelt-Thin”

• AppleGothic
  • @”AppleGothic”

Desde el primer iPad la gente viene reclamando y sobre todo, rumoreando a cerca del nuevo modelo mini. Sin embargo los últimos meses los rumores han ido mostrando uno a uno todos los componentes del nuevo dispositivo que hoy por fin ha visto la luz en la keynote de Apple.

El iPad mini estará disponible en España el próximo 2 de Noviembre de 2012.

El primer iPad salió hace 10 años, hoy hace 11 del primer iPod, y aunque por aquel entonces a muchos les costó entender el significado, toda marca que se precie se ha unido al desarrollo de estos dispositivos.

El iPad Mini surge para cubrir dos puntos clave, uno el hecho de aquellos que buscan un tablet mucho más manejable, pues a todos nos gusta ir a todas partes con él, y el actual iPad se hacia de rogar a la hora de llevarlo por ejemplo en el metro.

La otra para enfrentarse un poco al resto de compañías como son Google, Amazon y Microsoft que empiezan a crecer notablemente en un mercado algo más económico y que al final, mueve cifras muy temibles para la compañía de Cupertino.

El nuevo iPad Mini tiene un grosor de 7.2 mm y pesa tan solo 308 gramos.

La pantalla, la que lo hace Mini, es de 7,9 pulgadas y una resolucion de 1024 x 768 pixels.

En la Keynote no ha podido faltar una comparación con el Nexus 7 de Google del que ya os hemos hablado en alguna ocasión. Entre otras cosas, en la keynote se ha mencionado que pese a tener una dimensión similar, la pantalla del iPad Mini es más grande, y por supuesto se vuelve a hacer incapie en la diferencia entre el plástico de Google y el aluminio satinado de Apple.

Si bien a muchos no les ha gustado demasiado las características técnicas, creemos que son las esperadas para un dispositivo de menor coste que el iPad padre. 

• Chip A5, al igual que el iPhone 4S y el iPad 2P
• Procesador Dual Core de 1 Ghz.
• Cámara trasera de 5 Mpx 
• Cámara frontal HD para FaceTime.
• Conexión LTE
• Nuevo conector Lightning

Y el video oficial del nuevo iPad Mini:

Así que ya sabeis, os está esperando.

A todos los que lo compreis, no olvideis comentarnos en los comentario lo que os ha parecido para que todos estemos al tanto.

Si os gusta lo que hacemos recordar votarnos en los Premios Bitacoras 2012 desde este link.

Participamos en las categorías de Educación y Tecnología.

Las clasificaciones actuales nos sitúan en:

• Puesto 70 en la clasificación de Educación 2012
• Puesto 93 en la clasificación de Tecnología 2012

Ambas posiciones son toda una alegría para nosotros ya que empezamos hace apenas 3 meses y la acogida por vuestra parte ha sido todo un éxito.

Para nosotros es un placer ver que lo que hacemos tiene sentido para vosotros.

Así que ánimo, votar, comentar y programar!

Saludos,

Manu =D

Hoy os traemos un nuevo tutorial de HTML5.

Entre otras características, HTML5 destaca por el enorme potencial del nuevo elemento Canvas.

El elemento Canvas es un entorno para crear imágenes de forma dinámica. Para crear una sección o elemento de cambas basta con crear su etiqueta y definir una dimensión.

Si insertamos cualquier elemento entre las etiquetas del canvas, únicamente será visualizado por aquellos navegadores que no soportan el Canvas o HTML5.

Esto es útil ya que podemos definir un texto por defecto para los que no ven el canvas, a la vez que para los que sí, mostramos la imágen dinámica.

Todo el proceso de dibujado se hace en JavaScript. Lo único que necesitamos es recuperar el elemento Canvas y obtener su contexto.

El API 2D permite utilizar características que encontramos de normal en herramientas de diseño gráfico: líneas o trazos, rellenos, gradientes, formas, sombras, etc.

No obstante todo esto debe realizarse lógicamente por código. Es algo lento de crear hasta que vamos cogiendo habilidad.

Para este tutorial vamos a crear al completo el logo de Apprendemos.com que utilizamos en las webs o en twitter.

Empezaremos creando el cuadrado azul sin redondear los bordes para que quede claro el uso. Después pasaremos a crearlo con los correspondientes bordes.

Una vez hecho, insertaremos una serie de formas, así como el texto necesario.

Y por último el efecto lúcido (gloss) típico de aplicaciones iOS.

Vamos a ello.

Creamos un documento HTML con la siguiente estructura en el body:

<body>
    <canvas id="polygons" width="300" height="300">
        <p>Su navegador no soporta HTML5</p>
        </canvas>
</body>

Como vemos hemos añadido el elemento dentro del. Este elemento es el encargado de mostrar lo que definamos mediante JavaScript.

Pasamos a añadir el evento OnLoad aly su correspondiente función JavaScript:

 <body onLoad="simpleCanvas();">

        <script type="application/x-javascript">
            function simpleCanvas() {
 
                /* Recuperamos el canvas */
                var canvas = document.getElementById("polygons");
 
                if (canvas.getContext) {
 
                    /* Obtenemos el contexto plano (2d) */
                    var ctx = canvas.getContext("2d");
 
                    /* Establecemos el valor RGB del primer polígono */
                    ctx.fillStyle = "rgb(41,155,243)";
 
                    /* Con fillRect crearemos un rectangulo los numeros correscponden:  */
                    /* los 2 primeros a las coordenadas y los otros tamaño (x,y,ancho,alto)  */
 
 
                    ctx.fillRect (10, 10, 180, 180);
 
 
                }
            }
        </script>

        <canvas id="polygons" width="300" height="300">
            <p>Su navegador no soporta HTML5</p>
        </canvas>
    </body>

Si probamos los resultados en el navegador podremos ver el cuadrado creado de color azul. Para probar que se muestra el mensaje en caso de no ser compatible, lo más fácil en probar con alguna versión de Internet Explorer, ya que será de las más fáciles en ser incompatible con cualquier cosa =p

Una vez hemos visto el uso del FillRect(), la parte más fácil y común de Canvas, lo vamos a sustituir para crear el mismo fondo con sus bordes redondeados.

Para ello debemos parar a explicar las siguientes funciones de HTML5 de forma breve pero necesaria.

fill(); Sirve para dibujar el relleno del polígono que hemos definido.

stroke(); Sirve para dibujar el trazo del polígono definido.

fillStyle = “rgb(41,155,243)”; Define un color RGB para el dibujo.

fillStyle = “rgba(255, 255, 255, 1.0)”; Define un color RGB para el dibujo, pero con canal alfa, es decir, habilitando transparencia.

beginPath(); comienza un nuevo polígono, del que una vez definido, podremos dibujar el trazo (stroke) o el relleno (fill).

moveTo(x, y); Permite desplazar el punto desde el que se pinta, o se sigue pintando a a posición deseada.

lineTo(x, y); Dibuja una linea desde la posición actual hasta la indicada por x e y.

quadraticCurveTo(x_curva, y_curva, x_destino, y_destino); Permite crear una curva de Bézier. El origen de la curva, será el punto actual en el que nos encontremos.

El destino estará marcado por x_destino, y_destino. X_curva y Y_Curva será el punto hacía el que la linea se desvía realizando entonces la curva deseada.

Una vez conocidas estas herramientas, pasaremos a utilizarlas para crear nuestro fondo:

 function simpleCanvas() {
       /* Recuperamos el canvas */
       var canvas = document.getElementById("polygons");
 
 
 
                if (canvas.getContext) {
                /* Obtenemos el contexto plano (2d) */
                var ctx = canvas.getContext("2d");
 
                /* Establecemos el valor RGB del primer polígono */
                ctx.fillStyle = "rgb(41,155,243)";
 
 
 
 
 
                    // Comenzamos un trazo
                    ctx.beginPath();
 
 
 
                    // Desplazamos el punto a la posición 10,10
                    ctx.moveTo(10, 10);
 
 
 
                    // Dibujamos una línea horizontal parando 25px antes de el vértice del cuadrado.
                    ctx.lineTo(165, 10);
 
 
 
                    // Aquí será donde empiece la superior derecha.
 
                    // Desde el punto anterior, definimos como primer parámetro de quadraticCurveto el vértice del cuadrado (hacia donde irá la curva de Bézier).
 
                    // Y como punto destino, el punto 25px por debajo del vértice.
 
                    ctx.quadraticCurveTo(190, 10, 190, 35);
 
 
 
                    // Repetimos el proceso. 
 
                    // Dibujamos una línea hasta 25px antes del vértice inferior derecha.
 
                    // Como vemos estamos dibujando el cuadrado en sentido de las agujas del reloj.
 
                    ctx.lineTo(190, 165);
 
                    // Dibujamos la siguiente curva.
 
                    ctx.quadraticCurveTo(190, 190, 165, 190);
 
 
 
                    // Y repetimos con los otros dos vértices:
 
                    ctx.lineTo(35, 190);
 
                    ctx.quadraticCurveTo(10, 190, 10, 165);
 
                    ctx.lineTo(10, 35);
 
                    ctx.quadraticCurveTo(10, 10, 35, 10);
 
 
 
                    // Por último pintamos el resultado
 
                    ctx.fill();
 
                }
 
            }

Probaremos en el navegador que el resultado es el deseado. Podemos ver el fondo azul redondeado.

La función arc() se utiliza para crear arcos, es decir, circunferencias completas o incompletas (una tarta sin una porción^^).

Por tanto, a continuación de “ctx.fill();” que acabamos de hacer, añadimos el siguiente fragmento para crear los 4 puntos blancos de arriba y abajo del logo.

 
                /* Damos color igual que en el anterios pero esta vez */
 
                    /*"rgba" añadiendo un numero más */
 
                    /*que en este caso serrá la transparencia */
 
                    ctx.fillStyle = "rgba(255, 255, 255, 1.0)";
 
 
 
                    // Superior primero
 
                    ctx.beginPath();
 
                    ctx.arc(110, 25, 5, 0, Math.PI*2, true);
 
                    ctx.fill();
 
 
 
                    // Superior segundo
 
                    ctx.beginPath();
 
                    ctx.arc(135, 25, 7, 0, Math.PI*2, true);
 
                    ctx.fill();
 
 
 
 
 
                    // Inferior primero
 
                    ctx.beginPath();
 
                    ctx.arc(65, 175, 7, 0, Math.PI*2, true);
 
                    ctx.fill();
 
 
 
                    // Inferior segundo
 
                    ctx.beginPath();
 
                    ctx.arc(90, 175, 5, 0, Math.PI*2, true);
 
                    ctx.fill();

Ahora vamos a dibujar los polígonos en forma de L de las dos esquinas.

Aquí utilizaremos closePath() que lo que hará es unir el punto original coń el último añadido de forma que el polígono siempre cierre.

Esto no es necesario porque podemos poner el último punto igual que el primero, quedando también cerrado.

A continuación de lo anterior, ponemos lo siguiente:

                    ctx.beginPath();
 
                    ctx.moveTo(150, 19);
 
                    ctx.lineTo(150,31);
 
                    ctx.lineTo(170,31);
 
                    ctx.lineTo(170,54);
 
                    ctx.lineTo(182,54);
 
                    ctx.lineTo(182, 31);
 
                    ctx.lineTo(182, 19);
 
                    ctx.closePath();
 
                    ctx.fill();
 
 
 
 
 
                    ctx.beginPath();
 
                    ctx.moveTo(18, 150);
 
                    ctx.lineTo(30,150);
 
                    ctx.lineTo(30,169);
 
                    ctx.lineTo(51,169);
 
                    ctx.lineTo(51,181);
 
                    ctx.lineTo(18,181);
 
                    ctx.closePath();
 
                    ctx.fill();

Como vemos este punto también era facil.

Ahora pondremos las letras “App” en el centro. Insertar texto también es muy facil. Seguido de lo anterior pondremos este fragmento:

 
                    // Definimos una fuente y un tamaño de letra.
 
                    ctx.font = '90px sans-serif';
 
 
 
                    // Podemos establecer la alineación base.
 
                    ctx.textBaseline = 'bottom';
 
 
 
                    // Y solo queda utilizar fillText para definir el texto a mostrar y la posición de origen.
 
                    ctx.fillText('App', 20, 140);

El resultado ya empieza a parecerse bastante al logo de Apprendemos.com, pero todavía quedará añadir nuestro iPhone y el efecto gloss sobre el logo.

Comencemos por el efecto gloss que no afecta a toda la imagen, y por tanto, no importa si el iPhone lo insertamos después.

Si nos fijamos en la forma. La parte superior debe tener la misma forma que el fondo azul, es decir, utilizaremos sus curvas.

La parte inferior va a terminar antes y con una más pronunciada. En este caso en vez de hacerla con una diferencia de 25px,

la haremos directamente hasta el centro (95px) para que una curva termine donde empieza la otra, dándonos la impresión de ser una sola.

                    ctx.fillStyle = "rgba(180, 218, 246, 0.3)";
 
 
 
                    ctx.beginPath();
 
                    ctx.moveTo(10, 10);
 
                    ctx.lineTo(165, 10);
 
                    ctx.quadraticCurveTo(190, 10, 190, 35);
 
                    ctx.lineTo(190, 75);
 
                    ctx.quadraticCurveTo(190, 100, 100, 100);
 
                    ctx.lineTo(100, 100);
 
                    ctx.quadraticCurveTo(10, 100, 10, 75);
 
                    ctx.lineTo(10, 35);
 
                    ctx.quadraticCurveTo(10, 10, 35, 10);
 
                    ctx.fill();

Y solo nos queda dibujar nuestro iPhone.

Comenzaremos por la capa inferior para ir superponiendo el resto.

Primero creamos la carcasa del iPhone:

 
                    //Carcasa iPhone
 
                    ctx.fillStyle = "rgba(0, 0, 0, 1.0)";
 
 
 
                    ctx.beginPath();
 
                    ctx.moveTo(110, 150);
 
                    ctx.lineTo(186, 150);
 
                    ctx.quadraticCurveTo(196, 150, 196, 160);
 
                    ctx.lineTo(196, 186);
 
                    ctx.quadraticCurveTo(196, 196, 186, 196);
 
                    ctx.lineTo(120, 196);
 
                    ctx.quadraticCurveTo(110, 196, 110, 186);
 
                    ctx.lineTo(110, 160);
 
                    ctx.quadraticCurveTo(110, 150, 120, 150);
 
                    ctx.fill();

Después la pantalla:

                    // Pantalla iPhone
 
                    ctx.fillStyle = "rgb(41,155,243)";
 
                    ctx.fillRect (129, 158, 50, 30);

Añadimos el botón, que hará de punto de “.com”:

                    // Botón iPhone
 
                    ctx.fillStyle = "rgba(255, 255, 255, 1.0)";
 
                    ctx.beginPath();
 
                    ctx.arc(120, 173.5, 4, 0, Math.PI*2, true);
 
                    ctx.fill();

Y para terminar, el texto “com” final:

                    // Texto "com"
 
                    ctx.font = '22px sans-serif';
 
                    ctx.textBaseline = 'bottom';
 
                    ctx.fillText('com', 134, 183.7);

Si probamos el resultado en nuestro navegador deberíamos observar una imagen como esta:

Esperamos que os haya gustado el tutorial de como crear formas y polígonos en Canvas de HTML5, y sobre todo, que os haya sido útil.

No olvideis ayudarnos con vuestro voto en Bitacoras.com Participamos en las categorías de Tecnología y Educación.

Sería un placer estar en las listas de clasificados. La motivación a seguir adelante con los tutoriales sería muy grande.

Como siempre, dudas y comentarios de bajo del tutorial.

Y mucho más en Twitter (@Apprendemos) y Facebook.

Saludos,

Manu =D

!Bienvenidos a este tutorial especial que os hemos preparado!

Hay dos motivos por los que puedes haber entrado en este tutorial:

• Desde la aplicación CódigoPostal, disponible en el AppStore
• Buscando un tutorial de:
  • Geocoding: para encontrar una dirección a partir de coordenadas, o al revés.
  • Animación de vistas con QuartzCore.
  • Añadir publicidad de iAds a tu aplicación en iOS
  • Adaptar una aplicación ya hecha al iPhone 5

Iremos añadiendo poco a poco cada uno de estos tutoriales hasta completar la aplicación que hay publicada en este enlace del App Store.

Código Postal

Código Postal es una aplicación creada para que podáis ver en que pocos pasos se puede tener una aplicación publicada en App Store, y que por mínimos que sean, generen beneficios.

En nuestro caso el beneficio es que una vez más Apprendemos.com llegue a todos vosotros por distintas vías.

Aquellos que todavía no la conozcan y descarguen del App Store el app Código Postal, se encontrarán con el enlace a este mismo tutorial, donde descubrirán como poder hacerla.

La aplicación destaca por su simpleza.

Hay dos formas de obtener el código postal deseado:

1. Obtener directamente el código postal de nuestra ubicación.

Bastará pulsar el botón para localizar el código postal.

2. Obtener el Código Postal a partir de la dirección concreta  introducida.

Deberemos poner como mínimo la calle y el municipio de donde deseamos saber el código postal. Así mismo ha de estar escrita correctamente. Una vez más, pulsamos el botón para que obtenga la dirección.

Muchos observaréis que en ciertos puntos no os georeferencia bien, o que si no ponéis una dirección precisa no os encuentra.

Para la aplicación utilizamos ciertos métodos de iOS, bastante más recientes que el Geocoding de Google. Es por esto que la precisión es algo inferior, y que no cuenta con la misma cantidad de información que por ahora, cuenta Google.

Incluso el nombre de las calles acepta menos errores que Google.

Si ponemos Calle Pou del Marqués, encontrará la que buscamos, sin embargo si ponemos Calle Pou Marques no lo hará, a diferencia de Google que sí lo consigue.

Esperamos que este punto mejore y aún así estudiaremos, para futuros tutoriales, como hacer el mismo proceso desde Google.

Si bien también es posible que al intentar recuperar la posición, el lugar en el que estemos no cuenta con código postal, como podría pasar en medio de la montaña, o en lugares en los que ni tan siquiera hay calles declaradas, puesto que estos sitios no hay código postal con la misma seguridad.

El diseño de esta aplicación, así como el próximo diseño de ¿AhoraQuién? viene de la mano de @JamalDols, creador de TuMenteCrea.es, un gran diseñador y buen amigo, que siempre se ofrece a participar en nuevos proyectos.

 Esperamos que os guste esta nueva iniciativa de tutoriales con aplicación publicada.

Podéis descargar el app de este pack de tutoriales desde aquí:

Nos gustaría conocer vuestra opinión aquí, en los comentarios.

Saludos,

Manu =D 

Como puede que sepas, hace apenas tres meses que comenzamos con Apprendemos.com

Los resultados y la buena aceptación por vuestra parte ha sido realmente sorprendente para nosotros, que no contábamos con crecer en cuestión de visitas, ni la participación en los comentarios de cada artículo o tutorial.

Comenzamos Apprendemos como una mezcla entre ganas de dar a conocer, crear un cuaderno de campo de nuestro propio trabajo, y comenzar un proyecto que nos apetecía hacer.

A día de hoy, estamos intentado sacar más tiempo para cubrir la demanda, ya que por ahora no podemos publicar todo lo que nos gustaría ya que es un blog redactado en el tiempo libre, y por tanto, a veces se hace muy difícil actualizar, sobre todo hacer tutoriales que llevan mucho trabajo por detrás.

Sin embargo, nos habéis apoyado en las redes sociales (Facebook y Twitter), ha aumentado considerablemente el número de visitas, incluso otras webs como Microsiervos, han puesto su grano de arena en comentar a cerca de nosotros. Y la verdad, recompensa, y ojalá que un día podamos dedicar nuestro tiempo de trabajo directamente a la web y los proyectos que la puedan rodear.

Y después de esta reflexión, demos pie al título de este post.

Como la mayoría sabréis los Premios Bitácoras son un refente nacional, donde se premia y clasifica en 20 categorías distintas a los blogs españoles. Durante estos meses se celebran los Premios Bitacoras 2012, siendo esta su octava edición.

Las cifras no son cosa boba, ya que hace un año, la pasada edición de los Premios Bitacoras 2012, recogió más de 18.000 blogs y casi 135.000 votos, algo descomunal, pero que a la vez hace ver la cantidad de gente que está, o estamos intentando aportar, lo que sabemos y lo que nos gusta, a la vez que apprendemos de vosotros.

Por tanto, no os vamos a pedir el voto, pero es obvio que nos vendrá muy bien contar con él. Si bien sería muy pronto para ganar, nos hace ilusión ver el resultado de Apprendemos.com, y este sistema de votos, esta participación, sería todo un apoyo moral para seguir haciendo de Apprendemos.com lo que realmente tenemos en mente, que os aseguro, no es poco.

Desde aquí, o desde la imagen junto al logo de la web, podéis votar por Apprendemos en los Premios Bitacoras 2012, en las categorías de Educación y Tecnología, que a nuestro parecer, son las más adecuadas.

Solo daros las gracias por el apoyo que siempre nos ofrecéis. Vamos a seguir publicando el contenido que quereis. Tutoriales de programación iOS, Android, HTML5, CSS3,  .NET, las últimas novedades de dispositivos y aplicaciones y mucho más!

Como habréis visto por ahora casi todo es para iPhone – iPad, a excepción de alguna cosa de Android o HTML5. Poco a poco vamos intentando ampliar y diversificar.

También os invitamos a recurrir al formulario de contacto de la web para mostrar vuestro interés en participar en Apprendemos.com como editores, o para proporcionarnos notas de prensa y demás artículos de interés para todos, ya que por ahora estamos abiertos a muchas posibilidades de colaboración.

Un saludo y gracias a todos!

¿Apprendemos? :p

Desde hace ya tiempo se viene hablando del próximo lanzamiento en lo que a dispositivos Apple se refiere, y es que apenas ha salido el iPhone 5, pero ya hacía tiempo que el iPad Mini estaba en boca de todos.

Y es que, si algo le faltaba al iPad era su hermano pequeño, algo más manejable. La escusa de que en tan poco espacio, no se podía aprovechar el sistema, a quedado atrás pues si los rumores no fallan, y todos sabemos que fallan poco, 

el nuevo iPad Mini sería presentado el 17 de Octubre de 2012, recibiéndose las invitaciones al evento el día 10 de Octubre.

En las imágenes que han dado vueltas por la red podemos ver la comparativa física entre el Apple iPad Mini, el Kindle Fire HD y el Google Nexus 7. Todos ellos de dimensión similar. Como vemos Apple sigue apostando por acabados de aluminio, limpios y bien pulidos, mientras que las otras marcas continúan apostando por material plásticos, con diferentes texturas.

Si bien intentamos pensar que se utiliza plástico a fin de economizar los dispositivos, también recogemos opiniones de gente que argumenta preferir el plástico, sobre todo rugoso, a fin de una mejor sujeción. 

Por ahora todos estamos a la espera, sobre todo, los desarrolladores, que si bien deseamos tenerlo, también nos preocupa como en el iPhone 5, la proporción de pantalla para diseñar aplicaciones compatibles con todos los dispositivos.

Y como siempre, en cuanto lo tengáis, nos lo contáis debajo, o en el formulario de contacto, para que si nos parece correcto, lo publiquemos en este mismo artículo.

Recordar que nos podéis seguir en Twitter y Facebook

Saludos,

Manu =D