Levick's Hub

I wanted to share with you this excerpt from Meditations by Marcus Aurelius:

In my father I observed mildness of temper, and unchangeable resolution in the things which he had determined after due deliberation; and no vainglory in those things which men call honours; and a love of labour and perseverance; and a readiness to listen to those who had anything to propose for the common weal; and undeviating firmness in giving to every man according to his deserts; and a knowledge derived from experience of the occasions for vigorous action and for remission. And I observed that he had overcome all passion for boys; and he considered himself no more than any other citizen; and he released his friends from all obligation to sup with himor to attend him of necessity when he went abroad, and those who had failed to accompany him, by reason of any urgent circumstances, always found him the same. I observed too his habit of careful inquiry in all matters ofdeliberation, and his persistency, and that he never stopped his investigation through being satisfied with appearances which first present themselves; and that his disposition was to keep his friends, and not to be soon tired of them, nor yet to be extravagant in his affection; and to be satisfied on all occasions, and cheerful; and to foresee things a long way off, and to provide for the smallest without display; and to check immediately popular applause and all flattery; and to be ever watchful over the things which were necessary for the administration of the empire, and to be a good manager of the expenditure, and patiently to endure the blame which he got for such conduct; and he was neither superstitious with respect to the gods, nor did he court men by gifts or by trying to please them, or by flattering the populace; but he showed sobriety in all things and firmness, and neverany mean thoughts or action, nor love of novelty. And the things which conduce in any way to the commodity of life, and of which fortune gives an abundant supply, he used without arrogance and without excusing himself; so that when he had them, he enjoyed them without affectation, and when he had them not, he did not want them. No one could ever say of him that he was either a sophist or a home-bred flippant slave or a pedant; but every one acknowledged him to be a man ripe, perfect, above flattery, able to manage his own and other men's affairs. Besides this, he honoured those who were true philosophers, and he did not reproach those who pretended to be philosophers, nor yet was he easily led by them. He was also easy in conversation, and he made himself agreeable without any offensive affectation. He took a reasonable care of his body's health, not as one who was greatly attached to life, nor out of regard to personal appearance, nor yet in a careless way, but so that, through his own attention, he very seldom stood in need of the physician's art or of medicine or external applications. He was most ready to give way without envy to those who possessed any particular faculty, such as that of eloquence or knowledge of the law or of morals, or of anything else; and he gave them his help, that each might enjoy reputation according to his deserts; and he always acted conformably to the institutions of his country, without showing any affectation of doing so. Further, hewas not fond of change nor unsteady, but he loved to stay in the same places, and to employ himself about the same things; and after his paroxysms of headache he came immediately fresh and vigorous to his usual occupations.His secrets were not but very few and very rare, and these only about public matters; and he showed prudence and economy in the exhibition of the public spectacles and the construction of public buildings, his donations to thepeople, and in such things, for he was a man who looked to what ought to be done, not to the reputation which is got by a man's acts. He did not take the bath at unseasonable hours; he was not fond of building houses, nor curious about what he ate, nor about the texture and colour of hisclothes, nor about the beauty of his slaves. His dress came from Lorium, his villa on the coast, and from Lanuvium generally. We know how he behaved to the toll-collector at Tusculum who asked his pardon; and such was all his behaviour. There was in him nothing harsh, nor implacable, nor violent, nor, as one may say, anything carried to the sweating point; but he examined all things severally, as if he had abundance of time, and without confusion, in an orderly way, vigorously and consistently. And that might be applied to him which is recorded of Socrates, that he was able both to abstain from, and to enjoy, those things which many are too weak to abstain from, and cannot enjoy without excess. But to be strong enough both to bear the one and to be sober in the other is the mark of a man who has a perfect and invincible soul, such as he showed in the illness of Maximus.

So that, those who are fathers can learn from it, those who are not be inspired by it. 

I've just released a new software license under which I'm planning to release my open source projects for Xenode Systems, it basically is a fork of the beerware license but a little more complete and instead of a beer one asks for a coffee as thankful gesture if someday someone might cross paths with the us and might want to thank us. (Because, as the internet taught us, a programmer is just a tool which converts caffeine into code hehe).

In case you don't know the beerware license, it's a very relaxed license which enables de end user to do anything with the software's source code (under any terms) provided he/she keeps 2 promises:

