Al acabar la WWDC, Apple entregó a los desarrolladores que asistieron una versión de prueba de su nuevo IDE (Entorno de Desarrollo Integrado), Xcode 4.

Con Xcode 4 puedes desarrollar aplicaciones para iPhone, iPad, iPod Touch y para cualquier Mac todavía más rápida y fácilmente.

También puedes crear Widgets de Dashboard o crear WebApps, mientras analizas el funcionamiento de tus aplicaciones.

Xcode 4 tiene una nueva interfaz de usuario y el flujo de trabajo ha sido rediseñado, además incluye mejoras y nuevos componentes para compilar, depurar (debug) y encontrar errores y problema comunes. El resultado es un programa más rápido, sencillo y productivo para los desarrolladores.

La mayor novedad es el uso de una ventana única y la integración de Interface Builder en Xcode. Hereda algunos elementos de iTunes como la pantalla similar a LCD de la parte superior que proporciona diferente información según cada momento.

Ahora Interface Builder está incluido en Xcode por lo que la manee de programar aplicaciones será más rápida pero ligeramente diferente (actualizaremos los tutoriales que tenemos preparados para publicarlos directamente en Xcode 4).

Nuevos asistentes y vistas duales permiten trabajar simultáneamente en el código y la interfaz de una aplicación.

Las mejoras en la depuración del código incluyen Fixit (una especia de corrector ortográfico para funciones, clases, variables, etc.) o versiones mejoradas de otras como Análisis Estático que es capaz de predecir errores y “leak” de memoria antes de ejecutar la aplicación. Además incluye un utilidad para comparar archivos a lo largo del tiempo con una interfaz parecida a Time Machine.

También incluirá una nueva versión de Instruments, la utilidad con la que podrás analizar el funcionamiento de tus aplicaciones y cada pequeño detalle de estas. Un nuevo compilador LLVM mucho más rápido y eficaz tendrá presencia en Xcode 4, capaz de compilar y ejecutar código de Mac un 25% más rápido y código de iOS un 60%.

Todavía no hay una fecha de salida concreta para Xcode 4 pero los que la han probado coinciden es su estabilidad y en lo rápido y cómodo que es.

Esperemos que pronto Apple decida lanzar la versión final, y que todos vayamos aprendiendo a hacer aplicaciones para iPhone 4 con esta nueva versión.

Haciendo que todo funcione

Como puedes ver en el último ejemplo de la 2ª parte [10], tenemos la función principal “main()” [10.1] y otra función que definimos nosotros mismos [10.13].  Si tuviéramos que compilar ese código, el compilador aún encontraría obstáculos. En la línea [10.8] podría demandar no conocer ninguna función llamada circleArea(). ¿Por qué? Aparentemente, el compilador comienza leyendo la función principal y de repente encuentra algo que no conoce. No buscará nada más y te mostrará este mensaje de alerta. Para satisfacer al compilador, simplemente añade la declaración de una función antes de la línea que contiene “int main()” [11.1]. No pasaría nada por que se tratara de la misma línea, salvo que ésta terminará con el signo de punto y coma. Ahora el compilador no se sorprenderá cuando encuentre la llamada a la función.

// [11]
float circleArea(float theRadius);    // Declaración de la función
 
int main()
{
// El código de la función main() iría aquí...
}

nota: El resto del programa no se muestra.

Pronto compilaremos este programa en la realidad. Primero un par de impares y finales.

Cuando escribimos un programa, puede aconsejarse tener en cuenta la posibilidad de reutilizar el código en el futuro. Nuestro programa podría tener una función llamada “rectangleArea()” como se muestra a continuación [12.1] y esa función podría ser llamada en nuestra función principal “main()”. Esto es útil tanto si el código que ponemos en una función es tan sólo utilizado una vez. La función “main()” será más sencilla de leer” Si tienes que resolver los bugs del código, será más fácil localizar dónde podrían encontrarse dentro de tu programa. Podrías saber que los bugs están en una determinada función. En lugar de tener que moverte a través de una enorme secuencia de órdenes, simplemente tendrás que chequear las líneas de la función, que son más fáciles de encontrar, gracias a la apertura y cierre de las llaves { }.

// [12]
float rectangleArea(float length, float width)
{
return (length * width)
}
 

Como puedes ver en un caso sencillo como éste, es posible tener una única orden [12.3] tanto para el cálculo como para la devolución del resultado. Utilicé la variable superflua “theArea” en [10.15] sólo para mostrarte cómo declarar la variable en una función.

Mientras que las funciones que definamos por nosotros mismos en este capítulo son algo triviales, es importante darse cuenta que nosotros podemos modificar una función sin afectar en el código que la llama mientras no cambiemos la declaración de la función (por ejemplo, en la primera línea).

Por ejemplo, puedes cambiar los nombres de las variables de una función y la función todavía funcionará (y esto tampoco afectará al resto del programa). Algún otro podría escribir la función y podrías usarla sin saber qué es lo que va dentro de la función.. Todo lo que necesitas saber es cómo usarla. Y esto quiere decir conocer:

• El nombre de la función
• El número, orden y tipco de los argumentos (arguments) de la función
• Lo que la función devuelve (el valor del área de la superficie del rectángulo) y el tipo de resultado.

En el ejemplo [12], estas respuestas son, respectivamente:

• rectangleArea
• Dos argumentos: ambos decimales (floats) en el que el primero representa la longitud y el segundo la anchura.
• La función devuelve algo, y el resultado es de tipo decimal (como puede percibirse desde la primera palabra del código [12.1]).

Variables Blindadas (shielded variables)

El código de dentro de una función está blindado respecto al programa principal y a las demás funciones.

Lo que esto significa es que el valor de una variable dentro de una función, por defecto no está afectada por otra variable o por otra función, incluso aunque tenga el mismo nombre. Esta es una de las características principales del Objective-C. En el capítulo 5, veremos de nuevo este comportamiento, pero antes, vamos a comenzar a utilizar el Xcode y hacer que funcione nuestro programa [10].