Give the original author recognition for the original software in some way (for example leave written in some part of your code "This project it's partially based upon X software of Y guy"

If someday you meet with the original software author, (and you consider his/her software it's/was useful to you) in a thankful gesture you can buy a beer to him/her (or a coffee in the case of coffeeware) if you wish.

I've always liked that license because it's simple and clear, also it has all you might want when you write really free software for the public: Let them do whatever they want with it (under any terms) provided they leave you recognition in some way and if it's possible, they thank you personally with a friendly gesture.

In the case of coffeeware, it's the same thing, but we invite the users to follow us in a social network (in order to be able to reach us with questions of comments they might have) and also we clarify that if they want to support our work with a donation, they're invited to ask us how. Another important thing is that, instead of our e-mail, we provide the user with some personal website link to contact us linked to our nickname in the license's text. You can download the coffeeware license in markdown format (and it's png badge) if you want to use it in your projects from it's official Github repo over here:

Hasta ahora hemos visto: Introducción, Parte I

Bienvenidos a mi nueva serie de tutoriales: Aprendiendo AngularJS y Google App Engine. El objetivo de esta serie es enseñar al lector (a lo largo de diferentes posts) Todo lo que necesita saber para iniciarse en el mundo del desarrollo web con las últimas tecnologías utilizando la infraestructura gratuita y altamente escalable de Google. No importa si apenas vas empezando o ya eres un desarrollador avanzado, todos aprenderán algo aquí. Trabajaremos con tecnologías como HTML/CSS/Coffeescript/jQuery/Python y algunas otras más, tocando temas como Bootstrap 3 y por supuesto, mucho de AngularJS. Entendimiento básico de las tecnologías antes mencionadas es recomendable pero no obligatorio.

Hoy veremos: CRUD

NOTA: No copies y pegues los snippets de código desde aquí, usa su enlace en Gist (abajo de cada bloque) para ello.

Esta segunda parte del tutorial tratará sobre CRUD básico en App Engine, CRUD es un acrónimo en inglés para las palabras Create, Read, Update and Delete mismas que corresponden a las 4 acciones básicas que todos realizamos en cualquier aplicación web con los entes principales de las bases de datos. Explicado de manera más simple (y en Español), todos Creamos, Leemos, Actualizamos y Borramos comentarios en facebook, tweets en twitter o algunos mails, qué se yo... Debido a que esta parte del tutorial es más compleja y larga que las anteriores, prefiero atacarla por medio de un video, así que esta segunda parte será más video oriented. Pueden ver el video de la lección a continuación (Disponible en HD):

NOTA: Por si alguien se lo pregunta, no usé herencia de plantillas en mis vistas porque como vamos a usar AngularJS más adelante, la interacción entre este framework y Jinja2 es más sencilla de esta manera, (evitando así conflictos entre uno y otro) según la vista.

No hay mucho más qué explicar aparte de lo tratado en el video, donde se centra el tutorial de hoy. sólo me queda mostrarles los snippets de código que han sufrido cambios desde la vez pasada:

app.yaml

application: portfolio version: 1 runtime: python27 api_version: 1 threadsafe: true

handlers: - url: /.* script: main.application secure: optional

- url: /new script: main.application login: admin secure: optional

- url: /edit script: main.application login: admin secure: optional

- url: /destroy script: main.application login: admin secure: optional

- url: /css static_dir: static/css

- url: /img static_dir: static/img

- url: /js static_dir: static/js

- url: /favicon\.ico static_files: static/favicon.ico upload: static/favicon\.ico

libraries: - name: webapp2 version: latest - name: jinja2 version: latest

(Cambia "portfolio" por el nombre de tu proyecto); Código en: https://gist.github.com/Jmlevick/6ab6f9df07beac9c5eff

main.py

import os import jinja2 import webapp2 from models.models import *

JINJA_ENVIRONMENT = jinja2.Environment( loader=jinja2.FileSystemLoader(os.path.dirname(__file__) + "/views"), extensions=['jinja2.ext.autoescape'], autoescape=True)

class Index(webapp2.RequestHandler):

def get(self): selector = ndb.gql("SELECT * FROM Project") template_values = { 'projects': selector } template = JINJA_ENVIRONMENT.get_template('index.html') self.response.write(template.render(template_values))

class Show(webapp2.RequestHandler):

def get(self): id = self.request.get('id') project = Project.get_by_id(int(id)) template_values = { 'name': project.name, 'img_url': project.img_url, 'description': project.description, 'author': project.author, 'url': project.url } template = JINJA_ENVIRONMENT.get_template('show.html') self.response.write(template.render(template_values))

class New(webapp2.RequestHandler):

def get(self): template = JINJA_ENVIRONMENT.get_template('new.html') self.response.write(template.render())

def post(self): self.project = Project(name = self.request.get('name'), img_url = self.request.get('img_url'), description = self.request.get('description'), author = self.request.get('author'), url = self.request.get('url')) self.project.put() self.redirect('/')

class Edit(webapp2.RequestHandler):

def get(self): id = self.request.get('id') project = Project.get_by_id(int(id)) template_values = { 'name': project.name, 'img_url': project.img_url, 'description': project.description, 'author': project.author, 'url': project.url } template = JINJA_ENVIRONMENT.get_template('edit.html') self.response.write(template.render(template_values))

def post(self): id = self.request.get('id') self.project = Project(id = int(id), name = self.request.get('name'), img_url = self.request.get('img_url'), description = self.request.get('description'), author = self.request.get('author'), url = self.request.get('url')) self.project.put() self.redirect('/')

class Destroy(webapp2.RequestHandler):

def get(self): id = self.request.get('id') self.project = Project(id = int(id)) ndb.delete_multi([self.project.key]) self.redirect('/')

application = webapp2.WSGIApplication([ ('/', Index), ('/show', Show), ('/new', New), ('/edit', Edit), ('/destroy', Destroy) ], debug=True)

Código en: https://gist.github.com/Jmlevick/968dc2a493ad24de878b

index.html

<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Portfolio</title> </head> <body> <h1>Index</h1>

{% for project in projects %} <span> <p>{{ project.name }}</p> <a href="show?id={{ project.key.id()}}">Show</a> | <a href="edit?id={{ project.key.id()}}">Edit</a> | <a href="destroy?id={{ project.key.id()}}">Destroy</a> </span> <br /> <br /> {% endfor %}

<a href="new">New</a>

</body> </html>

Código en: https://gist.github.com/Jmlevick/a258010cf56b0b4308fa

show.html

<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Portfolio</title> </head> <body> <div style="text-align: center;"> <h1>{{name}}</h1>

<img style="width: 500px; height: auto;" src="{{img_url}}" alt="">

<p>{{description}}</p> </div> </body> </html>

Código en: https://gist.github.com/Jmlevick/6d01053a0a0842e887bb

new.html

<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Portfolio</title> </head> <body> <h1>New Project</h1>

<form method="post"> <p>Name:</p> <input type="text" name="name"> <br> <p>Image URL:</p> <input type="text" name="img_url"> <br> <p>Description:</p> <textarea name="description" cols="45" rows="5"></textarea> <br> <p>Author:</p> <input type="text" name="author"> <br> <p>Url:</p> <input type="text" name="url"> <br> <br> <input type="submit"> </form>

</body> </html>

Código en: https://gist.github.com/Jmlevick/09fa5eab28a351dae4ae

edit.html

<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Portfolio</title> </head> <body> <h1>Edit Project</h1>

<form method="post"> <p>Name:</p> <input type="text" name="name" value="{{name}}"> <br> <p>Image URL:</p> <input type="text" name="img_url" value="{{img_url}}"> <br> <p>Description:</p> <textarea name="description" cols="45" rows="5">{{description}}</textarea> <br> <p>Author:</p> <input type="text" name="author" value="{{author}}"> <br> <p>Url:</p> <input type="text" name="url" value="{{url}}"> <br> <br> <input type="submit"> </form>

</body> </html>

Código en: https://gist.github.com/Jmlevick/18801aea00b9498238b1

Y con esto acabamos esta segunda parte. No olviden suscribirse al RSS del blog para estar al tanto de cuándo se publican nuevas partes del tutorial:

Y para poder contestar dudas más rápido y eso, les recomiendo también seguirme en twitter y mandarme menciones.

P.D. Aquí es un buen momento para usar Git en tu App, a esta rama yo la llamo "02mvc-crud" en mi app de ejemplo ;)

Hasta ahora hemos visto: Introducción

Bienvenidos a mi nueva serie de tutoriales: Aprendiendo AngularJS y Google App Engine. El objetivo de esta serie es enseñar al lector (a lo largo de diferentes posts) Todo lo que necesita saber para iniciarse en el mundo del desarrollo web con las últimas tecnologías utilizando la infraestructura gratuita y altamente escalable de Google. No importa si apenas vas empezando o ya eres un desarrollador avanzado, todos aprenderán algo aquí. Trabajaremos con tecnologías como HTML/CSS/Coffeescript/jQuery/Python y algunas otras más, tocando temas como Bootstrap 3 y por supuesto, mucho de AngularJS. Entendimiento básico de las tecnologías antes mencionadas es recomendable pero no obligatorio.

Hoy veremos: Estructura, MVC + REST

NOTA: No copies y pegues los snippets de código desde aquí, usa su enlace en Gist (abajo de cada bloque) para ello.

El objetivo que esta primera parte tiene es el de enseñarles cómo estructurar un proyecto en Google App Engine para trabajar cómodamente. Una de las ventajas que tiene GAE es su flexibilidad, el hecho de poder utilizar cualquier tipo de acomodo que te venga a bien en tus directorios y archivos para trabajar mientras tu descriptor (app.yaml) esté en orden... Pero el hecho de poder hacer las cosas como queramos no quiere decir que no debamos seguir algún tipo de orden, ¿verdad? Para esta serie de tutoriales, la aplicación que crearemos se basará en la arquitectura MVC (Model-View-Controller) y el principio REST. Conforme avancemos en el tutorial, notarán que esta app estará fuertemente influenciada por la "Manera Rails" de hacer las cosas, puesto que yo trabajo principalmente en Ruby On Rails. Y bueno, a todo esto...