Argumentos (Arguments)

Vamos a añadir un par de nombres de variable del tipo decimal [4.4] e iniciaremos la variable circleRadius, por ejemplo le daremos un valor [4.4], en el que la función circleArea() será “llamada”. Como puedes ver, el nombre de la variable circleRadius ha sido puesta entre los signos de paréntesis. Esto es un “argument” de la función “circleArea()”. Cuando la función “circleArea()” ha hecho su trabajo de cálculo, deberá devolver un resultado. Vamos a modificar la función de [3] para reflejar esto [5]:

Nota: sólo la función “circleArea()” será mostrada:

// [5]
circleArea(float theRadius) // [5.1]
{
float theArea;
theArea = 3.1416 * theRadius *theRadius; // pi por radio al cuadrado, π · r2
return thArea;
}

En [5.1] definimos que para la función circleArea() será necesario introducir un valor decimal… Cuando se recibe, este valor es almacenado en la variable llamada theRadius. Usamos una segunda variable a la que llamaremos theArea para almacenar el resultado del cálculo de la línea [5.4], por lo que deberemos declararla [5.3] del mismo modo que las declarábamos en la función “main()” [4.4]. Te darás cuenta que la declaración de la variable theRadius está realizada en paréntesis [5.1]. La línea [5.5] devuelve el resultado de la parte del programa desde la que la función ha sido llamada. como resultado, en la línea [4.11] la variable circleSurfaceArea está puesta en este valor.

La función del ejemplo [5] está completa, salvo por una cosa: No hemos especificad el tipo de datos que la función deberá devolver. El compilador requiere que lo hagamos así que no tenemos más opción que obedecer e indicar que el tipo es decimal [6.1].

// [6]
float circleArea(float theRadius) // [6.1]
{
float theArea;
theArea = 3.1416 * theRadius * theRadius;
return theArea;
}

Como indica la primera palabra de la línea [6.1], el dato que devuelve esta función (por ejemplo, el valor de la variable theArea) es del tipo decimal. Como programador, deberás asegurarte que la variable circleSurfaceArea en la función “main()” [4.8] es de esemismo tipo de dato de manera que el compilador no motivos para quejarse en este punto.

No todas las funciones requieren un “argument”. Aún así, aunque no haya uno, el paréntesis será necesario incluso cuando deba estar vacío.

// [7]
int throwDice()
{
int noOfEyes;
// Código para generar un valor aleatorio del 1 al 6
return noOfEyes;
}

Devolviendo valores

No todas las funciones devuelven un valor. Si una función no devuelve un valor, será del tipo “void” (vacío). La línea de código de la devolución del valor será, por tanto, opcional. Pero si la utilizas, la palabra “return” no deberá ir seguida de ningún valor o nombre de variable.

// [8]
void beepXTimes(int x);
{
// Código para hacer beep x veces.
}

Si una función tiene más de una orden, como en la función picureSurfaceArea() que aparece a continuación, las órdenes deberán estar separadas por una coma:

// [9]
float pictureSurfaceArea(float theWidth, float theHeight)
{
// Código para calcular el área de la superficie
}

La función “main()” debería, por conveniencia, devolver un número entero, y sí: también posee una orden de devolución (return). Podría devolver 0 (cero, [10.9]) para indicar que la función se ha ejecutado sin problemas. Como la función “main()” devuelve un entero, deberemos escribir “int” antes de “main()” [10.1]. Vamos a poner todo el código que tenemos en una lista:

// [10]
int main()
{
float pictureWidth, pictureHeight, pictureSurfaceArea,
circleRadius, circleSurfaceArea;
pictureWidth = 8;
pictureHeight = 4.5;
circleRadius = 5.0;
pictureSurfaceArea = pictureWidth * pictureHeight;
return 0;   // [10.9]
}
float circleArea(float theRadius)   // [10.12]
{
float theArea;
theArea = 3.1416 * theRadius * theRadius;
return theArea;
}

]]> http://www.applenext.com/2010/05/programar-en-mac-03-las-funciones-ii/feed/ 2 http://www.applenext.com/2010/05/programar-en-mac-03-las-funciones-i/ http://www.applenext.com/2010/05/programar-en-mac-03-las-funciones-i/#comments Mon, 03 May 2010 18:29:25 +0000 Alejo Miranda http://www.applenext.com/?p=1879

Continuamos con nuestro tutorial sobre Programar en Mac. Ahí va la primera parte del Capítulo 3.

Las Funciones

El código más grande que hemos visto tenía como mucho sólo cinco líneas. Aunque todavía quede mucho para llegar a programas con cientos de líneas, la naturaleza del lenguaje Objective-C hace que tengamos que tratar  ya cómo están organizados los programas.

Si los programas van a consistir en una larga y continua sucesión de órdenes de código, deberá entonces ser complicado localizar y solucionar los ‘bugs’ (como ya hemos dicho, son los errores del código). Además, como es lógico, una misma línea de código podrá aparecer en diferentes lugares; y si hay un bug en ese fragmento de código deberás comprobar el mismo bug en todos esos lugares. ¡Una pesadilla porque es muy fácil que nos olvidemos de uno (o dos)! Así que la gente ha tenido que pensar una manera de organizar el código haciéndolo más sencillo para la localización y resolución de bugs.

La solución a este problema es un grupo de órdenes agrupadas dependiendo de su función. Por ejemplo, tu puedes tener un conjunto de líneas de código que te permitan calcular la superficie del área de un círculo. Una vez que lo has chequeado, ese conjunto de órdenes funcionaran correctamente y tú nunca tendrás que volver a ese código para ver si existen bugs en él.

El conjunto de órdenes, llamado una “función”, tiene un nombre y podrás llamar a ese conjunto de órdenes por su nombre para ejecutar su código. Esto de usar funciones es absolutamente fundamental porque siempre hay al menos una función en un programa: la función “main()”. Esta función “main()” es lo que buscará el compilador, y de esta manera sabrá en qué lugar deberá comenzar la ejecución del código.

La función “main()”

Vamos a echar un vistazo a la función “main()” con más detalle [1]:

// [1]
main()
{
// Cuerpo de la función main(). Pon el código aquí
}

En la línea [1.1] se muestra el nombre de la función, por ejemplo “main”, seguida por los signos de abrir y cerrar paréntesis. Mientras “main” es una palabra reservada en el lenguaje de programación, y “main()” es necesaria para estar presente, cuando definas tus propias funciones podrás llamarlas de la manera que más te apetezca. Los paréntesis están allí por una buena razón pero no lo trataremos hasta un poco más tarde en este mismo capítulo.

En las líneas siguientes [1.2, 1.4] hay signos de llaves. Deberás poner tu código entre esos signos { }. Cualquier cosa entre los signos de llaves se conocerá como cuerpo (body) de la función. Vamos a tomar algo de código de los primeros capítulos y colocarlo a continuación [2]:

// [2]
main()
{
// Vamos a declarar las variables
float anchoDeImagen, alturaDeImagen, areaSuperficieDeImagen;
// Iniciamos las variables (otorgamos a cada variable un valor)
anchoDeImagen = 8.0;
alturaDeImagen = 4.5;
// Y ahora vamos a realizar el cálculo
areaSuperficieDeImagen = anchoDeImagen * alturaDeImagen;
}

Nuestra primera función

Si vamos a continuar añadiendo código a la función main(), podríamos acabar con la dificultad de hacer un “debug” (recordemos anteriores capítulos). Vamos a escribir otro programa, ahora con algo de estructura. Aparte de la función obligatoria main(), vamos a crear la función areaDelCirculo() [3]:

// [3]
main()
{
float anchoDeImagen, alturaDeImagen, areaSuperficieDeImagen;
anchoDeImagen = 8.0;
alturaDeImagen = 4.5;
areaSuperficieDeImagen = anchoDeImagen * alturaDeImagen;
}

areaDelCirculo() //[3.9]
{

}

Esa es una manera sencilla, pero nuestra función personal que comienza con una línea [3.9] no hace nada por ahora. Date cuenta que las especificaciones de la función están fuera del “body” de la función “main()”. En otras palabras, las funciones no están “anidadas”.

Nuestra nueva función “areaDelCirculo()” debe ser llamada desde la función “main()”. Vamos a ver cómo se hace eso [4]:

// [4]
main()
{
float anchoDeImagen, alturaDeImagen, areaSuperficieDeImagen,
radioDelCirculo, areaSuperficieDelCirculo; // [4.4]
anchoDeImagen = 8.0;
alturaDeImagen = 4.5;
radioDelCirculo = 5.0; // [4.7]
areaSuperficieDeImagen = anchoDeImagen * alturaDeImagen;

// ¡Y aquí es donde llamamos a nuestra función!

areaSuperficieDelCirculo = areaDelCirculo(radioDelCirculo); // [4.11]

}

Nota: el resto del programa no está mostrado (ver [3]).

Ya tenemos fecha para otra Keynote, y esta vez la cosa promete y mucho.

El día 7 de Junio de 2010 dará comienzo la WorldWide Developers Conference, algo así como la Conferencia Mundial de desarrolladores de Apple (si estás siguiendo nuestro tutorial para Programar en Mac puedes considerarte uno de ellos).

Se da por hecho que el nuevo iPhone 4 será presentado por el tito Jobs el día 7.

Qué es una WWDC

No sólo es la presentación principal, es un evento que (como una Macworld) dura una semana y está destinado a las personas que dedican su vida y tiempo para hacer programas para nosotros.

Hay talleres, charlas, laboratorios, clases guiadas y un montón de actividades dirigidas a profesionales (y no tanto) que desarrollan aplicaciones para Mac, iPhone y cualquier producto de Apple.

De vez en cuando se presentan nuevos Macs (como los Mac Pro o servidores Xserve, productos más destinados a profesionales) y últimamente, el iPhone tiene su hueco en estas fechas (el iPhone 3G y el iPhone 3Gs se presentaron en la keynote principal).

WWDC 2010

Este año se va a tratar los siguientes temas con especial interés, aparte del iPhone 4 y sus nuevas APIs que es la principal novedad:

• Application Frameworks: Introducción de Notificaciones Local y Push; Prueba de Apps; Fundamentos base; Novedades en los cimientos de iPhone OS 4; Trucos y recetas avanzadas en Cocoa®; Diseño de APIs para Cocoa y Cocoa Touch®; Reconocimiento de gestos avanzado; Integración de publicidad con iAd; Construcción de una experiencia de usuario personalizada basada en servidor; Uso de Core Location en iPhone OS 4; e Integración de Calendario con Event Kit.
• Internet y Web: Difusión de Audio y Video usando estándares web; Cómo extraer el máximo partido de las herramientas de desarrollo integradas en Safari®; Uso de almacenamiento de datos local con HTML5; Añadir detección táctil y gestual a páginas web con iPhone OS; y Creación de infográficos con tecnologías web estándar.
• Graficos y Media: OpenGL ES, ajuste y optimización; OpenGL ES, sombras y rendering avanzado; OpenGL ES, fundamentos para iPhone OS; OpenGL para Mac OS X; Diseño y desarrollo de juegos para iPhone OS; Introducción a Game Center; Configuración de juegos en Game Center; Game Center, técnicas; Core Animation en la práctica; Descubrir las bases de AV Foundation; Edición de contenido con AV Foundation; y Avances en HTTP Live Streaming.
• Herramientas de Desarrollo: Visión general de las herramientas de desarrollo; Diseño de apps con Interface Builder; Cómo trabajar de manera efectiva con Objective-C® en iPhone OS; Dominar Core Data; Técnicas avanzadas de Objective-C y Garbage Collection; Análisis avanzado de rendimiento con Instruments; Dominar Xcode para desarrollar para iPhone; y Adopción de multitarea en iPhone OS.
• Core OS: Network Apps para iPhone OS; Core OS Networking; Creación de apps seguras; Desarrollo de apps que trabajen con accesorios en iPhone OS; I/O Kit Device Drivers para Mac OS X; y Simplificación de las comunicaciones en red usando Bonjour®.