¿Qué es el MVC y Qué es REST?

El MVC es un patrón de arquitectura que se utiliza en la construcción de aplicaciones web. Se basa en 3 componentes básicos: Modelos, Vistas y Controladores. Un Modelo es un archivo/script que precisamente "modela" (Es decir, define en código, o describe pues) los entes/objetos que manejaremos en nuestra base de datos. En el caso de la app en turno manejaremos proyectos que pueden tener un nombre, una imagen, una descripción, un autor y una URL. El archivo de Modelos tiene como nombre "models.py" y se ve así:

from google.appengine.ext import ndb

class Project(ndb.Model):   name = ndb.StringProperty(indexed=False)   img_url = ndb.StringProperty(indexed=False)   description = ndb.StringProperty(indexed=False)   author = ndb.StringProperty(indexed=False)   url = ndb.StringProperty(indexed=False)

Código en: https://gist.github.com/Jmlevick/a3bae23111fc2e02353e

Nótese que ninguno de los campos está siendo indexado. Indexar alguna propiedad del modelo hace que la búsqueda de objetos en nuestra base de datos (basándonos en el atributo indexado) Nos suelte un resultado casi de inmediato sin importar el número de records en la DB. En este caso no indexaremos puesto que no es necesario para la app que vamos a hacer. Los índices pueden ser buenos para acelerar las lecturas a la base de datos pero alentan las escrituras y ocupan más espacio en disco/memoria (según dónde los almacenes), tema para otra ocasión.

Una Vista es lo que el usuario ve en la aplicación. Son las páginas que le mostramos al acceder a la app e interactuar en ella. En las vistas creamos toda la UI y UX con respecto a lo que vamos a desarrollar. Pueden llevar código HTML, CSS, Javascript y también algún lenguaje embedido (Como Python/Ruby/PHP) según el framework que estés usando. En el caso de nuestro proyecto de ejemplo, las vistas pueden llevar código python embedido a través de un lenguaje de plantillas que veremos después. De momento tenemos algunas vistas pero no tienen código para mostrar en esta etapa del tutorial, son archivos HTML vacíos.