Como apunte, un pase para la WWDC de este año cuesta 1599$, así que os lo contaremos desde aquí, jeje. Esto por supuesto incluye, la comida, acceso a todos los talleres y charlas, conciertos en el Yerba Buena Center, etc.

Definitivamente, el año 2010 es un gran año para nuestros amigos de la manzana.

Vamos con el capítulo 02 de Programar en Mac. Cómo sabéis estamos haciendo un repaso a C al mismo tiempo que hacemos los PDF orientados exclusivamente a Cocoa.

Comentarios…

Con el uso de nombres sensibles de variables (que vimos en el capítulo anterior), podemos hacer nuestro código más inteligible y entendible [1].

// [1]

float pictureWidth, pictureHeight, pictureSurfaceArea;

pictureWidth = 8.0;

pictureHeight = 4.5;

pictureSurfaceArea = pictureWidth * pictureHeight;

Nuestro código sólo contiene por ahora unas pocas líneas de código pero los programas más sencillos fácilmente pueden alcanzar cientos o miles de líneas de código. Cuando vuelves a revisar el código  después de algunas semanas o meses puede ser complicado recordar la razón por la que programar cada cosa. Esta es la razón por la que aparecen los comentarios.

Los comentarios te ayudarán a entender rápidamente la razón de ser de una determinada parte de tu código y por qué está en cada lugar. Algunos programadores suelen ir más allá y comienzan cada código con un comentario que les ayuden a organizar su pensamiento y les permitan codificar personalmente desde un rincón.

Te recomendamos que dediques un tiempo a comentar tu código. Te aseguramos que así compensarás en el futuro el tiempo que gastes hoy con los comentarios. Además, si compartes tu código con alguien más, tus comentarios podrán ayudarles a adaptar lo que necesiten con mayor velocidad.

Crear un comentario

Para crear un comentario, comienza el comentario con dos barras inclinadas.

// Esto es un comentario

En Xcode los comentarios se muestran en verde. Si un comentario es muy largo y requiere múltiples líneas, deberás escribirlas entre /* y */.

/* Esto es un comentario

que se extiende a dos líneas /*

Outcommenting

Pronto trataremos cómo resolver los bugs de un programa y las grandes facilidades que Xcode da para ello. Una manera de resolver los bugs, el método pasado de moda, es el llamado outcommenting. Colocando parte de tu código entre /* y */ podemos temporalmente deshabilitar esa parte del texto (algo así como convertir en comentario lo que era código) para ver si el resto del código funciona como esperamos. Esto nos permite dar caza al bug. Si la parte convertida en comentario es, por ejemplo, un valor de una determinada variable, podrás incluir una líea temporalmente donde estaba la variable o un valor que encaje para probar el resultado de tu código.

¿Por qué comentarios?

La importancia de los comentarios no puede ser exagerada. Se usa normalmente para añadir una explicación en lenguaje asequible sobre lo que va en una serie de líneasde código. Esto es porque no tienes porque deducir qué es cada código y puedes ver inmediatamente si el problema que estás experimentando está en esa parte del código. También puedes utilizar códigos para expresar cosas que son complicadas o imposibles de deducir del propio código. Por ejemplo, si programas una función matemática usando un modelo específico descrito con detalle en alguna parte de un libro, podrás poner la referencia bibliográfica en un comentario asociado al código del que hablamos.

Algunas veces es útil escribir varios comentarios antes de escribir el código de programación. Esto puede ayudarte a estructurar tus pensamientos y el resultado de la programación será más sencillo.

Los ejemplos de código en este manual no contienen tantos comentarios como nos gustaría normalmente al escribir un código, porque están acompañados todos ellos de los textos de explicación.

]]> http://www.applenext.com/2010/04/programar-en-mac-02-los-comentarios/feed/ 8 http://www.applenext.com/2010/03/programar-en-mac-hemos-hecho-un-pdf-para-ti/ http://www.applenext.com/2010/03/programar-en-mac-hemos-hecho-un-pdf-para-ti/#comments Mon, 29 Mar 2010 02:14:46 +0000 Alejo Miranda http://www.applenext.com/?p=1442

En AppleNeXt.com, hemos preparado un PDF con lo básico para empezar a Programar en Mac y iPhone/iPad.

Visto el éxito que están teniendo nuestros primeros tutoriales, hemos decidido que todo os lo vamos a ir contando de forma aún más sencilla. Por ahora, este PDF incorpora los primeros pasos introductorios para empezar con la programación. Además, esta semana continuaremos con la lección 02 y en pocos días os pasaremos otro PDF con los primeros pasos en Cocoa.

Pulsa leer más para descargar el primer PDF: Guía para Programar en Mac

Programar en Mac – Introducción [2.7 MB]

Todo Gratis. Todo en español. Todo para Mac Claro, todo en AppleNeXt.com

Finalizamos la Lección 01 de Programar en Mac:

Operaciones Matemáticas

En los ejemplos anteriores hemos realizado una operación de multiplicación. Utiliza los siguientes símbolos oficialmente conocidos como “operadores” para realizar tus operaciones matemáticas:

• + para suma
• - para la resta
• / para la división
• * para la multiplicación

Utilizando los operadores podremos realizar un enorme número de cálculos. Si echas un vistazo al código que realizan los programadores profesionales, te darás cuenta de un par de peculiaridades. Probablemente por que son algo perezosos:

En lugar de escribir x = x + 1; los programadores suelen utilizar algo como [9] o [10]:

// [9]

x++;

// [10]

++x;

En ambos casos, significa: incrementar x con otra. En algunas ciscunstancias es importante si las ++ está antes o delante del nombre de la variable. Véanse los siguienes ejemplos [11] y [12]:

// [11]

x = 10;

y = 2 * (x++);

// [12]

x = 10;

y = 2 * (++x);

En el ejemplo [11] cuando todo se expresa y se realiza, y es igual a 20 y x es igual a 11. Sin embargo, en [12.2] x se incrementa un número antes de la multiplicación por 2. Por lo tanto en el final, x = 11 e y = 22. El código del ejemplo [12] es equivalente al ejemplo [13].

// [13]

x = 10

x++;

y = 2 * x;

Por lo tanto el programador ha juntado dos códigos en uno. Personalmente, creo que eso hace que el programa sea mucho más difícil de leer. El código está bien formulado pero podría haber un “bug” al acecho.

Paréntesis

Sería algo anticuado para ti si volvieras a tener que pasar la secundaria, pero los paréntesis pueden ser usados para determinar el orden en que las operaciones deben ser realizadas. Por orden, * y / tienen preferencias sobre + y -. Por lo tanto 2 * 3 + 4 es igual a 10. Usando el paréntesis, puedes forzar a que la suma se realice primero: 2 * (3 + 4) = 14.

Division

El operador “división” requere una atenció especial porque supone na pequeña diferencia si es utilizada con enteros o con decimales. Mira los siguientes ejemplos:

// [14]

inx x = 5, y = 12, ratio;

ratio = y / x;

// [15]

float x = 5, y = 12, ratio;

ratio = y / x;

En el primer caso [14] el resultado es 2. Sólo en el segundo caso [15] el resultado es el que probablemente esperamos: 2,4.

Variables de dos opciones (Booleans):

Un “boolean” es una variable lógica de “verdadero” o “falso”. 1 y 0 son los estándares de “verdadero” o “falso” y son usadas de manera intercambiable y pueden ser consideradas de manera equivalente:

Verdadero (True) 1

Falso (False) 0

Se usan habitualmente para evaluar cómo realizar una acción dependiendo de la variable  dicotómica (o boolean) de una determinada variable o función.

Módulos

Un operador con el que probablemente no estás tan familiarizado es % (modulus). No funciona como probablemente te esperas: el operador “modulus” no es un cálculo de porcentajes. El resultado del operador % es el resto de la división de enteros del primer operando entre el segundo (si el valor del segundo es cero el comportamiento de % es indefinido).

// [16]

int x = 13, y = 5, remainder;

remainder = x % y;

Ahora el resultado de este “remainder” es igual a 3 porque x es igual a 2 * y + 3. El resto de la división es 3.

Aquí hay otros tantos ejemplos de modulus:

21 % 7 es igual a 0

22 % 7 es igual a 1

23 % 7 es igual a 2

24 % 7 es igual a 3

27 % 7 es igual a 6

30 % 2 es igual a 0

31 % 2 es igual a 1

32 % 2 es igual a 0

33 % 2 es igual a 1

34 % 2 es igual a 0

50 % 9 es igual a 5

60 % 29 es igual a 2

Puede usarse de múltiples maneras posibles, pero date cuenta de que sólo funciona con números enteros.

Un uso común para el “modulus” es determinar si un número entero es “par” o “impar”. Si es par entonces el modulus de dos será igual a 0. Y en el caso contrario, debe equivaler a otro valor. Por ejemplo:

// [17]

int anInt;

// Un código que establece un código para anInt

if ((anInt % 2) = 0)

{

NSLog(@”anInt is even”);

}

else

{

NSLog(@”anInt” is odd”);

}

Seguimos con la Lección 01 de Programar en Mac:

Enteros (integers) y decimales (floats)

Ahora, echa un vistazo al ejemplo [5] y en particular a las dos primeras líneas:

// [5]

pictureWidth = 8;

pictureHeight = 4.5;

pictureSurfaceArea = pictureWidth * pictureHeight;

Los números en general se pueden clasificar en dos categorías: números enteros y con decimales (números racionales). Aquí puedes ver un ejemplo de ambos casos respectivamente. Los enteros se usan para contar o enumerar, como cuando tenemos que repetir una serie de instrucciones un número determinado de veces (ver capítulo 7).

El código del ejemplo [5] no funcionaría. El problema está en que el compilador quiere que le digas en adelante que tipo de nombre de variables vas a utilizar en tu programa y a qué tipo de dato se refieren. Por ejemplo, números enteros o números con decimales. Esto en lenguaje friki se denomina “declarar la variable”.

// [6]

int pictureWidth;

float pictureHeight, pictureSurfaceArea;

pictureWidth = 8;

pictureHeight = 4.5;

pictureSurfaceArea = pictureWidth * pictureHeight;

En la línea [6.1] “int” indica que la variable pictureWidth es un número entero (integer). En la línea siguiente, estamos declarando dos variables separándolas con una coma. Más específicamente, la línea [6.2] dice que ambas variables son del tipo decimal, por ejemplo, los números que contienen son decimales. En este caso es un poco tonto que pictureWidth es de un tipo diferente que las otras dos variables. Pero lo que puedes ver es que si multiplicas un “int” por un “float” el resultado es un “float”, que es la razón por la que debes declarar la variable pictureSurfaceArea como un “float”.

¿Por qué el compilador quiere que le digas si una variable representa un número entero o decimal? Bien, un programa necesitará parte de la memoria del ordenador. El compilador reserva memoria (bytes) para cada variable que encuentra. Cada diferente tipo de datos (en este caso “int” y “float”) requiere diferentes cantidades de memoria y una diferente representación, y por este motivo el compilador necesitará reservar la cantidad adecuaa de memoria y la representación más oportuna.

¿Qué ocurre si estamos trabajando con números grandes o una gran precisión decimal? ¿Servirá la cantidad de memoria que haya reservado el compilador? Exacto. Hay dos respuestas para esto: en primer lugar, tanto “int” como “float” contienen contadores que pueden almacenar números muy grandes (o de una gran precisión decimal). En muchos sistemas éstos son “long long” y “double”, respectivamente. Y esto nos lleva a la segunda respuesta: como programador, será tarea tuya estar al tanto de los problemas. En cualquier caso, no se trata de un problema que deba ser discutido en el primer capítulo de un manual de introducción.