Un Controlador es "el pegamento" que une a los otros 2 atributos del MVC (por describirlo de alguna manera). Es básicamente un archivo que le indica a la aplicación cómo ha de responder a una request del usuario (Qué debe pasar si entran a la página principal, qué pasa si quieren entrar a la página individual de un objeto etc). En App Engine los controladores son llamados "handlers" y están escritos en Python, además de que también conllevan otra funcionalidad y es la del routing, (el describir las URL's accesibles de la aplicación y cómo responder a ellas cuando la gente accesa) con un poco de ayuda del app.yaml (más adelante veremos este archivo a fondo). Para esta parte de nuestro tutorial, el archivo de controlador (main.py) sólo lleva estas líneas:

import os import jinja2 import webapp2 from models.models import *

Código en: https://gist.github.com/Jmlevick/2758c8bb8ff5b1fd291e

Luego ahondaremos en el código completo que terminará teniendo.

Terminamos con el MVC. Ahora pasemos a REST. En cuanto a REST, se trata de un principio de creación de aplicaciones web que sostiene que toda aplicación se puede "construir" (por no encontrar una palabra más adecuada) sobre algunas acciones básicas cuyos nombres y definiciones varían según frameworks, pero por ejemplo en Rails (lo explicaré así porque en este tutorial usaremos ese arquetipo) tenemos las acciones Index, Show, New, Create, Edit, Update y Destroy. Cuyas funcionalidades respetan los principios de REST al permitir lo siguiente:

Index: Da acceso a todos los entes guardados en la base de datos

Show: Da acceso a un ente específico

New: Permite crear un nuevo objeto

Create: Es lo que sucede entre que creas el objeto y se guarda en la base de datos (por explicarlo de alguna manera)

Edit: Permite editar un Objeto existente

Update: Es lo que sucede entre que editas un objeto existente y se guarda en la base de datos con los nuevos atributos (por explicarlo de alguna manera).

Destroy: Permite destruir un objeto.

Cada una de estas acciones son descritas con métodos/funciones en el controlador de una aplicación y tienen una ruta propia que permite el acceso desde el navegador además de una vista (Cuya existencia es nula en las acciones de Create, Update y Destroy, pues no se necesita en realidad para éstas). Además podemos omitir vistas de acciones con las que el usuario no interactúa directamente o bien, que no responden a requests HTTP.

Estructurando el proyecto

Ya que entiendes éstas bases que usaremos, es momento de trabajar un poco y el día de hoy estructuraremos el proyecto que vamos a crear. Para empezar, dentro de la carpeta google_appengine que se genera tras instalar el SDK de Python en tu computadora (o bien extraerlo según tu plataforma) Crearemos una carpeta vacía llamada "portfolio". Dentro de esta carpeta hemos de crear la siguiente estructura de archivos y carpetas:

portfolio   ├── app.yaml   ├── index.yaml   ├── main.py   ├── models            ├── __init__.py            └── models.py   ├── static            ├── css            ├── img            ├── js            └── src   └── views            ├── edit.html            ├── index.html            ├── new.html            └── show.html

Entiéndase que todo lo que no tiene extensión es una carpeta y lo que sí, es un archivo. Terminamos así entonces con 7 directorios y 9 archivos anidados de la manera en que se muestra en el diagrama de arriba. Ahora, a explicar qué es cada cosa (y/o qué contiene):

app.yaml

Es un archivo descriptor de la aplicación. Le describe la aplicación a App Engine, delimita algunas rutas y define librerías a utilizar. Es el corazón central de tu app, su archivo de configuración. Ha de contener el siguiente código:

application: myPortfolio version: 1 runtime: python27 api_version: 1 threadsafe: true

handlers: - url: /.* script: main.application secure: optional

- url: /new script: main.application login: admin secure: optional

- url: /edit script: main.application login: admin secure: optional

- url: /css static_dir: static/css

- url: /img static_dir: static/img

- url: /js static_dir: static/js

- url: /favicon\.ico static_files: static/favicon.ico upload: static/favicon\.ico

libraries: - name: webapp2 version: latest - name: jinja2 version: latest

Código en: https://gist.github.com/Jmlevick/734634a8d437fe94bb3a

De aquí únicamente cambiaremos "myPortfolio" por el nombre de tu app, mismo que eliges al crearla en el dashboard de http://appengine.google.com. el parámetro de Version es la versión de tu app, Runtime el entorno a usar (en este caso Python 2.7) Api es la versión del API de App Engine más reciente para ese entorno (que es la 1 de momento). Y el parámetro Threadsafe habilita la capacidad de tu aplicación para procesar varias requests al mismo tiempo, por default lo recomendado es usar "true". Toda la sección de Handlers es puro routing, decimos qué URL's se pueden accesar y qué archivo de controlador las manejará, en nuestro caso sólo tenemos 1 archivo de controlador (main.py) que está en la raíz del proyecto y como vamos a usar webapp2 (el framework predeterminado de app engine) en lugar de poner "main.py" en el parámetro de "script" de nuestras rutas tenemos que poner main.application para referenciar dicho controlador; Hay otras opciones que verás, como "secure" o "login" y también notarás que la primera ruta tiene un comodín, lo que significa que cualquier request que se haga a la aplicación desde la raíz en adelante (http://myapp.appspot.com/loquesea) ha de procesarse con el mismo script de controlador. Si no necesitásemos restringir el acceso a ciertas URL's (como las que permiten crear y destruir objetos en la DB) bastaría con este primer handler, pero como no es el caso tenemos que definir los demás con la opción "login:admin" para que solo los administradores de la app tengan acceso a esas URL's y por ende, a sus funciones (Luego ahondaremos en esto). "secure" simplemente habilita o deshabilita el HTTPS en la aplicación, yo uso el parámetro "optional" para que la gente pueda usar HTTPS si quiere o HTTP normal, no forzando ni una ni otra opción. Otra opción que se ve ahí es "static_dir" y básicamente dice qué directorio dentro de la aplicación contiene "las respuestas" (archivos) a una request de determinada URL para assets (CSS, JS, etc).

El último handler simplemente sube el favicon a app engine y le dice dónde se encuentra y a qué URL responde.

En cuanto a las librerías, tenemos 2: webapp2 (Framework web de app engine) y jinja2, un motor de plantillas. Se pueden definir versiones específicas o usar siempre la más actualizada con "lastest" (como se ve en nuestro archivo app.yaml de arriba). Más adelante ahondaremos en éstas 2 librerías conforme construyamos la app. Pueden leer más sobre el app.yaml y todo lo que se puede hacer/definir con él por acá.

index.yaml

Este archivo tiene este código:

indexes:

# AUTOGENERATED

# This index.yaml is automatically updated whenever the dev_appserver # detects that a new type of query is run. If you want to manage the # index.yaml file manually, remove the above marker line (the line # saying "# AUTOGENERATED"). If you want to manage some indexes # manually, move them above the marker line. The index.yaml file is # automatically uploaded to the admin console when you next deploy # your application using appcfg.py.

Código en: https://gist.github.com/Jmlevick/efb81a1381e3227d66de 

Y pues se podría decir que "va vacío". Lo único importante son las primeras 2 líneas (indexes y AUTOGENERATED) Que permiten reconocerlo a app engine y cambiarlo al vuelo para generar índices en la base de datos cuando los estamos ocupando.

main.py

Este es el controlador de nuestra aplicación, ya hablamos de él arriba, sus funciones/propósito y mostramos el código que tiene hasta el momento.

Carpeta Models

Contiene 2 cosas: un archivo de inicialización y el archivo de modelo que mostramos arriba. Sirve para organizar todo lo referente a modelación de bases de datos (obviamente) dentro de la aplicación, sus archivos:

__init__.py

Va vacío, sólo sirve para que un programa python pueda reconocer esta carpeta como un módulo e importar scripts que tenga adentro a voluntad del usuario.

models.py

Sirve para modelar los entes de nuestra aplicación, ya explicamos arriba este archivo y mostramos su código... En una aplicación más grande, lo ideal es crear un archivo de modelo por cada ente dentro de la app y meterlo a nuestra carpeta de models.

Carpeta Static

Contene todas las carpetas de assets de la aplicación (css, js, img, y en este caso src), sus carpetas:

css

Contiene todas las hojas de estilo de nuestra app

js

Contendrá todos los javascript que nuestra app lleve

img

Contiene todas las imágenes que se necesiten en la aplicación

src

Es una carpeta que contendrá archivos .coffee de coffeescript, Toda la app la escribiremos en coffeescript (la parte de Angular pues) y lo compilaremos en automático al directiorio JS, de donde se jalarán los scripts para levantar la app en producción.

Carpeta Views

Contiene las vistas de nuestra aplicación (de momento archivos HTML vacíos), sus archivos:

index.html

Sirve para que el usuario vea todos los proyectos en nuestro portafolio

show.html

Sirve para que el usuario vea los detalles individuales de 1 solo proyecto en el portafolio

new.html

Sirve para crear nuevos proyectos y añadirlos al portafolio

edit.html

Sirve para editar los atributos de proyectos ya existentes en el portafolio.

Verificando

En el video a continuación, puedes ver cómo queda la estructura de directorios (y los archivos) para esta primera etapa del tutorial, por si te quedó duda o te confundiste con algo:

Y con esto acabamos esta primera parte. No olviden suscribirse al RSS del blog para estar al tanto de cuándo se publican nuevas partes del tutorial:

Y para poder contestar dudas más rápido y eso, les recomiendo también seguirme en twitter y mandarme menciones.

P.D. Aquí es un buen momento para usar Git en tu App, a esta rama yo la llamo "01structure" en mi app de ejemplo ;)