En cualquier caso, tanto los números enteros como los decimales pueden ser negativos, como por ejemplo la cuenta de un banco. Si sbes con certeza que el valor de una variable nunca será negativa, puedes acotar el rango de la variables para que el compilador ajuste la memoria disponible.

// [7]

unsigned int chocolateBarsInStock;

No hay posibilidad de que en este caso pueda ser un número negativo. El “unsigned int” representa a todos los números mayores o iguales a cero.

Declarando una variable

Es posible declarar una variable y asignarla un valor en un solo código [8].

// [8]

int x = 10;

float y = 3.5, z = 4.2;

Tipos de datos

Como acabamos de ver, los daros almacenados en una variable pueden ser de determinados tipos, como por ejemplo “int” o “float”.

En Objective-C, los tipos simples como los que acabamos de ver son conocidos como datos escalares. Aquí hay una lista de los tipos de datos escalares más comunes que están disponibles en Objective-C:

void: Vacío (nada)

int: Número entero (…, -1, 0, 1, 2, …)

unsigned: Número entero positivo / Naturales (0, 1, 2, …)

float: Número decimal / Racionales

double: Número decimal con doble precisión

char: Caracteres / letras (hola)

BOOL: variables de dos opciones: 1, 0; Verdadero, Falso; Sí, No.

Introducción

Si aprendes a conducir un coche, debes aprender a manejar determinadas cosas como si fueran una sola. Debes saber cómo funciona tanto el embrague, como el acelerador o el pedal del freno. Para programar también necesitarás almacenar muchas cosas en tu mente o tu programa se vendrá abajo. Mientras que en el caso de un coche ya conoces cómo es el interior del vehículo antes de aprender a conducirlo, en el caso de la programación careces de esa ventaja antes de aprender a usar el Xcode. Para no abrumarte, dejaremos el tema de la programación como tal para más tarde; primero, te vamos a familiarizar con algunas cuestiones del código C-Objective, comenzando con algunos cálculos sencillos que ya conoces muy bien.

En Primaria, debes hacer cálculos rellenando los huecos:

2 + 6 = …

… = 3 * 4

(el asterisco * es el el símbolo estándar para representar la multiplicación en los teclados informáticos).

En Secundaria, los puntos suspensivos pasaron de moda y las variables son llamadas “x” e “y” (y aparece una nueva palabra maravillosa, “álgebra”). Mirando atrás, puedes sacar tus propias conclusiones sobre por qué a la gente le intimidaba tanto este pequeño cambio de … por x.

Variables

El lenguaje C-Objective también usa variables. Las variables no son más que nombres convenientes en cada caso para referirse a una dato específico, como un número. He aquí un ejemplo de código en C-Objective: una línea de código donde a una variable se le otorga un determinado valor:

// [1]

x = 4;

El punto y coma

A la variable denominada “x” se le ha otorgado el valor 4. Te habrás dado cuenta que hay un signo de punto y coma al final del código. Esto es así porque el punto y coma es necesario siempre al final de cualquier código. ¿Por qué? Bien, quizá el fragmento de código del ejemplo [1] pueda parecerte algo fácil y sin embargo un ordenador no sabría qué hacer con él. Es necesario utilizar un determinado programa especial, llamado “compilador” para convertir el texto que has tecleado en un lenguaje de “unos y ceros” que el Mac entenderá. Es muy complicado para un compilador leer el texto que cualquiera de nosotros puede haber escrito. Por tanto, tendrás que darle algunas pistas para que nos entienda, como por ejemplo el lugar donde termina cada código. Pues eso mismo es lo que hacemos cuando utilizamos el punto y coma.

Si te olvidas de un punto y coma en el texto, el código no podrá ser compilado, es decir, no se podrá convertir en un programa que el Mac pueda ejecutar. No te preocupes mucho por esto, porque el compilador te avisará y protestará en caso de no poder compilar tu código. Como veremos en futuros capítulos, te ayudará a encontrar dónde está el error y solucionarlo.

Dando nombres a las variables

Mientras que los nombres de las variables por sí mismos no significan nada para el compilador, utilizar nombres descriptivos en las variables puede hacer que nos resulte mucho más sencillo leer el programa y, por tanto, mucho más fácil de entender. Lo cual supone una ventaja en caso de tener que localizar y corregir un error en tu código.

Los errores en los programas se denominan tradicionalmente “bugs”. Encontrarlos y corregirlos es una operación habitual denominada “debugging”.

Por tanto, en el código real evitaremos utilizar nombres de variables no-descriptivos como x. Por ejemplo el nombre para el ancho de una imagen podría ser denominada pictureWidth [2]

// [2]

pictureWidth = 8;

Si olvidar un punto y coma puede resultar un gran error para un compilador, podrás suponer que la programación es algo en lo que importan mucho los detalles. Uno de esos detalles es el de prestar atención al hecho de que el código será siempre diferenciará entre mayúsculas y minúsculas, por lo tanto, importará si utilizas mayúsculas o no. La variable pictureWidth no es la misma que pictureWIDTH o PictureWidth. De acuerdo con las reglas generales convenidas, nombraremos las variables fusionando palabras: la primera en minúscula y las demás comenzando en mayúscula, tal como hemos visto en el ejemplo anterior. A este estilo de nomenclatura se le llama generalmente camelCase. Siguiendo este esquema, reduciremos las opciones de caer en errores de programación por el uso de mayúsculas o minúsculas.

Por favor, date cuenta que el nombre de una variable consiste en una sola palabra (o un todo).

Mientras que tienes total libertad para elegir el nombre de las variables, hay algunas normas sobre el nombre de las variables con las que te tendrás que conformar. La primera regla que deberás obedecer es la de que los nombres no podrán ser una de las palabras reservadas del lenguaje Objective-C (por ejemplo una palabra con un significado especial en este lenguaje). Componiendo una palabra a partir de la unión de otras dos, estarás siempre cumpliendo esta norma, como hemos visto con pictureWidth. Para que las variables sean inteligibles, el uso de mayúsculas en los nombres es muy recomendable. Si sigues este esquema, tus programas tendrán menos bugs.

Si quieres seguir aprendiendo un par de reglas, continua leyendo este párrafo. Además de letras, el uso de dígitos está permitido, pero un nombre de variable jamás podrá comenzar con un dígito. También estará permitido el uso del “guión bajo” o “_”. He aquí algunos ejemplos de variables:

Nombres aceptados:

door8k

do8or

do_or

Nombres no aceptados:

door 8 (porque contiene un espacio)

8door (porque empieza por un dígito)

No recomendados:

Door8 (porque comienza con mayúscula)

El uso de variables para cálculo

Ahora que sabemos cómo dar un valor a una variable, podremos realizar cálculos. Vamos a ver el código para calcular la superficie de una imagen. He aquí el código [3] que lo hace:

// [3]

pictureWidth=8;

pictureHeight=6;

pictureSurfaceArea=pictureWidth*pictureHeight;

Sorprendentemente el compilador no es sensible a los espacios (salvo para los nombres de variables, etc). Así que para hacer el código más fácil a los ojos, podremos usar algunos espacios:

// [4]

pictureWidth = 8;

pictureHeight = 6;

pictureSurfaceArea = pictureWidth * pictureHeight;

[CONTINÚA...parte 2]

]]> http://www.applenext.com/2010/03/programar-en-mac-01-un-programa-es-una-serie-de-instrucciones/feed/ 9 http://www.applenext.com/2010/03/devforums-foros-oficiales-de-apple-para-programadores/ http://www.applenext.com/2010/03/devforums-foros-oficiales-de-apple-para-programadores/#comments Fri, 12 Mar 2010 10:04:37 +0000 Alejo Miranda http://www.applenext.com/?p=1191

Como lo oyes, en la Apple Developer Connection (ADC, que ya explicamos hace tiempo) existen unos foros oficiales proporcionados por Apple para la discusión, debate y ayuda de otros programadores. Es realmente una muy buena noticia para los que empiezan con esto porque siempre será más útil la ayuda y la experiencia de alguien a la hora de dar los primeros pasos en la programación para Mac.

Los foros están en el siguiente enlace: http://developer.apple.com/devforums/.

Cuando entres en la web, te darás cuenta que los foros, como en toda la sección de programación de la web de Apple, está en inglés (creo que en Chino y Japonés también hay algunas cosas), lo cual supone un handicap para algunos de los hispanohablantes que dan sus primeros pasos puesto que auque muchos nos manejemos en inglés siempre es más sencillo comenzar con la programación y participar en foros en nuestro idioma.

Al margen de esto, hay una cuestión importante: los foros están disponibles para los que accedan a un programa de programación de Apple: los Developer Programs que también explicábamos hace pocos días. No basta con tener una cuenta de Apple, sino que habrá que apuntarse a estos programas. Son bastante interesantes y realmente, si lo pensamos, tampoco son tan caros. Pero es cierto que comenzar a programar es, por ahora, un hobbie, y 99 € quizá son demasiados para un hobbie.

De todos modos, para quienes os animéis a apuntaros a un programa de programación de la web de Apple, podréis acceder a estos DevForums, podréis descargar el SDK del iPad para investigar sobre cómo será el nuevo aparatito de Apple antes que nadie, podréis acceder a invitaciones para seminarios y eventos de Apple e incluso para las famosas keynote (especialmente la WWDC’10 orientada especialmente a los desarrolladores y en la que previsiblemente se presentará el nuevo iPhone v4.0)

Muestra de los DevForums de Apple para los desarrolladores

Antes de continuar con el tutorial de programación en Mac (usando Cocoa), vamos a hablar de las herramientas necesarias para dicha programación: Xcode y el iPhone SDK.

Vamos a echar un vistazo a estas aplicaciones tan importantes para programar en Mac:

La presentación de las herramientas del iPhone SDK

Xcode es la herramienta principal de “Developer Tools” (que como dijimos en el anterior post «¿Qué es la “Apple Developer Connection”?» se trata del pack de herramientas para programadores que se entregaba en las primeras versiones de Mac OS X). Para programar en Mac es la aplicación más importante que deberemos aprender a utilizar en todo caso: tanto para desarrollar software para Mac, para iPhone/iPad/iPodTouch, como para Safari. En todos los casos hace falta el Xcode.

Instruments

Pero esta vez nos vamos a centrar en otra herramienta: el iPhone SDK (que vale igual para el iPod Touch y a partir de la reciente versión 3.2 beta para el iPad).

El iPhone SDK es el Kit de Desarrollo de Software del iPhone, es decir, el paquete de herramientas necesarias para la creación de Apps y utilidades para el iPhone y el iPad. Si quieres ver el vídeo completo de la presentación del iPhone SDK pulsa aquí.

Scott Forstall presenta el iPhone SDK

El SDK está formado por 4 programas: Xcode, Interface Builder, Instruments y iPhone Simulator. El primero de ellos, como ya hemos hablado, es el programa necesario para programar en C-Objectives de acuerdo con Cocoa. El Interface Builder es una herramienta que se utiliza para diseñar el interfaz gráfico de usuario. Instruments además de un conjunto de instrumentos necesarios proporciona una linea de tiempo para los datos. Por último el iPhone Simulator es, como su nombre evidencia, un simulador para probar las aplicaciones de la forma más rápida y sencilla.

El SDK, gracia a estas herramientas, permitirá a alguien que sepa manejarse con C-Objective (incluso a quien programe en C y C++) desarrollar cualquier aplicación específicamente para el iPhone y el iPod Touch.

Las herramientas son las mismas que las que Apple usó en su día para crear las aplicaciones para el iPhone, y que permiten un acceso total al hardware. Para el sonido, se inluye Core Audio y Open AL, para vídeo, Video Playback con soporte para el codec h.264, Core Animation, Quarz y Open GL ES para la aceleración gráfica 3D vía hardware, que mejora el rendimiento optimizando el consumo de batería. Por último, también incluye Core Location, para las aplicaciones de posicionamiento geográfico.

Otro momento de la presentación el 6 de marzo de 2008

Después del desarrollo de aplicaciones (las aplicaciones del iPhone, iPod Touch e iPad son denominadas “Apps”, para diferenciarlas de las “Aplicaciones” que es como conocemos al software para el Mac), Apple las introducirá en el mercado a través de la AppStore, en la que están clasificadas por materias.

Para satisfacer la necesidad de cada desarrollador para cobrar su obra creada y al mismo tiempo la exigencia de Apple de cobrar la puesta a disposición en el AppStore y el desarrollo del SDK, los programadores podrán poner el precio que deseen a sus Apps. Mientras, Apple se lleva un 30% en concepto de distribución y alojamiento. En caso de que el desarrollador decida colgar la aplicación sin que ésta tenga ningun coste, Apple no se lleva nada en ningún caso, pero la aloja y la distribuye como si se tratase de una aplicación de pago.

La ADC (Apple Developer Connection) proporciona dos modalidades de programas para los desarrolladores. Ambos programas pondrán a su disposición un elenco de aplicaciones, heramientas, tutoriales, guías y ayudas para el desarrollo y la distribución de las diferentes Apps creadas. Estos dos programas son el Standard por 99 $ al año y el Programa de Empresas por 299 $ anuales.

Programas de Desarrollo

Para ambos programas será necesario utilizar ordenadores Mac con procesador Intel y al menos el Mac OS X Leopard. En el caso de la versión 3.2 beta (la preparada para el desarrollo de Apps para el iPad) será imprescindible Snow Leopard.

Características de cada programa para desarrolladores del iPhone

]]> http://www.applenext.com/2010/03/programar-en-mac-el-iphoneipad-sdk/feed/ 4 http://www.applenext.com/2010/03/programar-en-mac-introduccion/ http://www.applenext.com/2010/03/programar-en-mac-introduccion/#comments Mon, 01 Mar 2010 01:58:42 +0000 Alejo Miranda http://www.applenext.com/?p=1096

Hace unas semanas que el equipo de AppleNeXt.com estamos traduciendo al español con un lenguaje asequible un tutorial sobre la programación en Mac para los que se quieran adentrar en los secretos del desarrollo de software para Mac, iPhone, Safari e iPad.

Inicialmente no es algo muy complicado, como veréis. Pero a medida que vayamos avanzando la cosa adquiere un nivel mayor. Pero no os asustéis, todo es empezar y poco a poco iremos sumando más capítulos a este tutorial. ¿Preparados para convertiros en programadores de Mac? Adelante.

Cocoa quiere decir Cacao en inglés

Programar en Mac con Cocoa utilizando Objective-C

Hoy día existen multitud de aplicaciones y software que ofrecen soluciones creativas y sencillas para cualquier situación que podamos encontrar. Muchas de estas aplicaciones se han desarrollado para Mac, para iPhone / iPod Touch o simplemente para el iPod classic y nano.

Con este tutorial pretendemos involucrarte con sencillez en los conceptos fundamentales de la programación en Mac utilizando Xcode y Objective-C.

Este tutorial no está destinado a profesionales experimentados.

Comencemos a usar Cocoa

Introducción

Apple te proporciona totalmente gratis absolutamente todas las herramientas necesarias para crear grandes aplicaciones utilizando Cocoa. Este conjunto de herramientas, conocido bajo el nombre de Xcode, viene de serie con Mac OS X y además te lo puedes descargar de la sección de desarrollo de la página web de Apple.

Además existen buenos libros de programación en Mac pero la mayoría de ellos dan por hecho que tienes experiencia en programación. Este tutorial no. Nosotros te vamos a enseñar lo más básico de la programación y en particular la programación con Objective-C utilizando Xcode. Después de 5 capítulos serás capaz de crear un programa básico sin interfaz gráfico de usuario (GUI). Más tarde, tras algunos capítulo más, ya conocerás como crear programas sencillos con interfaz de usuario. Y cuando hayas concluido este tutorial estarás preparado para abordar otros libros más complejos sobre la programación basada en C. Deberás estudiar esos libros también porque hay mucho por aprender, aunque por ahora no debes preocuparte porque este tutorial te resultará bastante fácil.

Cómo usar este tutorial.

Como verás, algunos párrafos se mostrarán dentro de una pequeña caja. Te sugerimos que leas cada capítulo al menos dos veces. La primera, evitando los textos de las cajas, y la segunda vez que leas los capítulos, deberás leer el contenido de las cajas. Deberás practicar lo que hayas aprendido, y así podrás aprender también los detalles más interesantes, que quizá pasaron desapercibidas en la primera lectura. Si utilizas el tutorial de esta manera, podrás equilibrar la curva de aprendizaje del desarrollo de aplicaciones.

Este tutorial contiene docenas de ejemplos, que consisten en una o más líneas de código de programación. Para asegurarte de asociar la explicación con los ejemplos apropiados, cada ejemplo está etiquetado con un numero colocado entre corchetes, como este [1]. La mayoría de los ejemplos tienen más de dos o más líneas de código. A veces, se utilizará un segundo número para referirse a una línea del código en concreto. Por ejemplo, [1.1] se refiere a la primera línea del ejemplo [1]. En los recortes de código más extensos pondremos la referencia tras una línea de código:

//[1]

volume = baseArea * height;    // [1.1]

Programar no es un trabajo sencillo. Por tu parte, requerirá cierta perseverancia y deberás tratar de realizar por ti mismo todas las cuestiones que se planteen en este tutorial. No puedes aprender como tocar el piano o conducir un coche únicamente leyendo un manual; lo mismo ocurre para aprender a programar. Este tutorial está en formato digital, así que no tendrás ninguna excusa para ir probando el Xcode mientras lo sigues. Por lo tanto, a partir del capítulo 5 te sugeriremos que leas cada uno al menos 3 veces. En la última lectura deberías tratar de realizar los ejemplos con Xcode y después realizar algunas modificaciones en el código para ver qué ocurre.

Vía | www.cocoalab.com