Dos años y medio atrás me sumaba formal y activamente a AtomicLab.org, organización liderada por Gino Tubaro con la misión de ayudar a quienes más lo necesitan utilizando la tecnología como pilar.

A través de Microsoft entré en contacto para ayudarlos como organización, pero luego me involucraría a nivel personal también, y todo comenzó en el laboratorio que Gino y Gustavo habían montado en el CMD.

El proyecto quizá más conocido del laboratorio es Limbs, que se enfoca en el diseño, producción y distribución de manos mecánicas impresas en 3D con plástico y una impresora hogareña.

La foto la sacamos en la primera reunión donde se empezaron a gestar varias de las iniciativas. Les cuento la primera: ¡Manotón!

Organizamos en las oficinas de Microsoft con la ayuda de varios voluntarios, imprimimos, armamos y entregamos durante el evento 20 manos a chicos y grandes que lo necesitaban.

Este evento se repitió y sigue repitiendo, ya que es un gran espacio donde, no solo se entregan muchos pedidos al mismo tiempo, sino que se genera comunidad de voluntarios, que muchos de ellos siguen ayudando e imprimiendo más manos luego del evento en sí. Además de ser el caballo de batalla del laboratorio para poder fondear no solo las manos entregadas durante los eventos, sino también las que se entregan luego, gracias a los sponsors que aportan para que el evento sea posible de realizar.

Con el mismo espíritu, pero en otra época del año llegaron los Navidatones (si, nos gustan mucho los hackathones ), pero esta vez, quien entrega las manos es Papa Noel, con ayuda de todo el equipo, en época navideña. Hicimos los últimos dos años esta iniciativa donde en cada una se entregaron 10 manos más.

Desde el primer momento vimos que entregar manos una a una, o de a grupo en eventos iba a tener un alcance limitado, y teniendo en cuenta que los diseños son open-source, nos dimos cuenta que el problema no era el acceso a la tecnología, sino la unión de las partes, quien tiene ganas de ayudar e imprimir con quien tiene la necesidad.

Luego de mucho trabajo en equipo de forma voluntaria, nació Limbs.earth, la primera plataforma que registra la necesidad de manos mecánicas en todo el mundo, y une esa necesidad con un embajador que de forma voluntaria imprime la mano hecha a medida.

Este proyecto también es open-source, fue construido en el ultimo año y medio y sigue en constante desarrollo. El equipo de tecnología que me toco liderar para llegar a lanzar la plataforma en diciembre de 2017, ahora los considero amigos, y quisiera aprovechar para nombrarlos y agradecerles el trabajo que en las sombras hicimos para que hoy más de 800 manos hayan sido entregadas:

· Lucas López y Micaela Yanigro: desarrollando la plataforma, hoy Lucas pasa a liderar el equipo.

· Matias Gonzalez: diseño e interfaz, el hace que todo se vea increíble.

· Beatriz, Lucho y Aldano: los 3 encuentran cada error para que los arreglemos antes que lo vean los usuarios

· Eduarda Fontaine: manejando la administración de la plataforma y conexión con cada embajador para que cada mano se imprima y llegue a destino.

Queria cerrar este post agradeciendo especialmente a mi amigo Gino Tubaro, con quien ademas de compartir la vision de que con la tecnologia se le puede cambiar la vida a las personas para bien, compartimos un montón de momentos y anécdotas, buenos y malos en todos estos años, y los que vendrán!

Sin duda el proyecto va a seguir creciendo, y espero, si llegaste a leer hasta acá, y estás interesado en ayudar, te contactes, seguro podes dar una mano dando manos!

In this post and video i want to share the steps and requirenments to use the RSK-BTC bridge, also known as Two-Way Peg.

Requisites

1. A BTC Wallet with funds
2. Whitelist your address here: https://github.com/rsksmart/rskj/wiki/Whitelisting-in-RSK

Steps

1. Get the federation address by calling the Bridge contract

Navigate to https://mycrypto.com/contracts/interact and select from the network list in the right top corner “RSK”. then click on the “contracts” option in the menu.

Finally, to get the address, select the “bridge” contract, access it, select the “getFederationAddress” function and click on the “read” button to get the address.

2. Send funds to the Bridge

PLEASE, don’t follow this step until you are whitelisted!!!

Using your whitelisted address in BTC, send the amount to be converted to SBTC (Smart Bitcoin) to the federation address obtained in the previous step. Use the wallet you want. It’s just a BTC transaction.

The amount should be between 0.1 to 10 BTCs, no less, no more

3. Check the funds converted in RSK

In order to check the funds in RSK we need 2 tools:

• RSK Utils: converts the BTC address into an RSK address
  • Navigate to https://utils.rsk.co
  • Or, run this tool locally by downloading the code and run it from here: https://github.com/rsksmart/utils
• RSK Explorer: https://explore.rsk.co

The RSK network is the Smart Contract platform of Bitcoin, it offers the same capabilities of Ethereum, but the gas is paid with Bitcoin.

When your application needs to interact with the network by publishing or calling a Smart Contract you need a node synchronized. This video of the series explains how to install a node on Docker.

The video is closed captioned, and bellow you will find the step by step easy to copy and paste.

Step 1:

Navigate to the RSK Artifacts page and download
the supervisord.conf and the Dockerfile corresponding to the desired environment.

Step 2:

Open a Terminal and navigate where the
downloaded files are placed and run the following command to build the image:

For MaiNet

docker build -t mainnet -f Dockerfile.MainNet .

For TestNet

docker build -t testnet -f Dockerfile.TestNet .

For RegTest

docker build -t regtest -f Dockerfile.RegTest .

Step 3:

Run the container by executing the following command, depending on the network selected before:

MaiNet

docker run -d --name mainnet-node-01  -p 4444:4444 -p 5050:5050 mainnet

TestNet

docker run -d --name testnet-node-01  -p 4444:4444 -p 50505:50505 testnet

RegTest

docker run -d --name regtest-node-01  -p 4444:4444 -p 30305:30305 regtest

The RSK network is the Smart Contract platform of Bitcoin, it offers the same capabilities of Ethereum, but the gas is paid with Bitcoin.

When your application needs to interact with the network by publishing or calling a Smart Contract you need a node synchronized. This video of the series explains how to install a node using the Amazon Web Services AMI Marketplace. 

The video is closed captioned, and bellow you will find the step by step easy to copy and paste.

Step 1:

Navigate to the AWS Console site: https://console.aws.amazon.com

Step 2:

On the AWS services dashboard, click on EC2 (Virtual Machines), then on “launch instance” button.

Step 3:

Click on AWS Marketplace, search for “rsk”, and select the “RSK Node Bamboo v0.x.x MainNet”; Review the prices and select “Continue”.

Step 4:

Select the instance type. The once disabled doesn’t reach the minimum hardware requirements. Then, click on “Next: configure instance details”

Step 5:

Optionally change the default values on this screen, and continue clicking on “Next: Add Storage”

Step 6:

In the Storage section, increase the size to 100GB, the minimum recommended to run the node, then click on “Next: Add Tags”

Step 7:

Optionally add a tag to identify the instance, then, click on “Next: Configure Security Group”

Step 8:

Now create a new rule with the TCP 22 port, and select a source to open the SSH port and be able to connect to the node remotely, then click on “Review and Launch”

Step 9:

Review the info and click on “Launch” to start the VM deployment

Step 10:

After AWS deploys the VM, enter the VM details and use the IP or DNS to connect to the node.

The RSK network is the Smart Contract platform of Bitcoin, it offers the same capabilities of Ethereum, but the gas is paid with Bitcoin.

When your application needs to interact with the network by publishing or calling a Smart Contract you need a node synchronized. This video of the series explains how to install a node on Windows/Linux/MacOS by running a pre-compiled JAR version of the node.

The video is closed captioned, and bellow you will find the step by step easy to copy and paste.

Step 1:

Download Java from https://java.com/download and install it in your Windows, Linux or MacOS machine.

Step 2:

Download the last pre-compiled JAR version of the RSK node from: https://github.com/rsksmart/rskj/releases

Step 3:

Once downloaded, place it on a well-known folder, open a console and navigate to it.

Step 4:

Run the following command to start the node:

$ java -cp <PATH-TO-THE-RSKJ-FATJAR> co.rsk.Start

Step 5:

Connect to the node and test it.

The RSK network is the Smart Contract platform of Bitcoin, it offers the same capabilities of Ethereum, but the gas is paid with Bitcoin.

When your application needs to interact with the network by publishing or calling a Smart Contract you need a node synchronized.

This video of the series explains how to install a node on Ubuntu using the PPA. The video is closed captioned, and bellow you will find the step by step easy to copy and paste.

Step 1:

Open a terminal and run the following commands to prepare your machine:

sudo add-apt-repository ppa:rsksmart/rskj 
 
sudo apt-get update

Step 2:

Install the RSK node by running the command:

sudo apt-get install rskj

Step 3:

Accept the Terms and Conditions, press ESC, then accept.

Step 4:

Select between Mainnet, Testnet or Regtest

Step 5:

Start the node by running the command:

sudo service rsk start

The RSK network is the Smart Contract platform of Bitcoin, it offers the same capabilities of Ethereum, but the gas is paid with Bitcoin.

When your application needs to interact with the network by publishing or calling a Smart Contract you need a node synchronized.

This video of the series explains how to install a node on a VM using the Microsoft Azure Marketplace. The video is closed captioned, and bellow you will find the step by step easy to copy and paste

Step 1:

Navigate to https://portal.azure.com and inside the Azure Portal, click on “Create a resource”

Step 2:

Search for “RSK”, select the “RSK Bamboo v0.x.x MainNet…”, and click on “Create”.

Step 3:

Configure some settings: VM Name, VM Disk Type, username, password, resource group and location.

Step 4:

Select the VM Size, check the sizes and costs; and the node hardware requirements.

Step 5:

Open the 4444 port by changing the default configuration in the network security group.

Add an inbound rule for the TCP 4444 port

Step 6:

Check the configuration summary and click on “create” to launch the deployment.

Step 7:

When the deployment finishes, take note of the public IP or DNS to connect to the node.

The RSK network is the Smart Contract platform of Bitcoin, it offers the same capabilities of Ethereum, but the gas is paid with Bitcoin.

When your application needs to interact with the network by publishing or calling a Smart Contract you need a node synchronized.

This video of the series explains how to connect to a node using SSH. The video is closed captioned, and bellow you will find the step by step easy to copy and paste

Step 1:

Open a Terminal and connect to the remote node by running this command:

ssh username@address

Where username is the one in the remote node, and, address is the remote node DNS or IP

Step 2:

Type your password.

Step 3:

Once inside the node, you can run commands remotely.

To check the node status (or last block) run the following command:

curl -s -X POST -H "Content-Type:application/json" -d '{"jsonrpc":"2.0","method":"eth_blockNumber", "params":[],"id":888}' http://localhost:4444

You should see a result like the following:  {“jsonrpc”:”2.0″,”id”:888,”result”:”0x2FE44″}

Step 4:

Check that the blockNumber corresponds with the last of the network checking in the Stats website:

Mainnet: https://stats.rsk.co

Testnet: https://stats.testnet.rsk.co

Index:

• Environment setup
• Tools
• New project
• Compile
• In-memory blockchain
• Deploy
• Test your Smart Contract
• Remote deploy

If you find something unclear, or have ideas on how to improve this or new tutorials? Found this useful? Want to help building more tutorials? Have ideas?, feel free to contact me!

Environment setup

This is very hard to standardize, there are several tools available, and more are coming every day, lot of compatibility issues, versions, different OSs, so, I will try to give (IMHO) the most easy to install and compatible environment I can.

Tools

RSK has two networks, one is a development or test network (also known as testnet) and a production ready network (the mainnet).

To interact with the network, you must connect your application with a Node. You can find how to deploy a node and connect it to testnet or mainnet.

Public nodes

New! no installation or hardware required.

• Mainnet: https://public-node.rsk.co/
• Testnet: https://public-node.testnet.rsk.co/

How to install a node

In order to interact and see the network status, here you can find the links:

The Testnet has a faucet that provides SBTC to run your Smart Contracts within the sandbox for free, the Mainnet does not, that would be like giving money for free in the real world .

You will need to install all the required software specified in the previous section.

I present you your new IDE, Visual Studio Code, this is the initial screen:

New project

Let’s start coding! Open Visual Studio Code. You can see the interface in the screenshot.

The first task is setting the environment folder. Its just a new empty folder that we are gonna use to host all our project files.

Click on “File” –> “Open folder…” and choose a convenient location.

As we are going to use the Command Line Interface that is not showed by default. Click in “View” –> “Integrated Terminal” to open it.

The folder should be empty in order to start fresh.

To start coding, truffle help us by creating a template project with some magic on it.

On the command interface type:

truffle init

This creates some folders and files as a template, we will focus our attention in.

• “contracts” folder: where our contracts must be (*.sol files).
• “migrations” folder: javascript migration code, this is executed on the deploy.
• “truffle.js” file: truffle configuration file, we are going to configure our network to deploy the contract.

You should see the file tree as follows:

Lets create our first Smart Contract just creating a new file called “HelloWorld.sol” inside the “contracts” folder.

Open the file and paste the following code (updated at ago-2018):

}

Its a simple Smart Contract with only one variable that can be asked or replaced using the functions “getGreeting()” and “setGreeting(“some message”)” respectively.

Compile

Now we have our code done, let’s prepare the project to compile and deploy it.

Open the “1_initial_migration.js” file in the “migrations” folder, and add lines 2 and 6. The file should end like this:

var Migrations = artifacts.require(“./Migrations.sol”);

var HelloWorld = artifacts.require(“./HelloWorld.sol”);

module.exports = function(deployer) {

deployer.deploy(Migrations);

deployer.deploy(HelloWorld);

};

This tells truffle how to deploy our code.

Next step is to compile the Smart Contracts running this command in the terminal:

truffle compile

This operation compiles the Smart Contracts and creates one JSON file for each one. Open and see what’s inside our compiled Smart Contract (“HelloWorld.json” inside the new created “build/contracts” folder). Do you find some things interesting?

In-memory blockchain

In order to avoid gas usage and long waits during our development process, truffle implements an in-memory blockchain that allow us to deploy and interact with our smart contracts.

To start the in-memory blockchain and connect the terminal to it, run this command:

truffle develop

This command returns lot of information. Some to highlight are the address:port where the blockchain is running (http://127.0.0.1:9545 in my case, this may vary, but don’t panic).

We can see also 10 account addresses with the corresponding Private Keys and the famous 12 words; Its convenient to write this down for future usage. Don’t send any money to this accounts, they are living just in your in-memory blockchain.

Deploy

Firstly, we are going to deploy our compiled Smart Contracts to our in-memory blockchain.

If you started this tutorial from this step, I recommend to go back one and open the in-memory blockchain console.

Once in the truffle develop console, just type and execute this command to deploy the contract:

migrate

If you don’t see a result similar to the one in the screenshot, force the deploy using this command:

migrate –-reset

The command result gives:

• Transaction Id
• Contract address (important to call the contract)

That is all! You have your Smart Contract deployed!

Test your smart contract

With the Smart Contract deployed, now we need to test or interact with it. Truffle execute the migration file “1_initial_migration.js” mentioned before. It’s just javascript, so, we can see line by line what is running. In the second line we create a global variable called HelloWorld that contains the Smart Contract, type in the console and see the result:

HelloWorld

Now, we are going to interact with it, type line by line the following commands as showed in the image below:

var helloWorldContract

HelloWorld.deployed().then(function(contract){ helloWorldContract = contract; })

helloWorldContract.getGreeting.call().then(console.log)

This three lines creates a variable “helloWorldContract”, then reference the Smart Contract to this variable, and finally we use the variable to call the “getGreeting” function in the contract.

The next step is writing/modify the greeting by calling the “setGreeting” function of the Smart Contract, typing and running the command:

The result is quite different from the other calls, and the time between the call and answer may vary if you are running local or connected to a remote network. Because we are setting a variable, we need to run the Smart Contract through a transaction to the blockchain. The command result is the transaction receipt. You can see the blockNumber, transactionHash and gasUsed among other info.

If you are running this on a remote network (testnet or mainnet), you will find this transaction details in the explorer (see tools section).

Now, the last step is calling the “getGreeting” function again to check our new greeting message!

As you know, the Smart Contracts deployed to remote networks are executed by the real nodes participating in the network. It’s normal that the transaction have some delay in the execution, and maybe you will see the same first greeting message, give the network some time and run the command again.

Remote deploy

The last step is deploying our Smart Contract to a remote network. To do so, you need a node to interact with the network, refer yourself to the tools section in this tutorial to see how to install a node, or ask me the address if you are following this tutorial during a workshop or meetup. (join the RSK Ambassador Program)

Truffle needs to know about the network, so, let’s configure the network as showed below:

Copy this code to the “truffle.js” configuration file.

If you are using a public node, you need to create and unlock your address private key. Run the following commands in order (replace “password” with a random key):

var myAccount = web3.personal.newAccount(‘password’)

web3.personal.unlockAccount(myAccount, “password”);

myAccount

The last command returns your RSK Address.Copy and paste it on the configuration file (“from” variable).

Navigate to the testnet faucet (https://faucet.testnet.rsk.co), and paste your address to get some SBTC.

Back in the terminal, press CTRL + C + C to exit the console.

After that, run the migrate command as we learnt in the previous sections.

truffle migrate –reset –network aleRSK

Replace “aleRSK” with the name you want. Be sure its the same configured before in the “truffle.js” file.

Open the console connected to the remote network:

truffle console –network aleRSK

After that, test it using the same steps as in the “testing your smart contract” section.

If you are here you’ve showed passion about the technology. Join our Global Community Slack and join the RSK Ambassador Program!

Starting at January 21 for a couple of weeks, I had a fantastic the experience with Gabriel Kurman of traveling on the “RSK European Tour”, attending events and meetups in London, Kiev, Moscow, Berlin, Hamburg, Cologne, Utrecht, Amsterdam, Bordeaux and Paris.

We had the chance to present RSK and talk about the Internet of Value, our platform’s present and future. Gabriel told me, when I joined the team, about the good vibe and karma that the project has on the community. This is absolutely true, and is inspiring. Almost everyone agree that this is the path to make blockchain technologies mainstream. Together we will enable financial inclusion and new governance models, improving the life of millions.

Now, moved to Barcelona, I want to thanks everybody that helps making RSK visible to every community. As promised, here you can find the presentation and few links/information on different programs that we are running.

Ambassador program:

Do you want to be part of the next technology revolution?

Join the most powerful Blockchain community and become an industry leader.

Join us at: https://ambassadors.rsk.co/

Bounty program:

For security experts, software developers and hackers who dedicate time and effort to improve the RSK platform.

Submit your findings and earn rewards!

Info: https://bounty.rsk.co/

Technical Resources:

Do you want to start training yourself?

Start with this resources: https://blog.alebanzas.com.ar/rsk-technical-resources/

Educate:

RSK educate is our global initiative to provide students and educators with the resources needed to accelerate blockchain-related learning endeavors.

Are you an academy interested in offering the courses or are you an individual interested in taking the course?

More info: https://educate.rsk.co/

B4H:

Blockchain4Humanity is a not for profit, social accelerator foundation.

More info: http://bit.ly/block4h

2018 came with great news! I’m moving to Barcelona, Spain to become part of a great team at RSK Labs helping every developer and company to change people’s life through Blockchain Technology to build the Internet of Value. RSK Labs founded in Latin America, enables smart contracts on Bitcoin network, fully compatible with Ethereum. I’m honored and happy for the warm welcome and support! 

RSK is the first open-source smart contract platform with a 2-way peg to Bitcoin that also rewards the Bitcoin miners via merge-mining, allowing them to actively participate in the Smart Contract revolution. RSK goal is to add value and functionality to the Bitcoin ecosystem by enabling smart-contracts, near instant payments and higher-scalability.

¡2018 llegó con buenas noticias! Me estoy mudando a Barcelona, ​​España para formar parte de un gran equipo en RSK Labs que ayuda a cada desarrollador y compañía a cambiar la vida de las personas a través de la tecnología Blockchain para construir Internet of Value (internet del valor). RSK Labs, fundada en Latinoamérica, habilita contratos inteligentes en la red Bitcoin, totalmente compatible con Ethereum. ¡Me siento honrado y feliz por la cálida bienvenida y el apoyo!

RSK es la primera plataforma de contrato inteligente de código abierto con una vinculación bidireccional a Bitcoin que también recompensa a los mineros de Bitcoin a través de merge-mining, lo que les permite sumarse a la revolución de los Smart Contracts. El objetivo de RSK es agregar valor y funcionalidad al ecosistema de Bitcoin al permitir contratos inteligentes, pagos casi instantáneos y mayor escalabilidad.

Manual para activar Microsoft Azure con el programa Microsoft Dreamspark

Contenido:

1. Activar cuenta de Microsoft Dremspark

2. Activar servicio de Microsoft Azure

Activar cuenta de Microsoft Dremspark con código

1. Ingresar al portal https://www.dreamspark.com/ como se muestra en la siguiente imagen:

2. Ingresar al enlace “estudiantes” que se muestra a continuación

3. Ingresar al enlace que dice “iniciar sesión” para ingresar el usuario y contraseña de un correo tipo Microsoft tipo @outlook.com o @hotmail.com o @live.mx

4. Validar datos personales en el sistema de Dreamspark, asegurar que seleccionen el país Argentina

5. Se muestran opciones de validación posibles

6. Seleccionar la Opción que dice: “Recibí Código de Comprobación” e ingresar el código que recibiste.

7. Felicidades Activaste Microsoft Dreamspark presionar Continuar

8. Felicidades 2, dar click en “Continuar”

Activar servicio de Microsoft Azure

Debes estar en logueado con tu cuenta en la sección de Estudiantes, en el portal de https://www.dreamspark.com/

1. Seleccionar la opción “Catálogo de Software” y seleccionar el Icono que dice Microsoft Azure en el segundo renglón de iconos.

2. Se muestra la descripción de Microsoft Azure, presionar el botón que dice “Registrarse Ahora”

3. Ingresar Numero de celular de preferencia para recibir el código de activación mediante un mensaje de texto en tu celular.

4. Ingresar código de activación recibido en tu número de celular.

5. Seleccionar que está de acuerdo en las licencias y presionar el botón de Suscribirse

6. Esperar configuración de Microsoft Azure.

7. Felicidades Microsoft Azure configurado

8. ahora podes usarlo entrando en http://portal.azure.com

Vamos a ver paso a paso como descargarse las herramientas desarrollo para usar Azure, y comenzar tus proyectos en la nube.

Si no tenes una maquina tan potente para utilizar las herramientas, seguí los pasos y desarrolla desde la nube.

PASO 1

Ingresar a la suscripcion de MSDN desde: https://msdn.microsoft.com/subscriptions/manage/hh442900

PASO 2

Buscar en el cuadro de texto “Visual Studio 2013 Ultimate with Update 3”, y hacer click en “Details”, y luego en “Direct download”. Esto lanzará una descarga.

PASO 3

Una vez finalizada la descarga, ejecutamos el archivo. Esto abre el instalador de Visual Studio. Aceptamos los terminos y condiciones, y damos click al boton “next”.

PASO 4

Seleccionamos los componentes que queremos instalar (ver imagen), y hacemos click en el botón “install”.

PASO 5

Instalar el SDK de Azure para .NET

Para desarrollar para la nube en .NET, necesitamos instalar el SDK de Azure.

Este es compatible con Visual Studio 2012 y 2013 en todas sus ediciones (express, pro, premium, ultimate).

Dejo los links y paso a paso para instalarlo en nuestro ambiente de desarrollo.

Instalar el SDK para VS 2013

Instalar el SDK para VS 2012

¿Donde empezar?: http://azure.microsoft.com/en-us/develop/net/

PASO 1

Descargar el SDK (links arriba) y ejecutarlo. Se va a lanzar el Web Platform Installer.

PASO 2

Apretar el botón “Install” (súper difícil )

PASO 3

Apretamos el botón “I Accept”.

Comenzara la instalación. Va a demorar según tu conexión a internet.

Muchas veces tenemos problemas de hardware que nos impiden utilizar las ultimas versiones de un software. En este paso a paso te voy a mostrar como levantar un ambiente de desarrollo donde puedas utilizar Visual Studio 2013 (o cualquiera) en un par de clicks, y sin necesidad de muchos procesadores

Todo esto lo vamos a hacer utilizando una maquina virtual en Azure.

Si aún no tenés cuenta, te dejo algunas opciones para que empieces:

• Free trial
• Subscriptores MSDN
• Miembros de BizSpark

PASO 1

Ingresar en https://manage.windowsazure.com/.

PASO 2

En la barra inferior, hacer click en el botón “+ new”, dentro de “compute” –> “Virtual Machine” –> “From Gallery”:

PASO 3:

En la galería, seleccionamos la maquina que se adecue a la versión de Visual Studio que quiero utilizar, recomiendo la ultima “Visual Studio Ultimate 2013 Update 3”. y luego click en la flecha de abajo a la derecha.

PASO 4:

Dependiendo del tipo de desarrollo que queramos hacer, necesitaremos una máquina poderosa. Yo elijo un A4 ya que pienso compilar proyectos grandes. Además, tenemos que elegir el usuario y password con el que nos vamos a conectar a Windows. Luego click en la flecha de abajo a la derecha.

PASO 5:

Elijo la región en donde quiero tener la maquina (para buscar la de menor latencia, podes entrar en azureping.info), luego click en la flecha de abajo a la derecha.

PASO 6:

Click en el tilde de abajo a la derecha. Esto va a comenzar a crear la maquina virtual, en unos minutos va a estar lista.

PASO 7:

Una vez creada, tendremos un servicio como el siguiente, al cual nos conectamos de forma remota:

De ahora en adelante, trabajamos en la máquina en Azure.

Windows 10 Technical Preview nos permite acceder a compilaciones tempranas del sistema operativo.

Como millones de personas, instale el preview en mi compu (build 9841). Hace unos días se libero el build 9860, y cuando fui a actualizar mi maquina, la actualización me arrojaba un error:

Preview Build failed to download 0x80246018

Para solucionarlo, hay que eliminar 2 claves de registro de Windows. Siguiendo los pasos:

1. Abrimos el registro de Windows apretando la tecla Windows + R, y escribiendo regedit
2. Navegamos por las carpetas: Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\WindowsSelfHost\Applicability
3. En esa carpeta deberíamos encontrar solamente las siguientes claves:

BranchName = fbl_release

ThresholdRiskLevel = low

ThresholdInternal = (si la encontramos, hay que eliminarla)

ThresholdOptedIn = (si la encontramos, hay que eliminarla)

Asi es como deberia quedar:

Espero sea de utilidad, con el nuevo build hay cosas muy copadas como el centro de notificaciones y efectos en ventanas.

Para probar Windows 10 Technical Preview, sigan el link: http://windows.microsoft.com/en-us/windows/preview

Media Services primarily offers on demand streaming, variable bit rate or smooth streaming, encoding to various formats including smooth streaming and storage capabilities. Under, but under the covers, it uses Azure App Fabric for compute and Blob Storage for hosting data. Thus it’s a Platform as a Service(PaaS) offering additional capabilities over infrastructure provided Azure.

Today we’ll see how to leverage Media Services to build an ASP.NET MVC application that allows users to upload and encode their videos in a Web Portal and playback the content on demand.

The Application Architecture

The diagram above gives us an overall view of how we can use Azure Media Services. The major steps involved are:

1. User logs into the ASP.NET MVC Web Application

2. Uploads their Video ‘assets’ to Azure Blob storage. The fact that it is going to Blob storage is transparent to the user, it’s a normal file upload for them.

3. Once uploaded, we can optionally encode the Video for smooth streaming.

4. Finally when the video (either smooth streaming version or the progressive download version) is requested by the user, it is streamed back to them.

5. On the client side, a Browser plugin is used to serve up the content.

With the basic premise out of the way, let’s get started with our application.

Setting up the ASP.NET MVC App and Pre-Requisites

Pre-Requisites – Setting up Azure Media Service

– We’ll need an active Azure account, if you don’t have one, you can avail a 90 day free trial at http://www.windowsazure.com. Keep an eye out for outgoing data and encoding charges if used.

– Login to the Azure Management Portal and click on the [+ New] button in the bottom toolbar and add a new Media Service by navigating as follows

App Service > Media Service > Quick Create

– In the Quick Create panel, provide the Name of your media service, the Region where you want it to be hosted and the Azure Storage account to use. If you don’t have a Storage Account already, you’ve to create a new one, else you can pick one of your existing Storage Accounts.

– Finally click on the ‘Create Media Service’ button to initiate service creation. Once the service is created, we’ll see a new Media Service and new Storage Service (if you opted for a new one) created.

Note: I am using an existing media service and storage account hence the names are different from the ‘Create New’ panel.

– Final step is to obtain the Service Keys. Click on the Media Service from the ‘All Items’ list.

Here you have multiple options to retrieve the Keys, you can download the sample project or click on the Manage Keys button to just view the keys.

Note, the keys and save them securely for easy access later in the app. We are now set on the Azure side. Let’s setup our MVC Application.

Setting up the MVC Application – Dependencies and Model design

Project Setup and Dependencies

To setup the application, we start off with the ASP.NET MVC 4 template and use the ‘Internet’ project type. This gives us the forms authentication module out of the box. Once the project is setup, we add the following Nuget package for the media services dependencies

PM> install-package WindowsAzure.MediaServices

This installs all packages necessary to use Azure Media Services APIs

Model Design

Our data model will be simple for this example. We’ll save the UserId, Title, FileUrl and a Boolean indicating if the file is visible to others, for every media asset uploaded.

public class MediaElement
{
public int Id { get; set; }
public string UserId { get; set; }
public string Title { get; set; }
public string AssetId { get; set; }
public bool IsPublic { get; set; }
}

We’ll generate the CRUD pages using the default ASP.NET MVC Scaffolding as follows

– Build the application

– Right click on Controller folder and select ‘Add’ > ’New Controller’

– Update the Template to use Entity Framework and the Model to use the MediaElement entity. Provide a new Data Context Class name and click Add to complete the codegen.

Updating Controller to use Authorization

Once the code is generated open the MediaController class add the Authorize attribute so that all actions can executed only when a user is logged in.

[Authorize]
public class MediaController : Controller
{
…
}

Updating Home Page to include My Media tab

Open the _Layout.cshtml file and add an Action Link to navigate to the Media Browser

<li>@Html.ActionLink(“My Media”, “Index”, “Media”)</li>

You can also update the Title, remove the About and Contact links etc.

Update the Index.html for the Home Controller (the landing page) by replacing the generic markup with something indicating that we have a ‘super special’ Media hosting Application.

This wraps up the basics, let’s dive in and see how we can implement the Media management part.

Integrating Media Services

Uploading Media files in chunks

As per our architecture diagram, user login has been implemented thanks to ASP.NET project template. Next thing to implement is the uploading of Media.

Media files, especially video files, can be large, spanning hundreds of MBs. As a result, it is not possible to upload these files in one go due to limitation of Request size imposed by IIS. So we will upload the media files in chunks. The topic of uploading files in chunk has been discussed in details in our article Uploading Big files to Azure Storage from ASP.NET MVC. I will use the same technique, so I won’t be reproducing the code here. If you are new to Azure Cloud Storage, I suggest you go through the previous article.

Adding an Upload Client

We will modify the default Application flow by changing the ‘Create’ link to ‘Upload’ in the Index.cshtml and navigating to a New page called Upload.

<p>
@Html.ActionLink(“Upload New Media”, “Upload”)
</p>

Views/Media/Index.cshtml

[HttpGet]
public ActionResult Upload()
{
return View();
}

Controllers/MediaController.cs

@{
ViewBag.Title = “Upload”;
}
<h2>Upload New Media</h2>
@using (Html.BeginForm())
{
<fieldset>
<legend>Media Element</legend>

<div class=”editor-label”>
Select Media File to Upload:
</div>
<div class=”editor-field”>
<input type=”file” id=”selectFile” value=” ” />
<input type=”button” id=”fileUpload” value=”Upload” />
</div>
<div id=”progressBar” style=”width: 50%; height: 20px; background-color: grey”></div>
<br />
<label id=”statusMessage”></label>
</fieldset>
}
<div>
@Html.ActionLink(“Back to List”, “Index”)
</div>
@section Scripts {
<script src=”~/Scripts/media-upload.js”></script>
@Scripts.Render(“~/bundles/jqueryui”)
@Scripts.Render(“~/bundles/jqueryval”)
}

Views/Media/Upload.cshtml

Add a JavaScript file media-upload.js and copy the script over from the Chunked Upload sample. Ensure the POST is going to the correct URL i.e. /Media/SetMetaData and /Media/UploadChunk.

Add reference to this script in the Upload.cshtml (as shown above). For the progress bar to show up properly, update the _Layout.cshtml to add the following css bundle

@Styles.Render(“~/Content/themes/base/css”)

Creating the Blob Storage Connection String

Before we continue we need to build the Blob Storage’s connection string. This is easy once you know the format:

DefaultEndpointsProtocol=<connectionType>;AccountName=<blobStorageAccountName>;AccountKey=<blobStorageAccessKey>

1. ConnectionType is either http or https

2. AccountName is the name of the storage account associated with your Media Service. You can go to your Azure Portal, Select Media Services (1) tab on the left, go to Linked Resources tab (2) and pick the name of the Storage account (3)

3. Account Key: In the above screen, click on the Storage account name to navigate to Storage Dashboard, from the bottom toolbar, click on ‘Manage Keys’ button to bring up the Key’s dialog, Copy the Primary Access Key.

4. Now that we have got all the three components, add a key to the Web.config’s appSettings section.

<add key=”StorageConnectionString” value=”DefaultEndpointsProtocol=https;AccountName=mediasvcc5hww8r75gwc0;
AccountKey=o+oXVH9PEVQ3AFC6xWBQHL9diuJ7jecU10oaGyw5wRhMbdLlA9f+lfoeGOsXgYQyaxrgFq8SFSj6nfFJa96cnA==” />

Finishing off the Upload functionality

Now that we’ve got the Storage connection string, add the following keys as well

<add key=”StorageContainerReference” value =”temporary-media” />
<add key=”MediaAccountName” value=”mediaservicedemo”/>
<add key=”MediaAccountKey” value=”hSpRS8OJuhJIktmSX9HhAeZKD+paOt05W+uSZC6Y2W8=” />

The StorageContainerReference is name of the temporary container to which media will be uploaded. The MediaAccountName is the name of the MediaService that we gave when we created the Service

MediaAccountKey is the access key, you can go to the Media dashboard and use the Manage Keys button like you did from the Storage dashboard, to copy the MediaAccountKey.

Next we add the SetMetadata, UploadCurrentChunk and CommitAllChunks methods into our MediaController.cs. Wherever we are Update the configuration strings appropriately.

If you run the app and try to upload a file, it will get uploaded to the temporary-media storage container. However our work isn’t done yet. We’ve simply uploaded it to blob storage, our Media service still doesn’t know about the video and can’t serve it up, or encode it. Add the following method in the MediaController and add call it from CommitChunks method:

private void CreateMediaAsset(CloudFile model)
{
…
}

This code fetches the media in the blob storage and create a new MediaService Asset out of it and copies it to a container controlled by Media Services. I have broken down the code for the above method in the following steps:

Step 1: Retrieve account keys and names

string mediaAccountName = ConfigurationManager.AppSettings[“MediaAccountName”];
string mediaAccountKey = ConfigurationManager.AppSettings[“MediaAccountKey”];
string storageAccountName = ConfigurationManager.AppSettings[“StorageAccountName”];
string storageAccountKey = ConfigurationManager.AppSettings[“StorageAccountKey”];

Step 2: Create the media service context.

CloudMediaContext context = new CloudMediaContext(MediaServicesAccountName,
MediaServicesAccountKey);

Step 3: Create instance of the CloudStorageAccount, this is the storage account associated with the Media Service.

CloudStorageAccount storageAccount = new CloudStorageAccount(new
StorageCredentials(MediaServicesStorageAccountName, MediaServicesStorageAccountKey),
true);

Step 4: Create a Storage Client instance from where we need to copy the file

var cloudBlobClient = storageAccount.CreateCloudBlobClient();
var mediaBlobContainer = cloudBlobClient.GetContainerReference(cloudBlobClient.BaseUri + “temporary-media”);
mediaBlobContainer.CreateIfNotExists();

Step 5: Create a new Media Asset and a Write Policy.

IAsset asset = context.Assets.Create(“NewAsset_” + Guid.NewGuid(),
AssetCreationOptions.None);
IAccessPolicy writePolicy = context.AccessPolicies.Create(“writePolicy”,
TimeSpan.FromMinutes(120), AccessPermissions.Write);

Step 6: Create a Destination Location in the Media Service and get the blob handle of the destination file (blob).

ILocator destinationLocator = context.Locators.CreateLocator(LocatorType.Sas, asset,
writePolicy);
// Get the asset container URI and copy blobs from mediaContainer to assetContainer.
Uri uploadUri = new Uri(destinationLocator.Path);
string assetContainerName = uploadUri.Segments[1];
CloudBlobContainer assetContainer =
cloudBlobClient.GetContainerReference(assetContainerName);

Step 7: Get Blob handle of the Source File

string fileName =
HttpUtility.UrlDecode(Path.GetFileName(model.BlockBlob.Uri.AbsoluteUri));
var sourceCloudBlob = mediaBlobContainer.GetBlockBlobReference(fileName);
sourceCloudBlob.FetchAttributes();

Step 8: Check for rudimentary properties to ensure the source file is valid and then create the file in the designation. Initiate copy from Blob.

Note: This is actually a job and takes a few seconds to reflect on the server if you are hitting refresh continuously.

if (sourceCloudBlob.Properties.Length > 0)
{
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
var destinationBlob = assetContainer.GetBlockBlobReference(fileName);
destinationBlob.DeleteIfExists();
destinationBlob.StartCopyFromBlob(sourceCloudBlob);
destinationBlob.FetchAttributes();
if (sourceCloudBlob.Properties.Length != destinationBlob.Properties.Length)
Console.WriteLine(“Failed to copy”);
}

Step 9: Once the copy is done delete the destination locator and the write policy.

destinationLocator.Delete();
writePolicy.Delete();

Step 10: Refresh the asset by retrieving it from the context

asset = context.Assets.Where(a => a.Id == asset.Id).FirstOrDefault();
var ismAssetFiles = asset.AssetFiles.ToList()
. Where(f => f.Name.EndsWith(“.mp4”, StringComparison.OrdinalIgnoreCase))
.ToArray();

if (ismAssetFiles.Count() != 1)
throw new ArgumentException(“The asset should have only one, .mp4 file”);

ismAssetFiles.First().IsPrimary = true;
ismAssetFiles.First().Update();
model.UploadStatusMessage += ” Created Media Asset ‘” + asset.Name + “‘ successfully.”;
model.AssetId = asset.Id;
}

Next we save the new MediaElement details for the current User.

Saving the Media Element

Once we know that the file has been saved to the Media Service, we can save the Title and Asset details to the database. To do this, we first update the CommitAllChunks method to send back the AssetId in the Json that we were returning.

return Json(new
{
error = errorInOperation,
isLastBlock = model.IsUploadCompleted,
message = model.UploadStatusMessage,
assetId = model.AssetId
});

Next we update the Update.cshtml to add a panel with the Title and Save button. This panel becomes visible once the Upload is complete and file saved to the Media Service.

<div id=”detailsPanel”>
<input type=”hidden” id=”assetId” />
<label id=”statusMessage”></label>
<br />
<div>
Title <input type=”text” id=”title” />
</div>
<button id=”saveDetails”>Save</button>
</div>

To toggle it’s visibility, we update the media-upload.js to hide it on document load and show it once the last chunk upload has returned successfully.

Next we add a Save method to the media-upload.js to post the AssetId and Title.

var saveDetails = function ()
{
var dataPost = {
“Title”: $(“#title”).val(),
“AssetId”: $(“#assetId”).val()
}
$.ajax({
type: “POST”,
async: false,
contentType: “application/json”,
data: JSON.stringify(dataPost),
url: “/Media/Save”
}).done(function (state)
{
if (state.Saved == true)
{
displayStatusMessage(“Saved Successfully”);
$(“#detailsPanel”).hide();
}
else
{
displayStatusMessage(“Saved Failed”);
}
});
}

This posts the data to a Save action method in our MediaController. We don’t have a Save method so far, so we add one to save the data to the database as follows:

[HttpPost]
public JsonResult Save(MediaElement mediaelement)
{
try
{
mediaelement.UserId = User.Identity.Name;
mediaelement.FileUrl = GetStreamingUrl(mediaelement.AssetId);
db.MediaElements.Add(mediaelement);
db.SaveChanges();
return Json(new { Saved = true, StreamingUrl =  mediaelement.FileUrl});
}
catch (Exception ex)
{
return Json(new { Saved = false });
}
}

Before we save the Data to the Server, we call the GetStreamingUrl method. This method does the equivalent of ‘Publishing’ data from the Web Portal. It creates an access policy that’s valid for a year and generates an appropriate URL for the uploaded media.

private string GetStreamingUrl(string assetId)
{
CloudMediaContext context = new
CloudMediaContext(ConfigurationManager.AppSettings[“MediaAccountName”],
ConfigurationManager.AppSettings[“MediaAccountKey”]);
var streamingAssetId = assetId; // “YOUR ASSET ID”;
var daysForWhichStreamingUrlIsActive = 365;
var streamingAsset = context.Assets.Where(a => a.Id ==
streamingAssetId).FirstOrDefault();

IAccessPolicy accessPolicy = context.AccessPolicies.Create(streamingAsset.Name,
TimeSpan.FromDays(daysForWhichStreamingUrlIsActive),
AccessPermissions.Read | AccessPermissions.List);
string streamingUrl = string.Empty;
var assetFiles = streamingAsset.AssetFiles.ToList();
var streamingAssetFile = assetFiles.Where(f => f.Name.ToLower().EndsWith(“m3u8-aapl.ism”)).FirstOrDefault();
if (streamingAssetFile != null)
{
var locator = context.Locators.CreateLocator(LocatorType.OnDemandOrigin,
streamingAsset, accessPolicy);
Uri hlsUri = new Uri(locator.Path + streamingAssetFile.Name + “/manifest(format=m3u8-
aapl)”);
streamingUrl = hlsUri.ToString();
}
streamingAssetFile = assetFiles.Where(f =>
f.Name.ToLower().EndsWith(“.ism”)).FirstOrDefault();
if (string.IsNullOrEmpty(streamingUrl) && streamingAssetFile != null)
{
var locator = context.Locators.CreateLocator(LocatorType.OnDemandOrigin,
streamingAsset, accessPolicy);
Uri smoothUri = new Uri(locator.Path + streamingAssetFile.Name + “/manifest”);
streamingUrl = smoothUri.ToString();
}
streamingAssetFile = assetFiles.Where(f =>
f.Name.ToLower().EndsWith(“.mp4”)).FirstOrDefault();
if (string.IsNullOrEmpty(streamingUrl) && streamingAssetFile != null)
{
var locator = context.Locators.CreateLocator(LocatorType.Sas, streamingAsset,
accessPolicy);
var mp4Uri = new UriBuilder(locator.Path);
mp4Uri.Path += “/” + streamingAssetFile.Name;
streamingUrl = mp4Uri.ToString();
}
return streamingUrl;
}

With that we have all the data we need to keep track of files uploaded by each user. Next up the media player.

Playing uploaded Media in Browser

We will leverage the excellent Player Framework project from Microsoft Media Service team. This is an OSS project on Codeplex and provides a set of clients to serve up Media along with other features like Playlist, Ad insertion and so on.

You have a variety of clients to choose, on the Web you can use HTML5 player and/or the Silverlight player. Today we’ll use the HTML5 player only.

Step 1: Download the Player Framework for HTML5 client from here. This consists of the playerframework.js and the playerframework.css both in their minified form.

Step 2: Add the style reference to _Layout.css (Bundle it as a best practice).

Step 3: Add a new JavaScript file media-player.js. It has only one function, that is to initialize the player framework client and depends on playerframework.js.

var mediaPlayer =
{
initFunction : function (window, sourceUrl)
{
var myPlayer = new PlayerFramework.Player(window,
{
mediaPluginFallbackOrder: [“VideoElementMediaPlugin”, “SilverlightMediaPlugin”],
width: “480px”,
height: “320px”,
sources:
[
{
src: sourceUrl,
type: ‘video/mp4;’
}
]
});
}
}

Step 4: Adding the player in the ‘Edit’ page (Edit.cshtml). Update the markup to hide the UserId, AssetId and FileUrl. These are not directly updatable by the user.

@Html.HiddenFor(model => model.Id)
@Html.HiddenFor(model => model.AssetId)
@Html.HiddenFor(model => model.FileUrl, new { id = “fileUrl” })
@Html.HiddenFor(model => model.UserId)

Step 5: Add a <div> that will serve as the container and then use the media-player script to tie the div to the PlayerFramework client. The FileUrl value is passed to the videoPlayer as well.

<div id=”videoPlayer”>
</div>

<div>
@Html.ActionLink(“Back to List”, “Index”)
</div>

@section Scripts {
<script src=”~/Scripts/playerframework.min.js”></script>
<script src=”~/Scripts/media-player.js”></script>
@Scripts.Render(“~/bundles/jqueryval”)
<script type=”text/javascript”>
mediaPlayer.initFunction(“videoPlayer”, $(“#fileUrl”).val());

</script>
}

That’s all that needs to be done to play the video.

Step 6: We can cleanup the Index.cshtml as well to show the Title and Delete options only, with the Title hyperlinked to the Edit page.

@model IEnumerable<AzureMediaPortal.Models.MediaElement>

@{
ViewBag.Title = “My Media Index”;
}
<h2>My Media Index</h2>
<p>
@Html.ActionLink(“Upload New Media”, “Upload”)
</p>
<table>
<tr>
<th>
@Html.DisplayNameFor(model => model.Title)
</th>
<th>
@Html.DisplayNameFor(model => model.IsPublic)
</th>
<th></th>
</tr>
@foreach (var item in Model) {
<tr>
<td>
@Html.ActionLink(@item.Title, “Edit”, new { id=item.Id })
</td>
<td>
@Html.DisplayFor(modelItem => item.IsPublic)
</td>
<td>
@Html.ActionLink(“Delete”, “Delete”, new { id=item.Id })
</td>
</tr>
}
</table>

Deleting Media

Finally we’ll update the Delete method in the controller to delete Assets from server as well. To do this, we again use the AssetId to create a context and delete the asset. Once the asset is deleted we delete the record from our database as well.

private void DeleteMedia(string assetId)
{
string mediaAccountName = ConfigurationManager.AppSettings[“MediaAccountName”];
string mediaAccountKey = ConfigurationManager.AppSettings[“MediaAccountKey”];
CloudMediaContext context = new CloudMediaContext(mediaAccountName, mediaAccountKey);
var streamingAsset = context.Assets.Where(a => a.Id == assetId).FirstOrDefault();
if (streamingAsset != null)
{
streamingAsset.Delete();
}
}

[HttpPost, ActionName(“Delete”)]
[ValidateAntiForgeryToken]
public ActionResult DeleteConfirmed(int id)
{
MediaElement mediaelement = db.MediaElements.Find(id);
DeleteMedia(mediaelement.AssetId);
db.MediaElements.Remove(mediaelement);
db.SaveChanges();
return RedirectToAction(“Index”);
}

With that we are ready to run our app, Demo Time!

Demo – Our personal Media Portal

Step 1: Run the application, Register yourself the first time and Login.

Step 2: Navigate to the My Media page and click on Upload New Media

Step 3: Browse and select a media file (only mp4 for this sample). Click upload to begin upload. You’ll notice the upload button gets hidden as the progress shows progress.

Step 4: After the file is uploaded 100%, you’ll notice a pause as the media is registered with Media Service and AssetID obtained.

Step 5: Once Media is registered with Media Service, you’ll see a Save button and an Input box to Save the Title for the uploaded file. Provide the title and hit Save. Once save completes, you will see a Video panel and be able to preview the uploaded video. Click on ‘Back to List’ to go back to the Index page.

Step 6: After saving you can navigate back to the index page.

Step 7: From the index page, you can click on the title to navigate to the Edit page.

Step 8: Here you can view the media asset as well as change the Title if you want. Save will navigate back to the Index page, from which we can go to the delete page to Delete the asset if no longer required.

Post en progreso, basado en: http://www.dotnetcurry.com/showarticle.aspx?ID=924

Para copiar un VHD de una cuenta de storage a otra (incluso de otra suscripción), hay que simplemente ejecutar un script de PowerShell.

Pre-requisitos:

• Instalar Microsoft Azure Powershell
• Configurar suscripcion de Azure en Powershell

Una vez que cumplamos con los requisitos. Hay que ejecutar el siguiente comando:

Select-AzureSubscription “Nombre de la Suscripción”

### VHD de origen – contenedor de acceso publico ###
$srcUri = “http://MISTORAGE.blob.core.windows.net/MICONTAINER/MIBLOB.vhd“

### Storage Account de destino ###
$storageAccount = “NOMBREDESTORAGEDESTINO”
$storageKey = “KEYDELSTORAGEDEDESTINO”

$destContext = New-AzureStorageContext  –StorageAccountName $storageAccount `
-StorageAccountKey $storageKey

### Contenedor de destino
$containerName = “CONTENEDORDESTINO”

### Creamos el contenedor de destino
New-AzureStorageContainer -Name $containerName -Context $destContext

### Copiamos asincronicamente ###
$blob1 = Start-AzureStorageBlobCopy -srcUri $srcUri `
-DestContainer $containerName `
-DestBlob “NOMBREBLOBDESTINO.vhd” `
-DestContext $destContext
### Traemos el estado de la copia ###
$status = $blob1 | Get-AzureStorageBlobCopyState

### Imprimimos el estado ###
$status

### Imprimimos estado hasta que se complete la copia ###
While($status.Status -eq “Pending”){
$status = $blob1 | Get-AzureStorageBlobCopyState
Start-Sleep 10
### Print out status ###
$status
}

2. Buscar en la lista de opciones “teclado”.

Se va a mostrar una lista de todas las distribuciones de teclados instalados en tu equipo.

Tocar para entrar a las opciones de cada teclado. (ver imagen abajo).

Por cada teclado, destildar la opción “Corregir palabras”.

Como deshabilitar las sugerencias de texto

Cando tipeamos algo, Windows Phone nos muestra una lista de palabras sugeridas. Si encontramos una que coincida, podemos seleccionarla para ahorrar tiempo al escribir todas las letras de esa palabra.

Yo personalmente utilizo esta función para escribir mas rápido. Pero, entiendo, que puede no ser útil para todos.

Para apagar esta función, dentro de las opciones de cada teclado, hay que destildar “sugerir texto”.

Deshabilitando las sugerencias de texto, también se deshabilita la corrección automática.

At TechEd North America 2014, we announced the general availability of Azure ExpressRoute, Virtual Networking enhancements, compute-intensive A8 & A9 VirtualMachines, IP Reservation, Import/Export Service, Managed Cache Service, Traffic Manager support for external endpoints, and several other features. In addition, we announced the public preview of RemoteApp, API Management, Redis Cache, Files, BizTalk Hybrid Connections, and Internal Loadbalancing. Support plans from the providers of top Linux distributions were also announced.

ExpressRoute now generally available

With Microsoft Azure ExpressRoute, you can create private, high-throughput connections between Azure datacenters and your existing infrastructure, whether it’s on-premises or in a colocation environment. ExpressRoute connections don’t go over the public Internet, and they offer more reliability, faster speeds, lower latencies, and higher security than typical connections over the Internet. As ExpressRoute enters general availability, we’re also pleased to offer a 99.9 percent SLA on ExpressRoute connection uptime. Plus, we’re offering two new bandwidth tiers for the Exchange Provider scenario: 200 Mbps and 500 Mbps.

If you were using ExpressRoute during the preview, you can continue to use the service at the preview rates until July 1, 2014. Lower connection speeds are now available at their general availability rates. If you don’t want to continue to use the ExpressRoute service at the new prices, you can delete the ExpressRoute connections for your account.

For more information, visit the ExpressRoute website. To get a comprehensive look at pricing, visit the ExpressRoute Pricing Details website.

General availability of Virtual Network enhancements

Announcing the general availability of the two most requested features for Azure Virtual Network: Multiple Site-to-Site and VNET-to-VNET connectivity.

First, Virtual Network now supports more than one site-to-site connection. So, you can now securely connect multiple on-premises locations with a virtual network (VNET) in Azure. Using more than one site-to-site connection comes at no additional cost. You incur charges only for the VNET gateway uptime.

Second, VNET-to-VNET connectivity has been enabled. That is, multiple virtual networks can be directly and securely connected with one another. Using this feature, you can connect VNETs that are running in different Azure regions and have traffic route via the Azure backbone. This feature enables scenarios that require presence in multiple regions, applications that are highly available, or the integration of VNETs for a larger network. The data traffic flowing between VNETs is charged at the same rate as egress traffic.

For more information, visit the Virtual Network website. To get a comprehensive look at pricing, visit the Virtual Network Pricing Details website.

Compute-intensive A8 and A9 instances now generally available for Virtual Machines

Compute-intensive A8 and A9 instances are now generally available for Azure Virtual Machines. These instances provide faster processors, faster interconnectivity, more virtual cores for higher computing power, and larger amounts of memory. A8 instances (which have 8 virtual cores and 56 GB of RAM) and A9 instances (which have 16 virtual cores and 112 GB of RAM) also include a 40-Gbit/s InfiniBand network that provides remote direct memory access (RDMA) technology for the maximum efficiency of parallel Message Passing Interface (MPI) applications. With these instances, customers can run compute-intensive and network-intensive applications such as high-performance cluster applications and applications that use modeling, simulation and analysis, video encoding, and so on.

For more information, visit the Virtual Machines website. To get a comprehensive look at pricing, including the details about Azure regions where A8 and A9 instances are available, visit the Virtual Machines Pricing Details website.

IP Reservation for VIPs now generally available, and instance-level public IPs for Virtual Machines in preview

You can now reserve public IP addresses and use them as virtual IP (VIP) addresses for your applications. This enables scenarios where your applications need to have static public IP addresses or where you need to update your applications by swapping the reserved IP addresses. You can reserve up to 5 addresses per subscription at no additional cost and assign them to the Azure Cloud Services of your choice. You can also reserve another 5 (for a total of 10) addresses at additional cost.

For more information, visit the Reserved IP website. To get a comprehensive look at pricing, visit the Reserved IP Pricing Details website

Also, you can now assign public IP addresses to your virtual machines, so they become directly addressable without having to map an endpoint to access them directly. This feature will enable scenarios like running FTP servers in Azure and monitoring virtual machines directly using their IPs. During preview, you can obtain two public IP addresses per subscription free of charge.

Import/Export service now generally available

By using Azure Import/Export, you can move large amounts of data into and out of Azure Blobs much faster than is possible by downloading data from the Internet. Transporting your data from your hard drives to Azure is easy. It can be completed by using the Microsoft high-speed, highly secured internal network to transfer the data to our datacenter.

Currently, Import/Export is available globally. To get started with Azure Import/Export, follow these instructions.

For more information, visit the Import/Export website. To get a comprehensive look at pricing, visit the Import/Export Pricing Details website.

If you don’t want to continue to use the Import/Export service at the new prices, you can disable the service for your account by using the Azure Management Portal.

Managed Cache Service now generally available

Azure Managed Cache Service gives you access to a highly secured, dedicated cache that’s managed by Microsoft. It provides high performance and great features and is easy to use in your cloud applications. A cache created using the Azure Cache Service is accessible from any application within Azure that’s running on Azure Web Sites, Cloud Services, or Virtual Machines.

For more information, visit the Azure Cache website. To get a comprehensive look at pricing, visit the Cache Pricing Details website.

If you don’t want to continue to use Managed Cache at the new prices, you can disable the service for your account by using the Azure Management Portal.

Traffic Manager support for external endpoints

Traffic Manager now supports both Azure endpoints and external endpoints. Traffic Manager enables you to control the distribution of user traffic to your specified endpoints. With support for endpoints that reside outside of Azure, you can now build highly available applications across Azure and on-premises. You can apply intelligent traffic management policies across all managed endpoints.

For more information, visit the Traffic Manager website. To get a comprehensive look at pricing, visit the Traffic Manager Pricing Details website.

Redis Cache Service now in public preview

Azure Redis Cache is a distributed, in-memory, managed cache that helps you build highly scalable and responsive applications, by providing you super-fast access to your data. Azure Redis Cache is based on the popular, open-source Redis Cache. It gives you access to a highly secured, dedicated Redis Cache that’s managed by Microsoft. A cache created using Redis Cache is accessible from any application within Azure.

Azure Redis Cache will be available via the new Azure Preview portal. Azure Redis Cache is available at no additional cost during public preview.

Retirement of existing Shared Caching Service

As previously announced, the current Azure Shared Caching Service will be retired in September 2014 and with it the Microsoft Silverlight–based portal. Because the Azure Cache Service is in general availability, we strongly encourage you to migrate all existing caches on Shared Caching to the new Azure Managed Cache Service.

Azure RemoteApp now in public preview

In today’s dynamic business environment, everyone wants to access corporate resources from a variety of devices and be productive anywhere, anytime. The “bring-your-own-device” trend presents not only an opportunity to increase productivity but also a challenge to maintain data compliance. To meet these ever-changing business needs with limited resources, you need a flexible infrastructure that can securely scale up or down.

Azure RemoteApp delivers Window Server session-based applications from Azure. With Azure RemoteApp, you can:

•Quickly respond to the dynamic needs of the business, without large capital requirements.  •Centralize and protect corporate applications with the security features and reliability of Azure.

For more information, visit the Azure RemoteApp website. RemoteApp is available at no additional cost during public preview.

API Management now in preview

Azure API Management enables organizations to publish APIs more reliably, more securely, and at scale. Use API Management to engage with and drive API consumption among developers, partners, and even internal teams while benefiting from the business and operational insights available in the admin portal. This service provides the tools that your organization needs to manage APIs—from provisioning user roles to creating usage plans and quotas, applying policies for transforming payloads, throttling, conducting analytics, monitoring, and configuring alerts.

For more information, visit the API Management website. To get a comprehensive look at pricing, visit the API Management Pricing Details website.

Internal Loadbalancing now in public preview

The ability to load-balance Azure (VMs) with private IP addresses is now in public preview. The internally load-balanced endpoint will be accessible only within a virtual network (if the VM is within a virtual network) or within a cloud service (if the VM isn’t within a virtual network). Internal Loadbalancing is useful when you’re creating multitier applications in which some of the application tiers aren’t public facing but require load-balancing functionality. Internal Loadbalancing is available in the standard tier of VMs at no additional cost.

For more information, visit the Internal Loadbalancing website.

Azure Files now in public preview

Azure Files enables virtual machines in an Azure datacenter to mount a shared file system using the SMB protocol. These VMs are then able to access the file system using standard Windows file APIs (CreateFile, ReadFile, WriteFile, and so on). Many VMs (or Platform as a Service roles) can attach to these file systems concurrently, so you can share persistent data easily between various roles and instances. In addition to accessing your files through the Windows file APIs, you can access your data using the REST API, which is similar to the familiar Blob service interface.

To use the Azure Files service, create a storage account using the Azure Management Portal or the Microsoft Azure Service Management API. Any new accounts that you create using your approved subscriptions will automatically be enabled for Azure Files.

For more information, visit the Azure Files website. During public preview, preview services are offered at a discount. To get a comprehensive look at pricing, visit the Azure Files Pricing Details website.

BizTalk Hybrid Connections now in preview

With no custom code required, Azure BizTalk Hybrid Connections enables you to connect to any on-premises TCP or HTTP resource—such as Microsoft SQL Server, MySQL, or any web service—from Azure Web Sites. To get started, just add a new Hybrid Connection to your web site in the Azure Preview portal.

For more information, visit the Hybrid Connections website.

Support plans now available from the providers of top Linux distributions

Support plans are now available direct from the providers of top Linux distributions. If you’re running Linux in Azure Virtual Machines and have purchased Azure support, you can take advantage of these plans by deploying the associated image in the Azure image gallery.

For more information, visit the Linux Support Plans website. To get a comprehensive look at pricing, visit the Linux Support Plans Pricing Details website.

(comunicación enviada por correo, por eso en ingles )

Si utilizar Mercurial para versionar tu código, y querés tener tu servidor en Windows, seguí este paso a paso:

Pre-requisitos:

• Descargar Mercurial HG (mercurial-X.X.X.win-amd64-py2.6.exe)
  • https://bitbucket.org/tortoisehg/thg-winbuild/downloads
• Equipo o virtual con Windows (server preferentemente)
• Web Platform Installer
  • http://www.microsoft.com/web/downloads/platform.aspx

PASO 1 – Instalar Web Platform Installer

1. Ingresar en http://www.microsoft.com/web/downloads/platform.aspx y hacer click en “”Free Download”
   
2. Abrir WPI, buscar “Python”, e instalar la versión 2.6
3. Alternativamente, utilizar el sitio oficial para descargar la versión 2.6 desde http://www.python.org/download/releases/2.6/

PASO 2 – Configurar Windows Server

1. Abrir el “Server Manager”
   
2. Hacer click en “Add roles and features”.
   
3. Luego en el botón “Next –>”
   
4. Seleccionar “Role-based or featured-based installation”, y hacer click en el botón “Next –>”
   
5. Elegir el equipo al que se aplicara el rol, y luego el botón “Next –>”
   
6. Seleccionar “Web Server (IIS)”, y luego el botón “Next –>”
   
7. Avanzar hacia “Roles Services”, clickeando en “Next –>” con las opciones que vienen por defecto.
   
8. Seleccionar las siguientes opciones dentro de “Roles services”
   1. Common HTTP Features
      1. HTTP Redirection
   2. Health and Diagnostics
      1. Loggin tools
   3. Performance
      1. Dynamic Content Compression
   4. Security
      1. Basic Authentication
      2. IP and Domain Restrictions
      3. URL Authorization
   5. Application Development
      1. CGI
   6. Management Tools
      1. IIS Management Scripts and Tool
9. Confirmamos e instalamos.
   

PASO 3 – Instalar Mercurial

1. Ingresar en https://bitbucket.org/tortoisehg/thg-winbuild/downloads y descargar el instalador de la versión deseada que termine en “win-amd64-py2.6.exe” (Mercurial with Python) por ejemplo: “mercurial-2.2.2.win-amd64-py2.6.exe”
2. Instalar Mercurial
   

PASO 4 – Mercurial como Web Application

1. Verificar que IIS funcione correctamente, abriendo un navegador y accediendo a http://localhost
   
2. Crear una nueva carpeta en c:/inetpub/wwwroot
   
3. Ingresar en IIS Manager, y convertir la carpeta recien creada en una Application
   
4. Hacemos click en la nueva aplicación (hg), y luego en “Handler Mappings”
   
5. Agregar un “Script Map” con la siguiente info:
   1. Request path: *.cgi
   2. Executable: C:\Python26\python.exe -u “%s”
   3. Name: Python
      

PASO 5 – Probar Python

1. Crear un archivo “test.cgi” dentro de la carpeta “hg” que creamos como aplicacion en IIS, con el siguiente contenido:
   

   print ‘Status: 200 OK’
   print ‘Content-Type: text/html’
   print
   print ‘<html><body><h1>It Works!</h1></body></html>’

   

2. Ingresar al archivo desde http://localhost/hg/test.cgi
   
3. Borrar el archivo, solo sirve para probar que funcione Python.

PASO 6 – Configuraciones finales

1. Instalar desde Web Platform Installer “URL Rewrite 2.0”
2. Abrir una consola (Windows + R, CMD, Enter) y ejecutar los siguientes comandos:

%windir%\system32\inetsrv\appcmd.exe unlock config -section:system.webServer/security/authentication/anonymousAuthentication

%windir%\system32\inetsrv\appcmd.exe unlock config -section:system.webServer/security/authentication/basicAuthentication

• Descargar de aqui un Zip con los archivos necesarios para que funcione mercurial, y extraerlos en c:\intepub\wwwroot\hg.
• Acceder a http://localhost/hg y veremos nuestro cliente Web de mercurial funcionando!

Pasa poder utilizar el corrector ortográfico en Windows Live Writer, hay que completar los siguientes pasos:

1) Descargar el paquete de idioma desde acá.

2) Extraer los archivos a la carpeta “C:\Program Files (x86)\Windows Live\Writer\Dictionaries”

3) Cerrar Windows Live Writer (si estaba abierto)

4) Abrir Windows Live Writer

5) En el menú File –> hacer click en “Options”

6) Dentro del submenú “Spelling”, seleccionar el idioma desde el combo. Ahora va a aparecer “Spanish”.

Si queres limitar los paquetes de NuGet a los que puede tener acceso tu equipo de desarrollo, vas a necesitar crear tu propio feed de paquetes.

Para ello, necesitamos crear una carpeta nueva donde copiemos los paquetes que queremos disponibles en nuestro feed. (.nupkg)

Una vez que tenemos los paquetes, debemos abrir Visual Studio 2013 y configurar esta carpeta como proveedora.

PASO 1:

En el menu, hacer click en TOOLS, luego en “Library Package Manager”, y luego en “Package Manager Settings”.

PASO 2:

Se abrira una ventana como muestra la siguiente imagen:

Hacer click en el boton “+” (esquina superior derecha).

Luego configurar el nombre de nuestro feed y la ruta a la carpeta que creamos anteriormente.

Para limitar los paquetes online, debemos eliminar el feed que viene por defecto.

PASO 3:

Creamos un proyecto nuevo, o abrimos uno existente, y sobre el proyecto hacemos click derecho, y luego en “Manage NuGet Packages…”.

Encontraremos dentro de la seccion “Online” los feeds que agregamos en el segundo paso.

Acá esta todo el contenido de Emprendedor 5 Estrellas Versión Gamer!

Assets

Como instalar Construct2

Estrella 1

Lunes 2 de Septiembre de 2013

Video

Estrella 2

Lunes 9 de Septiembre de 2013

Video

Estrella 3

Lunes 16 de Septiembre de 2013

Video

Templates de juegos:

Salto infinito

Torres

Estrella 4

Lunes 23 de Septiembre de 2013

Estrella 5

Lunes 30 de Septiembre de 2013

Para poder generar un juego en la plataforma Windows 8, debemos instalar un plugin a Construct 2.

PASO 1

Descargar el plugin desde:

https://blog.alebanzas.com.ar/wp-content/uploads/2013/09/metro-plugin-r10.zip

PASO 2

Para instalar, arrastrar la carpeta exporters dentro de la carpeta de instalación de construct 2

Reemplazar los archivos.

Paso a paso como instalar Construct2 para poder comenzar a hacer tus propios juegos!

PASO 1

Descargar Construct2 desde: https://www.scirra.com/construct2/releases/r139

PASO 2

Ejecutar el instalador.

PASO 3

Hacer click en el botón “Next >”

PASO 4

Aceptar términos y condiciones de uso, y hacer click en “Next >”

PASO 5

Sin cambiar la carpeta de instalación original, hacer click en el boton “Next >”

PASO 6

Construct2 va a detectar automáticamente la arquitectura de tu equipo dando click en el botón “Next >”

PASO 7

Nuevamente, hacemos click en el botón “Next >”

Y luego en el botón “Install”

PASO 8

Esperar a que el programa de instalación finalice su trabajo.

PASO 9

Tildamos solamente “launch construct 2”, y luego hacemos click en el botón “Finish”

Luego de estos simples pasos, podremos comenzar a utilizar Construct 2 para hacer los mejores juegos!

Windows Azure es la plataforma en la nube de Microsoft. En este post voy a explicar paso a paso como dar de alta una maquina virtual con Windows Server 2012 R2 Preview.

PREREQUISITOS

• Tener una cuenta o trial de Windows Azure. (trial) (próximamente post)

PASO 1

Ingresar al portal desde: https://manage.windowsazure.com/

PASO 2

En la parte inferior izquierda, dar click en el botón “+ nuevo”.

PASO 3

Elegir dentro del grupo de soluciones disponibles “Proceso”, luego “Maquina virtual”, y seleccionar “de la galería”.

PASO 4

Aparecerá un listado de las maquinas virtuales disponibles. Elegir “Windows Server 2012 R2 Preview”.

PASO 5

Elegir nombre, tamaño, usuario y contraseña a la maquina virtual.

Detalles de tamaños disponibles en maquinas virtuales:

*El tamaño ExtraSmall esta disponible para el SDK 1.3 o inferior solamente.
**Las maquinas A6 y A7 pueden no estar disponibles en todas las ubicaciones.

PASO 6

Abrir el puerto 80 (HTTP).

Damos aceptar, y se empezara a crear la maquina virtual. Podemos ver el estado en la barra de estado del portal.

PASO 1

Ingresar en https://www.dreamspark.com/Account/CreateAccount.aspx

PASO 2

Registrarse como estudiante.

PASO 3

Hacer click en “Tengo un código de verificación” (pedirme un código vía FB, TW o paloma mensajera )

PASO 4

Completar el código, y hacer click en comprobar.

PASO 5

Ingresar en https://www.dreamspark.com/Product/Product.aspx?productid=44

Y descargar Visual Studio.

Como una imagen vale mas que mil palabras, les voy a mostrar como cambiar el fondo de su pantalla de inicio en Windows 8.1.

Y que mejor que hacerlo también con imágenes.

1. Hacemos click en “configuración” dentro del charm bar.

2. Luego en “personalizar”.

3. Tan simple como seleccionar que fondo queremos, yo personalmente uso el mismo fondo que mi escritorio (ultima opción abajo a la derecha).

Post cortito y al pie. Espero les sirva.

Acabo de actualizar mi teléfono HTC HD7 a la versión 7.8 de Windows Phone de manera exitosa, y quería compartir el procedimiento.

Mi teléfono tenia la versión 8107 (WP 7.5) en ingles, sin otro idioma instalado. Aclaro todo esto porque, ante un error en la actualización, vas a tener un pisapapeles muy caro, y no me hago responsable de daño en equipos de terceros , quien quiera actualizar su equipo lo hace bajo su propio riesgo.

La actualización la hice desde un equipo con Windows 8, y Zune instalado en su ultima versión.

Lo que necesitamos:
1. Zune (instalado en la región por default)
2. Cable USB
3. Archivos CAB **Mas abajo están los links, NO DESCOMPRIMIRLOS**
4. Archivos de idioma **Mas abajo están los links, NO DESCOMPRIMIRLOS**
5. CAB sender

Pasos a seguir, para lograr una actualización ordenada y sin complicaciones:
1. Crear 2 carpetas en el escritorio; 1. “phone updates” y otra “”CAB sender“
2. Dentro de la carpeta “phone updates” crear 5 carpetas con los siguientes nombres: “8107-8112”, “8112-8773”, ”8773-8779”, “8779-8783”, “8783-8858”. Acá vamos a guardar los archivos CAB de forma ordenada.
3. Descargar WPupdate del siguiente link http://depositfiles.com/files/c9t0p5pte
4. Descomprimir WPupdate en la carpeta “CAB sender” creada en el paso 1. Luego cortar la carpeta “if needed install this tool” y pegarla en la carpeta “phone updates”, y dejar el resto como está.
5. Descargar los archivos CAB y los de idioma de la actualización 8107-8112 de los siguientes links:
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/05/diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft-pluspkr.pks_d500a10eeb11fb6c1913adac4759d67185474d3e.cab
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/03/diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.dpi_262.pks_24bb20423e86130365686c1796577d4b22343be9.cab
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/03/diff-7.10.8107.79-7.10.8112.7-armv7-retail-microsoft.lang_0409.pks_ae068921fd637ba2e3e268b28e6ca1c9f3a9c11f.cab
6. Guardar los 3 archivos en la carpeta “8107-8112”
7. Descargar los archivos de idioma de la actualización 8112-8773 de los siguientes links:
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/05/diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.pks_113460c78ac6233e3bb776ceddb6ac94e98c4221.cab
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/05/diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.dpi_262.pks_4dbf7302a7b3da01eeafbcfbf1b9b75e6f6de15e.cab
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/05/diff-7.10.8112.7-7.10.8773.98-armv7-retail-microsoft.lang_0409.pks_3e940c840ee4815422610bb6da8f28ac327767cc.cab
8. Guardar los 3 archivos en la carpeta “8112-8773”
9. Descargar los archivos de idioma de la actualización 8773-8779 de los siguientes links:
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/05/diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.pks_b9598a098a3a4e902d043cef778a79ff3e6b0869.cab
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/05/diff-7.10.8773.98-7.10.8779.8-armv7-retail-microsoft.lang_0409.pks_4d87f62a11c7898a516df7563a9333e1082fad57.cab
10. Guardar los 2 archivos en la carpeta “8773-8779”
11. Descargar el archivo de idioma de la actualización 8779-8783 del siguiente link
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/10/diff-iucorefixed-7.10.8779.8-7.10.8783.12-armv7-retail-microsoft.pks_8a50b92b21951c7baf9f3600cea8c77e0918021f.cab
12. Guardar el archivo en la carpeta “8779-8783”

13. Por ultimo descargar los archivos CAB y los de idioma de la actualización “8783-8858” de los siguientes links:
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/11/diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.pks_d6fb2a271eed6a5d1187b17aba60806753d0ffce.cab
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/11/diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.dpi_262.pks_39b9cc884c90d83c0df50ed5623166e9257d1162.cab
http://download.windowsupdate.com/msdownload/update/software/dflt/2012/11/diff-7.10.8783.12-7.10.8858.136-armv7-retail-microsoft.lang_0409.pks_653898f93f54d951992766d317db1b846ca71e36.cab
14. Guardar los 3 archivos en la carpeta “8783-8858”
15. Abrir Zune, conectar el telefono, y asegurarse que lo reconoce. Una vez confirmado esto, cerrar Zune.
16. Navegar a la carpeta “8107-8112” y copiar los .CAB a la carpeta “CAB sender”.
17. En la carpeta “CAB sender” abrir la carpeta “tools”, y ejecutar el archivo “UpdateWP”. (se abre una ventana DOS y se cierra sola)
18. Volver a la carpeta “CAB sender” y ejecutar el batch “WP7 Update Cab Sender”.
19. Se abre una ventana DOS del CAB sender con varias opciones. Yo elegí enviar el CAB con backup en todas las actualizaciones, pero eso es decisión de cada uno. Para enviar con backup apretar la tecla B, sin backup la tecla S.

** Si aparece un error sobre un puerto COM, hay que ir a la carpeta “if needed install this tool” que movimos del ZIP en el paso 4, e instalar el programa que esta dentro de la carpeta, según tu arquitectura (x86 o x64), una vez instalado, volver a repetir los pasos desde el 17. No debería volver a haber error. Si no lo hay, podes seguir**
20. Dejar que el programa ejecute la actualización sin tocar nada.
21. Cuando la actualización se complete, cerrar el programa.
22. Eliminar los .CAB de la carpeta CAB sender.
23. Repetir los pasos del 16 al 22, reemplazando “8107-8112” por “8112-8773”, y sucesivamente por cada actualización.
24. Repetir con los .CAB de todas las actualizaciones hasta la versión 8858 (WP 7.8)
25. Eso es todo. Bienvenido a WP 7.8!

Me comentaron que se puede actualizar también: Nokia Lumia 710, Nokia Lumia 800, y LG Optimus

Fuente original

Desde que comenzó a funcionar el servicio, el 22 de julio de 1999 como MSN Messenger, y desde 2005 como Windows Live Messenger, este sistema de mensajería instantánea supo posicionarse como el mas usado por el publico masivo, alcanzando mas de 330 millones de usuarios.

Hace varios meses se viene escuchando el rumor de que el servicio se va a discontinuar, y esos rumores se confirman. El 15 de Marzo WLM no va a funcionar.

Microsoft va a retirar el servicio existente Windows Live Messenger (WLM) de manera global (exceptuando China), para unificar el servicio en una única plataforma mas robusta, Skype.

Los usuarios que utilizamos WLM no vamos a dejar de comunicarnos con nuestros amigos y contactos, ya que, con nuestra misma Microsoft Account (el mismo usuario y password que utilizamos en WLM, antes llamada .NET Passpost, luego Windows Live ID), vamos a poder utilizar el servicio de mensajería y videoconferencia Skype. Manteniendo los contactos que teníamos en WLM. Con Skype vamos a poder, no solo enviar mensajes instantáneos, sino también realizar video llamadas, sin costo alguno, y con la posibilidad de utilizarlo desde cualquier dispositivo móvil y tablet.

Pasos para instalar Skype

¿Nuevo en Skype?

1. Descargar la ultima versión de Skype.
2. Iniciar sesión a Skype con tu Microsoft Account.

¿Ya utilizas Skype?

1. Actualiza a la ultima versión de Skype.
2. Inicia sesión con tu Microsoft Account.
3. Vincula tu cuenta existente de Skype con tu Microsoft Account.

¿Que va a pasar desde hoy hasta el 15 de Marzo?

Messenger va a seguir funcionando de la misma forma que lo venís utilizando. Si inicias sesión con la ultima versión de escritorio, vas a ver una notificación que explica como actualizar a Skype.

¿Que va a pasar después del 15 de Marzo?

Si intentas inicias sesión con la ultima versión de escritorio, vas a ver una notificación que explica como actualizar a Skype y desinstalar el Messenger, que a esa altura, no va a servir mas que como recuerdo.

Tengo un HTC HD7, y hoy, cuando hice una llamada, nunca la pude cortar.. Se puso la pantalla negra, sin posibilidad de apretar ningún botón, y menos la pantalla.. la única opción que me quedo fue apagarlo arrancando la batería (ultima instancia).

Cuando ya pensaba que tenia que resetearlo, encontré en internet la solución que quiero compartir, porque me dio resultado y me pareció muy simple.

DIAGNOSTICO:

Problema en el sensor de proximidad que tiene el equipo, que hace que la pantalla se apague cuando estas con el teléfono en la oreja, para evitar que durante la llamada aprietes algo sin intención.

SOLUCION:

Presionar fuerte en el área donde se encuentran los sensores. Listo.. eso es todo..

Luego de instalar WordPress 3.5, intenté una actualización de plugins sin éxito, con el siguiente mensaje de error:

Download failed. Destination directory for file streaming does not exist or is not writable.

Este error es generalizado no solo a todos los plugins, sino también a los themes.

Para resolverlo debemos seguir los siguientes 2 pasos.

PASO 1

Ir al archivo /wp-includes/class-http.php , buscar y comentar las siguientes líneas (el comentario en PHP es con doble barra // )

if ( ! is_writable( dirname( $r[‘filename’] ) ) )
return new WP_Error( ‘http_request_failed’, __( ‘Destination directory for file streaming does not exist or is not writable.’ ) );

PASO 2

Ir al archivo wp-config.php (en el directorio raíz), y agregar la siguiente línea, que va a reemplazar el directorio temporal por uno al que WordPress tenga acceso.

define( ‘WP_TEMP_DIR’, ABSPATH . ‘wp-content/’ );’

Con esos 2 simples pasos, podes volver a administrar plugins y themes sin problemas.

Vamos a armar una aplicación que acceda a la librería de imágenes del usuario. Esto se podría utilizar para que el usuario seleccione una foto de perfil, comparta una foto, etc..

Pre-requisitos:

Ambiente de desarrollo instalado

Para comenzar, abrimos Visual Studio 2012, y en el menú elegimos File –> New –> Project…

Seleccionamos en el árbol de la izquierda “Otros lenguajes” –> “JavaScript” –> “Windows Store” y damos Aceptar

Una vez creada la solución y proyecto, abrimos el archivo default.HTML, y reemplazamos

<p>Content goes here</p>

por

<div id="listviewDiv" class="imageGallery"></div>

Vamos a utilizar ese DIV para mostrar las imágenes.

Así como en las aplicaciones XAML utilizamos C# para enviar a la vista el modelo a renderizar, en las aplicaciones HTML utilizamos JavaScript para lograr lo mismo.

Con la siguiente función vamos a obtener las imágenes de la librería del usuario, para luego mostrarlas en el DIV.

function loadListViewControl() {
        //Construimos el origen de datos para obtener las imagenes
        var library = Windows.Storage.KnownFolders.picturesLibrary;
        var queryOptions = new Windows.Storage.Search.QueryOptions;
        queryOptions.folderDepth = Windows.Storage.Search.FolderDepth.deep;
        queryOptions.indexerOption = Windows.Storage.Search.IndexerOption.useIndexerWhenAvailable;

        var fileQuery = library.createFileQueryWithOptions(queryOptions);
        var dataSourceOptions = {
            mode: Windows.Storage.FileProperties.ThumbnailMode.picturesView,
            requestedThumbnailSize: 190,
            thumbnailOptions: Windows.Storage.FileProperties.ThumbnailOptions.none
        };

        var dataSource = new WinJS.UI.StorageDataSource(fileQuery, dataSourceOptions);
        // Todo el codigo de arriba se puede simplificar con la siguiente línea 
        // Pero, preferí usar la “forma larga” para mostrar todas las opciones
        // var dataSource = new WinJS.UI.StorageDataSource("Pictures");
        // obtenemos el DIV anterior, para utilizarlo como contenedor
        var container = document.getElementById("listviewDiv");
        var listViewOptions = {
            itemDataSource: dataSource,
            itemTemplate: storageRenderer, //Explicado mas abajo
            layout: new WinJS.UI.GridLayout(),
            selectionMode: "single"
        };
        // Convertimos nuestro DIV en un ListView
        new WinJS.UI.ListView(container, listViewOptions);
    };

Una de las propiedades del ListView es el itemTemplate, esta se utiliza para definir la forma en la que se va a mostrar cada item en la lista.

En este ejemplo, utilizamos una función que va a generar los elementos HTML necesarios para nuestro itemTemplate.

function storageRenderer(itemPromise, element) {
        var img;
        if (element === null) {
            // Creamos un div con class FileTemplate, y adentro le metemos una imagen <img>
            element = document.createElement("div");
            element.className = "FileTemplate";
            element.appendChild(document.createElement("img"));
        }
        img = element.querySelector("img");
        img.style.opacity = 0;

        return {
            // retornamos el template
            element: element,
            // y la promesa de que se va a completar la carga de la imagen
            renderComplete: itemPromise.then(function (item) {
                // devolvemos el item cuando esta listo
                return item.ready;
            }).then(function (item) {
                // luego de tener el item listo, seteamos el source (src) a la imagen
                return WinJS.UI.StorageDataSource.loadThumbnail(item, img);
            })
        };
    }

Con esas pocas líneas, ya tenemos un listado de las imágenes del usuario.

Les dejo el link con la solución completa para que puedan usar: https://blog.alebanzas.com.ar/wp-content/uploads/2012/11/PictureLibrary.zip

Las Windows Store apps, son aplicaciones que corren en la Interfaz Moderna de Windows 8 (modern UI). Estas aplicaciones se pueden obtener desde la tienda de Windows 8 (Windows Store), y son ejecutadas en un ambiente controlado, que le permite al usuario tener la seguridad de que toda aplicación descargada desde el Store es libre de virus, malware, accede solamente a recursos declarados, solicita al usuario acceso a ciertos recursos sensibles, y que cumplen un estricto proceso de certificación para ser publicadas.

En tiempo de ejecución, las aplicaciones corren dentro de un contenedor (proceso wwahost.exe), que es quien provee la seguridad, permite o deniega acceso a los recursos, bloquea la comunicación entre procesos, y es quien renderiza la aplicación para que el usuario pueda interactuar con ella, utilizando el motor de Internet Explorer 10 (Chakra).

A la hora de desarrollar es importante tener en cuenta los siguientes puntos sobre nuestras aplicaciones:

• Corren en un ambiente dedicado, que no puede interferir ni ser interferido por el de otras aplicaciones.
• Tienen acceso sin restricción a carpetas que el sistema operativo le asigna a cada app (appdata).
• El acceso a dispositivos sensibles (cámara, micrófono, GPS) necesita explicito permiso del usuario.
• No pueden acceder al registro de Windows.
• No pueden ejecutar otras aplicaciones, y están aisladas de las otras aplicaciones, para evitar ataques.
• No se pueden comunicar con aplicaciones de escritorio.

Si pensamos desarrollar aplicaciones que utilicen recursos del sistema (cámara, GPS, acceso a internet, etc..), deben ser declarados en el archivo package.appxmanifest (ver imagen)

Si intentáramos acceder a un recurso no declarado, no solo no parara la certificación para ser publicada en Windows Store, sino que el contenedor lanzará una excepción en tiempo de ejecución.

En resumen, a la hora de desarrollar aplicaciones que utilicen recursos y/o dispositivos, deben ser declarados en el manifiesto, y no olvidar explicar en la descripción de la aplicación porque se utilizan.

Desde el punto de vista del usuario final, las aplicaciones que corren en la interfaz moderna de Windows 8, descargadas desde Windows Store, son lo suficientemente seguras como para instalarlas y utilizarlas con tranquilidad.

La nueva interfaz moderna de Windows 8 abre la puerta a los desarrolladores a un nuevo Store con la posibilidad de ser pioneros con nuestras aplicaciones, que nos dan la oportunidad de llegar al inmenso mercado de dispositivos con Windows 8.

Este nuevo ecosistema nos permite utilizar todo nuestro conocimiento en tecnologías ya manejadas como HTML5/JS/CSS3, C#, XAML, C++, para desarrollar nuestras aplicaciones.

Para comenzar a desarrollar, necesitamos instalar Windows 8, y Visual Studio 2012.

Se puede descargar Windows 8 desde el portal de subscripción de MSDN, u obteniendo una evaluación desde el evaluation center.

Una vez instalado Windows 8, debemos instalar Visual Studio 2012, que lo podemos obtener en su versión Express desde la pagina de descarga.

Dejo otros links de interés:

• Portal para desarrolladores
• Documentación
• Ejemplos
• Centro de descargas
• EBook gratuito “Programming Windows 8 Apps with HTML, CSS, and JavaScript”

Ayer se lanzo el SDK de Windows Phone 8 en el BUILD developer conference. Se anuncio Windows Phone 8 disponible en 191 mercados y en 50 idiomas. La plataforma de desarrollo esta pensada para que utilices skills adquiridos si desarrollas con tecnologías Microsoft.

A la plataforma existente en Windows Phone 7, se le agrega soporte de código nativo, y la API de Windows Runtime (WinRT). Esto nos permite reutilizar gran cantidad de nuestro código de otras aplicaciones, para portarlas en esta nueva plataforma. Esta decisión esta alineada al lanzamiento de Windows 8 no solo a nivel visual, sino también para desarrollo con sus aplicaciones nativas que corren en WinRT y utilizan la misma API.

Requerimientos de sistema:

Sistema operativo: Windows 8, Windows 8 Pro

• Windows 8 64-bit (x64)

• Hardware:
  • 4 GB de espacio en disco
  • 4 GB RAM
  • Procesador de 64-bit (x64)
• Windows Phone 8 Emulator:
  • Windows 8 Pro
  • Procesador con soporte SLAT (Second Level Address Translation)

Igualmente, si  tu procesador no soporta SLAT, podes instalar el SDK sin el emulador, y vas a poder desarrollar igual.

Links relacionados:

• Descarga el SDK para Windows Phone 8
• Getting Started
• Dev Center
• //BUILD/

Más de 350 estudiantes de 75 países viajaron a Sídney después de competir en eventos locales y en línea, para representar a su país y competir en las Finales Mundiales de Imagine Cup. Los premios en efectivo hacen un total aproximado de $175 mil USD y se entregan en ocho categorías diferentes.

“En los últimos 10 años, los participantes de Imagine Cup han aplicado la tecnología y sus mentes para impactar de manera positiva sus comunidades locales y cambiar el mundo”, dijo Moorthy Uppaluri, director general de programas académicos globales en Microsoft. “Ya sea que utilicen la nube para ayudar en la recuperación ante un desastre, inventar tecnología para hacer la educación más accesible y borrar la brecha digital o hacer posible el diagnóstico médico a través de teléfonos móviles, Imagine Cup ha inspirado a los estudiantes a imaginar lo que antes se consideraba imposible y hacerlo realidad”.

Todos los equipos que participaron en las Finales Mundiales de Imagine Cup 2012 en Sídney este año, son elegibles para aplicar al programa Imagine Cup Grants, una inversión de tres años, realizada por Microsoft, de 3 millones de dólares para ayudar a los estudiantes a convertir en realidad sus ideas.

Estos son los ganadores en las principales Competencias de Imagine Cup:

1. Diseño de Software. Software innovador que de rienda suelta al poder de la tecnología para beneficiar a sus comunidades o al planeta entero.

• Primer lugar: quadSquad (Ucrania)

• Segundo Lugar: Coccolo (Japón)

• Tercer Lugar: wi-GO (Portugal)

2. Diseño de Juego. Juegos que no sólo sean para divertirse, que también ayuden a mejorar el mundo al mismo tiempo

Xbox/Windows

• Primer Lugar: TANG Thai (Tailandia)

• Segundo Lugar: The Doers (Brasil)

• Tercer Lugar: Hotfix (Bélgica)

Teléfono

• Primer Lugar: Drexel Dragons (Estados Unidos)

• Segundo Lugar: Ecosia (Francia)

• Tercer Lugar: Turtle Games (Hungría)

Ganadores de los Retos Imagine Cup

1. Reto TI. Los conocimientos de sistemas de TI de los estudiantes son puestos a prueba en escenarios únicos que deben resolver.

• Primer Lugar: Alexandru Ticlea (Rumania)

• Segundo Lugar: Sherif Talaat (Egipto)

• Tercer Lugar: Joshua Sim (Singapur)

2. Reto Kinect Fun Labs patrocinado por Microsoft Studios. Entretenimiento con una conciencia social.

• Primer Lugar: Equipo Interlab (Brasil)

• Segundo Lugar: Equipo Whiteboard Pirates (Estados Unidos)

• Tercer Lugar: Equipo Flexifly (Polonia)

3. Reto Windows Azure. Los estudiantes aprovechan las características de la plataforma Windows Azure para construir aplicaciones web que ayuden a resolver los problemas más graves del mundo.

• Primer Lugar: Virtual Dreams Azure (Brasil)

• Segundo Lugar: Complex (Rumania)

• Tercer Lugar: The Klein Team (Argelia)

4. Reto Aplicación Windows Estilo Metro patrocinado por Microsoft Windows.

• Primer Lugar: Virtual Dreams Metro (Brasil)

• Segundo Lugar: nLife (Ucrania)

• Tercer Lugar: TokTok (Corea)

5. Reto Windows Phone patrocinado por Nokia.

• Primer Lugar: Vivid (Egipto)

• Segundo Lugar: The Stack (Polonia)

• Tercer Lugar: Aaltovation (Finlandia)

El Premio de la Gente (People’s Choice Award), patrocinado por Bing, es el único reconocimiento de Imagine Cup que es determinado por el público, e incluye un premio de 10 mil dólares. El equipo D Labs creó un software que ayuda a los niños con dislexia a utilizar los juegos para aprender de manera más efectiva a través de Kinect para Xbox 360.

Microsoft y Coca-Cola se enorgullecen de presentar a los ganadores del Premio Conciencia en Salud y del Premio Sustentabilidad del Medio Ambiente con dos proyectos que atacan a los problemas más graves de salud y el medio ambiente.

• Ganadores del Premio Conciencia en Salud:

Primer Lugar: Italian Ingenium Team (Italia)

• Ganadores Sustentabilidad del Medio Ambiente:

Primer Lugar: Greenway (Alemania)

Fuente: Blog Microsoft Latam

Hace unas semanas Facebook agrego a su conocido chat una nueva funcionalidad. “visto a las hh:mm” (seen at hh:mm). Esto puede sonar a mejora, pero en realidad es una violación a la privacidad, ya que se vuelve muy invasivo, porque podes querer responder en otro momento al mensaje, o directamente no responderlo.

Para poder anular esta opción todavía no existe una configuración oficial, pero existe una extensión de Google Chrome que resuelve nuestro problema.

Básicamente debemos ingresar el la siguiente URL:

https://chrome.google.com/webstore/detail/gfjpoahaombpolfifdahikhbdnjjeifk

Instalar la extensión, y en su icono, veremos en tiempo real como bloquea el mensaje de visto.

Windows 8 es la nueva versión del sistema operativo de Microsoft. Una característica que trae Windows 8 es la posibilidad de ser instalado en una memoria USB, o disco duro externo, y bootear directamente desde ahí, tanto para dispositivos USB 2.0 y 3.0.

Para evitar la perdida de datos, si la memoria es extraída, el sistema operativo se congela y, cuando se vuelve a conectar la memoria, el sistema continua funcionando inmediatamente. También es posible cifrar los datos con BitLocker.

Para poder tener nuestro Windows To Go, tenemos que seguir el siguiente tutorial:

Necesitaremos:

• Una PC con Windows 7 u 8
• La imagen ISO del Release Preview de Windows 8
• Windows Automated Installation Kit (AIK)
• Una memoria USB, disco externo, de por lo menos 16GB

Primero, insertamos la memoria USB. Debemos crear una partición primaria en nuestra memoria. Abrimos una consola de comandos con privilegios de administrador (botón derecho sobre la consola, “abrir como administrador”), ejecutamos los siguientes comandos:

• Ejecutar diskpart
• En DISKPART>, escribir LIST DISK para ver un listado numerado de los dispositivos USB y discos.
• Seleccionamos nuestra memoria USB escribiendo SELECT DISK y el número de disco (por ejemplo, si la memoria USB se muestra como el disco 2, escribimos SELECT DISK 2)
• Limpiamos todas las particiones existentes en la memoria, ejecutando el comando CLEAN
• Creamos una nueva partición: CREATE PARTITION PRIMARY
• Formateamos la nueva partición con el sistema de archivos NTFS: FORMAT FS=NTFS QUICK
• Activamos la partición con el comando: ACTIVE
• Salimos de diskpart, escribiendo EXIT

Ahora necesitamos extraer del archivo ISO de instalación de Windows 8 el archivo “install.wim” que esta dentro de la carpeta “sources”, y ponerlo en una carpeta nueva que llamaremos “wintogo” en el disco C (C:/WinToGo).

Si ya estas usando Windows 8, podes montar la ISO directamente, si usas Windows 7, podes abrir el ISO y extraer el archivo usando WinRAR.

Ahora debemos instalar Windows Automated Installation Kit, y .NET Framework 3.5.

Una vez completada la instalación, debemos ubicar el archivo “ImageX.exe” y copiarlo en nuestra carpeta “WinToGo”, que según la versión de Windows 8 que vayamos a instalar, se encuentra en diferente ubicación.

• C:\Program Files\Windows AIK\Tools\x86\
• C:\Program Files\Windows AIK\Tools\amd64\

Ahora tenemos los dos archivos que necesitamos para instalar Windows 8 en nuestra memoria USB. Solamente debemos ejecutar los siguientes comandos, y tendremos lista nuestra nueva instalación:

• ImageX.exe /apply install.wim 1 d: (o sustituir d: por la letra de nuestra unidad USB)
• BCDboot.exe d:\windows /s d: (o sustituir d: por la letra de nuestra unidad USB)

Durante el primer arranque del sistema operativo, se va a detectar el hardware de nuestro equipo y se va a reiniciar el equipo, luego nos va a pedir la clave de producto y finalizaremos la instalación normalmente, como si instaláramos Windows en un disco convencional.

Probé la instalación en una memoria Kingston USB 3.0, en dos maquinas diferentes, una con puerto USB 3.0 y otra con USB 2.0, y en los dos casos funciono de manera optima.

Esta es una buena solución para las empresas, ya que cada empleado podría llevar consigo su instalación completa, archivos personales, configuraciones, y ejecutarla en cualquier estación de trabajo.

La presidenta Cristina Fernández de Kirchner recibió al director general de Operaciones (COO) de Microsoft, Brian Kevin Turner, quien le presentó el Plan Nacional de Desarrollo Sustentable de esa compañía para Argentina, que incluye programas de capacitación.

Durante la audiencia, desarrollada en la Residencia de Olivos, donde la Presidenta cumplió hoy su actividad oficial, participaron los ministros de Industria, Débora Giorgi; de Planificación, Julio De Vido, y de Ciencia y Tecnología, Lino Barañao.

Por su parte Turner estuvo acompañado por el presidente de Microsoft para América Latina, Hernán Rincón; la directora general para Argentina y Uruguay, Sandra Yachelini; el director legal y corporativo de Argentina y Uruguay, Jorge De Lucio; la directora de Asuntos Públicos, Laura Yuma, y el asesor externo de Microsoft, Esteban Bicarelli.

Según se informó oficialmente al término del encuentro, Turner afirmó que América Latina “es la región de mayor crecimiento para la empresa”, y adelantó que este año la firma apostará fuertemente al desarrollo de aplicaciones para sus plataformas de software Windows 8 y Windows Phone en telefonía móvil”.

El ejecutivo, según se destaca en la página de Presidencia de la Nación, explicó durante el encuentro que la empresa organiza diversos programas destinados a incentivar el estudio de carreras técnicas en un sector de alto nivel de empleo, y a apoyar a la industria local y a los emprendedores.

En ese marco el CEO de Microsoft presentó el Plan Nacional de Desarrollo Sustentable de Microsoft para Argentina, que incluye programas para capacitación docente e inclusión de la tecnología en el aula -junto al Ministerio de Educación -, donaciones de Software para ONGs, y becas, junto al Ministerio de Trabajo.

El directivo de la empresa americana indicó que más de 1.000 emprendedores se benefician del programa BizSpark de Microsoft, diseñado para acelerar el éxito de las startups de software,  y que 9.000 estudiantes han sido entrenados para participar en la competencia Imagine Cup, con el fin de crear aplicaciones innovadoras para el nuevo sistema operativo versión 8 y para celulares Windows Phone.

Por otra parte, antes de realizarse la reunión formal con los directivos de  Microsoft, la Jefa de Estado conversó y se fotografió en su despacho con el grupo de estudiantes que ganó la final local con el proyecto “Boddy Music, Inclusión social de personas con Discapacidad”, de la competencia mundial Imagine Cup organizada por la empresa.

Los jóvenes, que intercambiaron saludos con Cristina, representarán a la Argentina en Australia durante la final del mes de julio de este año.

Imagine Cup es la competencia mundial organizada por Microsoft en la que los estudiantes desarrollan una idea tecnológica innovadora que ayude a resolver una problemática social, alineadas con los Objetivos del Milenio de Naciones Unidas.

Microsoft, está trabajando en las áreas de educación, trabajo e innovación, mientras que uno de los programas, llevado adelante junto al Ministerio de Educación, se llama Alianza por la Educación y se ocupa de capacitación docente e inclusión de la tecnología en el aula.

Además, la empresa tiene un programa de donaciones de Software para ONGs y un Programa de Empleabilidad Becas Control A y Becas Control F, con el cual,  junto al Ministerio de Trabajo, capacitan y fortalecen el tercer sector.

fuente: telam

Te invitamos al evento gratuito más grande de la historia para estudiantes desarrolladores en donde se te pondrá a prueba. Tenés que ser rápido, creativo y efectivo. ¡Deberías programar la mejor aplicación para Windows Phone, con Mango features!

Te esperamos el martes 15 de mayo
Hora: 15 hrs-00 hrs (8 horas de programación!)

Donde: las oficinas de Microsoft, Bouchard 710- 4°

REGISTRATE YA!

¡No te pierdas de esta oportunidad para crear la mejor aplicación para Windows Phone!

Microsoft  lanzo recientemente una aplicación cliente de SkyDrive para nuestra PC, y ya esta disponible para descargar que nos permite utilizar nuestro disco en la nube de manera sencilla como utilizamos nuestro explorador de Windows. Esta aplicación es compatible con los siguientes sistemas operativos:

• Windows Vista (SP2)
• Windows 7
• Windows 8
• Windows Server 2008 (SP2)
• Windows Server 2008 R2

Existen también clientes de SkyDrive para las siguientes plataformas:

• Windows Phone
• Mac OS X Lion
• iOS

Una vez instalado el cliente, tendremos acceso para navegar, subir, bajar, y modificar archivos que se encuentren almacenados en nuestra cuenta de SkyDrive. Microsoft nos ofrece de manera gratuita 7 GB, pero si necesitamos mas espacio, podemos comprar un plan se almacenamiento desde 10 dólares por a;o.

Cuando instalamos el cliente, nos pedirá que iniciemos sesión con nuestro Windows Live ID, y que seleccionemos donde ubicar localmente los archivos de nuestra cuenta de SkyDrive.

La aplicación se inicia con Windows y queda ejecutándose en segundo plano. Desde el icono en el área de notificaciones, podemos hacer botón derecho, y cambiar opciones relacionadas a la ejecución y a nuestra cuenta de SkyDrive.

Descargar SkyDrive para Windows

NHibernate es un framework basado en ORM (object / relational mapper) open source basado en el proyecto Hibernate de Java para .NET.
Los ORM’s como LINQ to SQL, Entity Framework, y NHibernate, traducen el modelo relacional, de tablas, columnas e índices, a un modelo de objetos basado en clases y propiedades.

La pagina principal del proyecto es http://www.NHForge.org , esta contiene blog posts, una wiki, la documentación completa, y un bug tracker. El soporte al proyecto se ofrece gracias a la ayuda de usuarios activos que colaboran con el proyecto en un grupo en Google Groups (http://groups.google.com/group/nhusers) . El código fuente del proyecto esta alojado en SourceForge (http://sourceforge.net/projects/nhibernate/). No solo podes bajar el código fuente, sino también, en SourceForge podes descargar binarios pre compilados de versiones estables.

Este es el primer post introductorio al proyecto. Tengo la suerte de trabajar en relación de dependencia en Autocosmos (autocosmos.com) con Fabio Maulo, quien, desde 2008 hasta hace unos meses, lidero el proyecto de forma activa, y de quien estoy aprendiendo detalles del framework que voy a compartir en distintos posts.

Skype es la aplicación de videoconferencia y colaboración en línea mas completa y utilizada en el mercado. Por día se loguean mas de 65 millones de usuarios que hablan 700.000.000 minutos de manera gratuita.

El día 27 de febrero se lanzo la primer beta de Skype para la plataforma Windows Phone 7, con el cual se puede aprovechar nuestra conexión WIFI para hacer llamadas de voz y video de manera gratuita a cualquier parte del mundo.

Les dejo el link al marketplace para descargarlo directo a tu teléfono móvil.

http://www.windowsphone.com/en-US/apps/c3f8e570-68b3-4d6a-bdbb-c0a3f4360a51

Al crear un hosted service, Windows Azure nos asigna un subdominio del tipo “mihostedservice.cloudapp.net”. Al proveernos un nombre y un dominio se logra tener una capa de abstracción que permite a Azure modificar las IPs virtuales (VIPs) de nuestro servicio sin tener que interrumpirlo.

Es por el cambio de IPs de manera dinámica que no podemos apuntar nuestro dominio (miempresa.com) a una IP en Windows Azure, sino que debemos apuntarlo al subdominio que nos asigna, “mihostedservice.cloudapp.net”.

Las empresas que se ocupan del registro de dominios tienen interfaces de administración de los mismos, y cada una, aunque sea diferente, van a solicitarnos información básica para asignar el dominio a un nombre de DNS.

• Host o nombre de dominio completo: es el dominio con el prefijo que se utiliza para acceder al servicio. No se puede asignar al servicio un dominio raíz (miempresa.com), debemos asignar un subdominio, como www, blog, noticias, etc..
• Tipo de registro: CNAME.
• Valor de registro: debemos especificar el nombre del servicio, “mihostedservice.cloudapp.net”.

Es posible que nos pidan un valor para el TTL (Time to live), podemos dejar el valor pre-determinado.

Para configurar nuestro hosted service para responder a nuestro dominio, debemos seguir los siguientes pasos:

1. Abrir el ServiceDefinition.csdef con un editor de texto.
2. Agregamos al elemento Endpoints un InputEnpoint. El siguiente ejemplo nos muestra como agregar un endpoint con HTTP que escuche el puerto 80, y se comunique con nuestro rol por el mismo puerto 80:

   <ServiceDefinition name="MyService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
     <WebRole name="WebRole1">
       <Endpoints>
         <InputEndpoint name="HttpIn" protocol="http" port="80" localPort="80" />
       </Endpoints>
     </WebRole>
   </ServiceDefinition>

   localPort es un atributo opcional. Si no lo asignamos, se asigna automáticamente en tiempo de ejecución de la aplicación.

3. Elegimos un nombre a nuestro endpoint.
4. Seteo el protocolo a usar. Entre HTTP o HTTPS.
5. Especifico el numero de puerto que deseamos usar para la comunicación con nuestro role.
6. Guardo el archivo.

En el momento de mejorar performance de nuestra aplicación, un aspecto muy importante (si no es el más), son las queries a la base de datos. Si conocemos, o creemos que conocemos, el funcionamiento de nuestra aplicación, podemos mejorar las queries mas pesadas. Pero, tenemos otra opción. Que SQL Server nos diga cuales son las mas costosas.

El siguiente script nos muestra, en orden (de la mas pesada a la menos), las queries ejecutadas en nuestro servidor de base de datos, que le consumieron mas tiempo/recursos ejecutar.

-- Find top 5 queries
SELECT TOP 5 query_stats.query_hash AS "Query Hash",
    SUM(query_stats.total_worker_time) / SUM(query_stats.execution_count) AS "Avg CPU Time",
    MIN(query_stats.statement_text) AS "Statement Text"
FROM
    (SELECT QS.*,
    SUBSTRING(ST.text, (QS.statement_start_offset/2) + 1,
    ((CASE statement_end_offset
        WHEN -1 THEN DATALENGTH(st.text)
        ELSE QS.statement_end_offset END
            - QS.statement_start_offset)/2) + 1) AS statement_text
     FROM sys.dm_exec_query_stats AS QS
     CROSS APPLY sys.dm_exec_sql_text(QS.sql_handle) as ST) as query_stats
GROUP BY query_stats.query_hash
ORDER BY 2 DESC;
GO

En el siguiente post, vamos a aprender a agregar puntos al mapa de Google convirtiendo de una dirección a un punto (latitud, longitud). Esta técnica se llama Geocodificación.

Se me presento la oportunidad de hacer un trabajo para una agencia de publicidad que necesitaba mostrarle a su cliente (Frávega) la ubicación geográfica de todos los elementos de una campaña (locales, carteles en vía publica, etc..). Es por eso que investigando un poco en internet encontré que esto se podía hacer de la siguiente manera:

Nota: Antes de leer lo que sigue, recomiendo repasar como utilizar la API de Google Maps

Primero, para este ejemplo, armé un array con las direcciones de catorce sucursales

var direcciones=new Array();
direcciones[0]=”Av. Santa Fe 3181″;
direcciones[1]=”Av. Corrientes 3247″;
direcciones[2]=”Av. Corrientes 3889″;
direcciones[3]=”Av. Santa Fe 3253″;
direcciones[4]=”Av. Cabildo 2202″;
direcciones[5]=”Av. Rivadavia 5216″;
direcciones[6]=”Brasil 1253″;
direcciones[7]=”Av. Melian 4630″;
direcciones[8]=”Av. Rivadavia 6502″;
direcciones[9]=”Av. Rivadavia 11626″;
direcciones[10]=”Florida 296″;
direcciones[11]=”Av. Corrientes 756″;
direcciones[12]=”Valentin Gomez 2813″;
direcciones[13]=”Av. Santa Fe 2401″;

Creo una variable global y en la inicialización del mapa la instancio.

    geocoder = new google.maps.Geocoder();

Luego, recorro el listado de direcciones, y las geocodifico para obtener un punto.

     for (var i = 0; i < direcciones.length; i++) {
setDireccion(i);
}

function setDireccion(INDEX) {
var request = new Object(); //CREO UN OBJETO
request.address = direcciones[INDEX] + “, Ciudad de Buenos Aires”; //sé que son direcciones en capital
geocoder.geocode(request, addAddressToMap); //geocode hace la conversión a un punto, y su segundo parámetro es una función de callback
}

La función de callback:

 

function addAddressToMap(response, status) {
if(!response) return;    //si no pudo

//icono que voy a usar para mostrar el punto en el mapa
var icon = new google.maps.MarkerImage(
“http://gmaps-samples.googlecode.com/svn/trunk/markers/blue/blank.png”,
new google.maps.Size(20, 34),
new google.maps.Point(0, 0),
new google.maps.Point(10, 34)
);
//creo el marcador con la posición, el mapa, y el icono
marker = new google.maps.Marker({
‘position’: response[0].geometry.location,
‘map’: map,
‘icon’: icon
});
marker.setMap(map); //inserto el marcador en el mapa
}

De esta sencilla forma podemos agregar puntos al mapa obteniendo la latitud y longitud desde una dirección física. En el ejemplo recorro un array de strings con las direcciones, pero tranquilamente se podrían obtener las direcciones de un servicio, xml, etc.. es a gusto del consumidor.

Google Maps una utilidad de Google que muestra mapas de todo el planeta. Puede alternar tres clases de vista de los mapas. Satélite: Es una vista de pájaro, con fotografí­as a gran altura reales. Mapa: Un callejero/mapa de calles y avenidas o Hí­bridaque mezcla ambas opciones.

Además de poder acceder a la aplicación desde http://maps.google.com , podemos agregar la potencia de la cartografía e información del mapa en nuestro sitio web, utilizando una API publica de uso gratuito.

Para insertar y manipular el mapa desde nuestro sitio web debemos hacer lo siguiente:

Agregar una referencia al archivo JS con las funciones de la API

<script type=”text/javascript” src=”http://maps.googleapis.com/maps/api/js?sensor=true&language=es“></script>

Insertar un elemento en nuestro sitio, en el que se renderizará el mapa

<div id=”map_canvas”></div>

Inicializar el mapa con la siguiente función javascript:

var map;

function initialize() {

var myOptions = {
zoom: 6,
mapTypeId: google.maps.MapTypeId.ROADMAP
};

map = new google.maps.Map(document.getElementById(‘map_canvas’),myOptions);

}

Agregar un evento que ejecute la función anterior

     google.maps.event.addDomListener(window, ‘load’, initialize);

A esta altura, tendremos nuestro mapa, pero sin ninguna funcionalidad adicional.

Con la potencia de la API de geolocalización de HTML5, podemos obtener nuestra posición actual, y ubicarla en el mapa, de la siguiente forma:

Sumamos a nuestra funcion de inicializacion el siguiente codigo

 

if(navigator.geolocation) {
navigator.geolocation.getCurrentPosition(function(position) {
var pos = new google.maps.LatLng(position.coords.latitude,position.coords.longitude);
var infowindow = new google.maps.InfoWindow({map: map, position: pos, content: Tu ubicacion actual usando HTML5.’ });
map.setCenter(pos);
}, function() {
handleError(true);
});
} else {
// Si el navegador no soporta geolocalización
handleError(false);
}

y agregamos la funcion “handleError”

    function handleError(errorFlag) {

if (errorFlag) {
var content = ‘Error en el servicio de geolocalizacion.’;
} else {
var content = ‘Error: Tu navegador no soporta geolocalización.’;
}

var options = { map: map, position: new google.maps.LatLng(60, 105), content: content };
var infowindow = new google.maps.InfoWindow(options);
map.setCenter(options.position);

}

Este es un ejemplo, hay muchos mas, y mas información ingresando en la página oficial de la API de Google Maps, http://code.google.com/intl/es-419/apis/maps/index.html

Web Scraping es un proceso de recopilación de información de forma automática a partir de la Web. En este post vamos a ver como obtener información desde otro sitio automáticamente.

Como ejemplo vamos a tomar la siguiente página:

• http://webcams.iberocruceros.com/FleetMonitor/WebCam.aspx?ShipCode=MI

La página pertenece a la empresa Ibero Cruceros, y muestra, información sobre el estado y ubicación de uno de sus barcos (Grand Mistral).

Lo que vamos a hacer es tomar las coordenadas del barco para mostrarlas en un mapa usando la API de Google Maps, y además agregar en el mapa otras informaciones que se pueden obtener de la misma pagina (velocidad del barco, rumbo, dirección del viento, temperatura, humedad, presión, y velocidad del viento).

Ejemplo del DOM (el pedazo DOM que nos interesa para lo que vamos a hacer).

<ul class=”shipInfo”>

<li class=”speed”><span class=”left”>Velocidad:</span><span class=”right”>18.4 Knots</span></li>

<li class=”heading”><span class=”left”>Rumbo:</span><span class=”right”>51.0°</span></li>

<li class=”latitude”><span class=”left”>Latitud:</span><span class=”right”>34°7’35” S</span></li>

<li class=”longitude”><span class=”left”>Longitud:</span><span class=”right”>52°55’57” W</span></li>

<li class=”winddirection”><span class=”left”>Direcciòn del vento:</span><span class=”right”>321.6°</span></li>

<li class=”temperature”><span class=”left”>Temperatura:</span><span class=”right”>21.0°C</span></li>

<li class=”humidity”><span class=”left”>Humedad:</span><span class=”right”>66.1%</span></li>

<li class=”pressure”><span class=”left”>Presiòn:</span><span class=”right”>1012.4 hPa</span></li>

<li class=”windspeed”><span class=”left”>Velocidad del viento:</span><span class=”right”>16.7 Km/h</span></li>

</ul>

Para hacer scraping en C#, creamos un nuevo proyecto web, y agregamos referencias a ScrapySharp, y a HtmlAgilityPack (podemos agregarlas directamente desde NuGet).

Armé una clase “Scraper” que devuelve el DOM de un sitio que nosotros le solicitamos (Uri), para luego, usando selectores del tipo CSS, obtener el/los elemento/s del DOM que estemos buscando.

Ejemplo de uso:

HtmlNode html = new Scraper().GetNodes(new Uri(“http://webcams.iberocruceros.com/FleetMonitor/WebCam.aspx?ShipCode=MI”));

var lat = html.CssSelect(“li.latitude span.right”).FirstOrDefault().InnerText;
var lon = html.CssSelect(“li.longitude span.right”).FirstOrDefault().InnerText;

En el ejemplo se puede ver como obtener la latitud y longitud de la ubicación del barco. De la misma forma podríamos obtener mas información.

Dejo la implementación del método GetNodes de la clase Scraper:

       public HtmlNode GetNodes(Uri url)
{
// Create the WebRequest for the URL we are using
var req = WebRequest.Create(url);

// Get the stream from the returned web response
var stream = new StreamReader(req.GetResponse().GetResponseStream());

var htmlDocument = new HtmlDocument();
htmlDocument.Load(stream);
return htmlDocument.DocumentNode;
}

Muchas veces tenemos que luchar con librerías externas, o ajenas a nuestro alcance de edición, y no nos queda otra alternativa mas que adaptarnos a lo que se nos plantea.

Este post surge por la necesidad de implementar el código de trackeo de comScore (una empresa que trackea como analytics, pero certifica a quien quiere poner publicidad en tu sitio, que la métrica no fue alterada).

Particularmente, necesitábamos poder trackear, y pasarle a la librería de comScore dos parámetros, uno que depende del dominio y otro que se carga desde un “ABM” dependiendo de otras variables.

Este es el ejemplo de como tiene que quedar el markup:

<html>
<head>

<script type=”text/javascript” src=”nuestraLibreria.js”></script>
<script type=”text/javascript”>
comScoreLib.init([“PARAM1″]);
</script>
</head>

<body>

<script>
comScoreLib.comScoreMetrics(‘PARAM2’);
</script>

<script type=”text/javascript” src=”libreriaDeComScore.js”></script>

</body>

</html>

Como se puede ver, mejor en el ejemplo, “libreriaDeComScore.js” es la librería externa que no podemos modificar.

“comScoreLib.init([“PARAM1”]);” –> inicializa el primer parámetro que depende del dominio.

“comScoreLib.comScoreMetrics(‘PARAM2’);” –> la llamada al código de trackeo de comScore con el segundo parámetro que se carga desde un ABM.

Para que todo esto funcione, armamos una librería propia, que ejecuta la de comScore (nuestraLibreria.js).
nuestraLibreria.js:

 

var comScoreLib = comScoreLib || (function(){
var _args = {}; // private

return {
init : function(Args) { //inicializamos el primer parámetro
_args = Args;
},
comScoreMetrics : function(section) { //pasamos el segundo parámetro y ejecutamos el código de trackeo (librería externa)
}
};
}());

Como resultado, tenemos implementada nuestra librería personalizada que se adapta a la externa según nuestras necesidades.

Muchas veces, en sitios grandes, con el fin de trackear subsecciones, minisitios, promociones, etc.. , generamos una enorme cantidad de trackers en nuestra cuenta de Google Analytics. Esto hace casi imposible la administración. Si quisiéramos conocer la totalidad de trafico de todo el sitio (incluyendo minisitios, subsecciones), tendríamos que agarrar una calculadora… Y ese no es el objetivo de Analytics.

Supongamos que tenemos un sitio con tres grandes secciones, compra/venta de autos, compra/venta de motos, y compra/venta de camiones, nos encontramos con que en cada sección ya se encuentra instalado un tracker distinto. Y ahora el requerimiento es el de unificar la información de trafico en un único lugar, y manteniendo la información anterior..

Hablando con un representante de Google Argentina, nos propuso la creación de un cuarto tracker, para eliminar los 3 anteriores, y que toda la información se empiece a generar en este nuevo tracker.

Pero.. No se adapta al requerimiento de “manteniendo la información anterior”. Porque insertaríamos un tracker solo, las cuentas anteriores quedarían en cero. Y no es lo que estamos buscando.

Para resolver este problema, recurrimos al trackeo de múltiples trackers en simultaneo, y obviamente, de forma asincrónica.

Ejemplo de código de seguimiento:

<script type="text/javascript">

var _gaq = _gaq || [];_gaq.push(['_setAccount', 'UA-XXXXXX-1']);_gaq.push(['_trackPageview']);

(function() {var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);})();

</script>

Nuestro nuevo tracker que se inserta en nuestras 3 secciones: UA-XXXXXX-2.

La forma de trackear las 2 cuentas en simultaneo es la siguiente:

_gaq.push(  ['_setAccount', 'UA-XXXXX-1'],  ['_trackPageview'],  ['2._setAccount', 'UA-XXXXX-2'],  ['2._trackPageview']

);

Si necesitamos n trackers:

_gaq.push(  ['_setAccount', 'UA-XXXXX-1'],  ['_trackPageview'],  ['2._setAccount', 'UA-XXXXX-2'],  ['2._trackPageview'],  ['n._setAccount', 'UA-XXXXX-n'],  ['n._trackPageview']);

La mejor forma que encontré de probar si nuestros cambios funcionan, y realmente trackea en las 2 cuentas, es entrando a Google Analytics Real Time desde las 2 cuentas, para notar, que tienen la misma información.

Arranco la final de Gaming.NET 2011 categorías Hoshimi e Imagine Cup. Estamos en la Universidad de La Punta en San Luis.

Google Analytics es una herramienta de alto potencial para los administradores de páginas web. Sin embargo, por la gran cantidad de información que brinda, su manejo puede llegar a ser muy complejo, haciendo difícil la toma de decisiones.

Esta vez les quiero compartir la nueva funcionalidad de “flujo de visitantes”. Esta nos permite ver, mediante un grafico, de donde vienen, como navegan, y cuando se van nuestros visitantes, para hacer un seguimiento mas de cerca del comportamiento de los usuarios en nuestro sitio web.

En “Flujo de Visitantes” se puede ver un gráfico que representa el flujo de visitantes a través de nuestro sitio comenzando por la fuente de tráfico (o cualquier otra dimensión) para ver su camino, desde donde ingreso, hasta donde finalizó la visita.

Los nodos del grafico son agrupados de forma automática de acuerdo a un algoritmo de inteligencia, y la visualización es altamente interactiva.

En octubre de 2011 Google en su evento Google Analytics Partners Summit en Mountain View, lanzó Google Analytics Real-Time! Como bien lo indica su nombre, es un servicio que nos permite ver la interacción de los usuarios de nuestro sitio web de manera instantánea y en tiempo real.

Para acceder a esta nueva funcionalidad, debemos ingresar en “Pagina principal”, y en el menú izquierdo seleccionar “Tiempo real (beta)”.

La imagen muestra el grafico de la evolución del trafico (paginas vistas) en nuestro sitio web en los últimos 30 minutos (a la izquierda), y por segundo del ultimo minuto (a la derecha).

Las métricas mas destacadas son las siguientes:

• Visitantes activos en el sitio
• Referencias principales (de donde vienen)
• Principales páginas activas (paginas que están siendo visitadas en ese instante)
• Palabras clave principales (utilizadas en las búsquedas para acceder a nuestro sitio)
• Ubicaciones principales (mapa que ubica a nuestros visitantes)

Esta nueva herramienta que nos ofrece Google es sin duda una muestra mas de la potencia que tiene Analytics. Recomiendo usarla de manera controlada, porque puede generar adicción.. enserio.

Hace 2 viernes nos juntamos en las oficinas de Microsoft Argentina con @guadacasuso, @fabiomaulo, @nahog, @gabrielsz, Fernando Aramburu, @aeidelman entre otros y nació un nuevo grupo de Windows Azure de habla hispana para que sea mas fácil para todos compartir experiencias, conocimiento y/o aclarar dudas.
Si estás por empezar alguna aplicación en Azure, ya tienes una o simplemente querés aprender y compartir podes subscribirte a:

http://tech.groups.yahoo.com/group/azurehispano/

Por mucho tiempo la forma de manejar el historial y ofrecer la posibilidad de agregar a favoritos aplicaciones AJAX fue utilizando location.hash. Ahora con HTML5 podemos reemplazar location.hash por una mejor solucion: pushState

Pushstate es la forma de cambiar la URL por javascript sin recargar la página. Se utiliza de la siguiente forma:

window.history.pushState(data, "Titulo", "/nuevo-recurso");

• Primer argumento (Object o String): Datos almacenados que pueden ser utilizados en el evento window.onpopstate; activado cuando se usa un pushState() oreplaceState().
• Segundo argumento (String): Modifica el titulo del nuevo estado. El título (ó <title>) del documento no cambia. Es una descripción para el manejo de historial.
• Tercer argumento (String): Ruta al nuevo recurso, por razones de seguridad no se modifica el dominio.

Para dar  soporte a los botones de “atrás” y “adelante” y evitar la recarga de la página se puede utilizar el evento windows.onpopstate

Les dejo un ejemplo de funcionamiento.

<!DOCTYPE HTML>
<title>Página 5</title>
<p>Estas en la página<span id="coord">5</span>.</p>
<p>
 <a href="?x=6" onclick="go(1); return false;">Ir a página 6</a> o
 <a href="?x=4" onclick="go(-1); return false;">Volver a página 4</a>?
</p>
<script>
 var currentPage = 5; // Arrancamos desde la pagina 5

 function go(d) {
   setupPage(currentPage + d);
   history.pushState(currentPage, document.title, '?x=' + currentPage);
 }
 onpopstate = function(event) {
   setupPage(event.state);
 }
 function setupPage(page) {
   currentPage = page;
   document.title = 'Página ' + currentPage;
   document.getElementById('coord').textContent = currentPage;
   document.links[0].href = '?x=' + (currentPage+1);
   document.links[0].textContent = 'Ir a página ' + (currentPage+1);
   document.links[1].href = '?x=' + (currentPage-1);
   document.links[1].textContent = 'Volver a página ' + (currentPage-1);
 }
</script>

Documentación de la W3G: http://www.w3.org/TR/html5/history.html

Les dejo los videos de la presentación que dimos en Codecamp 2010, HTML5 + CSS3, y para descargar la presentación completa + demos.

DESCARGAR PRESENTACION

Arrancamos tempranito ayudando a dar el ultimo ajuste para que el evento salga de la mejor manera, y creo que, por comentarios que nos llegaron de la gente que asistio, fue todo un exito!

Comenzó oficialmente cuando Migue Saez, Martin Salias, Marcelo De Vincenzi, y  Jonas Stawski presentaron el evento, y explicaron a todos los participantes de la dinámica del mismo.

Luego arrancaron los 4 bloques de 13 charlas en simultaneo. Si, 13 charlas en simultaneo, SUPER DIFICIL ELEGIR UNA ENTRE TANTAS INTERESANTES, y eso que se eligieron 52 de mas de 100 propuestas!.

No me quiero extender mucho, el que no fue, no se pierda el del año que viene, que, como viene pasando, cada año es mejor!

Les dejo la presentación y los archivos de las demos.

DESCARGAR

Mas de 60 millones de sitios en internet utilizan la plataforma WordPress. La creciente tendencia en el uso de servicios en la nube me llevo a la idea de subir un WordPress a Windows Azure. En este post voy a explicar paso a paso como llevar esto a cabo, desde la descarga de los fuentes, creación de base de datos en SQL Azure, Storage para guardar nuestras imágenes, y, por supuesto, subir nuestro sitio a una (o varias) instancias de Windows Azure, para lograr tener nuestro WordPress 100% en la nube.

Este post es la segunda y ultima parte. Es recomendable leer la primer parte, para no perderse ningún detalle, y llegar a buen puerto.

Personalizar WordPress

WordPress utiliza el file-system para persistir los archivos de instalación de plugins y themes. Esto en Windows Azure no va a ser posible, ya que, podemos escribir en el file-system, pero, los cambios no van a durar y serán eliminados cuando una instancia se reinicie. Además, el file-system no se comparte entre instancias, por lo que, si hay muchas instancias corriendo nuestro WordPress en simultaneo, una instancia no va a conocer los cambios de la/s otra/s. Para solucionar esto, y poder instalar themes y plugins, debemos hacerlo, generar un nuevo paquete y subirlo.

Modificar configuraciones del wp-config.php

El scaffolder de WordPress utiliza el Azure configuration file para llenar el wp-config.php. No se recomienda editar el wp-config.php, ya que podemos perder las características de escalabilidad que nos brinda el scaffolder. Para editar alguna de las configuraciones, podemos utilizar el Azure configuration file (ServiceConfiguration.cscfg) antes de subir el empaquetado, o editarlo desde el panel de control de Windows Azure Plattform.

Modificar configuraciones del php.ini

Si necesitáramos editar o agregar variables de configuración personalizadas en el archivo PHP.ini, el scaffolder de WordPress nos da soporte para realizarlo. Simplemente debemos abrir el archivo que se encuentra en la carpeta PHP del directorio del WebRole.

Además, si queremos ejecutar extensiones, simplemente las tenemos que agregar en la carpeta EXT dentro del directorio del WebRole. Todas las extensiones que se encuentren en esta carpeta se instalaran junto con PHP para poder utilizarlas.

Armado del paquete

Una vez que termines de customizar la instalacion de WordPress, debemos armar el empaquetado del proyecto para hacer deploy. El siguiente comando genera el paquete:

package create -in="C:\temp\WordPress" -out="C:\temp" -dev=false

Deploy del paquete

Una vez que tenemos nuestro empaquetado listo, lo que tenemos que hacer es el deploy de los archivos en Windows Azure para correr nuestro WordPress.

Para no extender este post, te recomiendo que leas y sigas los pasos para hacer un deploy del siguiente post:

• Deploy de aplicaciones en Windows Azure

Finalizar la instalacion de WordPress

El ultimo paso luego del deploy, es ingresar desde un navegador a la URL que elegimos en el momento del deploy de WordPress. Cuando entremos, nos aparecerá la siguiente pantalla, para completar los datos de ingreso como administrador de nuestro blog:

Configurar el plugin Windows Azure Storage

Una vez dentro del panel de control de WordPress, debemos ingresar en “Plugins” –> “Installed Plugins”, y hacemos click en “Activate”, para activar el plugin “Windows Azure Storage for WordPress”, que nos permitirá almacenar nuestros archivos multimedia (imágenes, videos, etc.) en nuestro blob storage.

Luego de activado, ingresamos en “Settings” –> “Windows Azure” y especificamos el Storage Account Name, Primary Access Key, y seleccionamos el storage container por default.

Antes de hacer click en guardar cambios, debemos asegurarnos de que el checkbox “Use Windows Azure Storage when uploading via WordPress’ upload tab” este checkeado.

Con estos simples pasos, ya tendremos nuestro WordPress instalado y corriendo en Windows Azure.

Mas de 60 millones de sitios en internet utilizan la plataforma WordPress. La creciente tendencia en el uso de servicios en la nube me llevo a la idea de subir un WordPress a Windows Azure. En este post voy a explicar paso a paso como llevar esto a cabo, desde la descarga de los fuentes, creación de base de datos en SQL Azure, Storage para guardar nuestras imágenes, y, por supuesto, subir nuestro sitio a una (o varias) instancias de Windows Azure, para lograr tener nuestro WordPress 100% en la nube.

Pre-requisitos

• Instalar el ambiente de desarrollo de Windows Azure
• Instalar el SDK de Windows Azure para PHP

Introducción

Utilizaremos la funcionalidad de scaffolding que nos provee el SDK de Windows Azure para PHP para descargar el empaquetado con los fuentes de WordPress y generar un paquete listo para correr en Windows Azure.

En este post, asumimos que ya tenemos instalado el SDK y el ambiente de desarrollo, si no lo hiciste todavía, lee los posts listados en los pre-requisitos.

Instalación del servicio de Windows Azure

Antes de poder instalar y correr WordPress en Windows Azure, debemos instalar los siguientes servicios:

• Hosted Service
• Storage account
• SQL Azure database

Para obtener mas información, lee los siguientes artículos de MSDN (en ingles), o espera a que escriba mas detalles sobre Hosted Services, Storage Accounts y SQL Azure.

• How to Create a Hosted Service
• How to Create a Storage Account
• Getting Started with SQL Azure

Descargar el scaffolder de WordPress

Se armo un scaffolder con una versión de WordPress que fue especialmente diseñada para una fácil configuración y deploy en Windows Azure se puede descargar desde:

http://blog.alebanzas.com.ar/wordpress-scaffolder.zip

El archivo WordPress.pharcontiene el scaffold empaquetado que se necesita para seguir este tutorial.

Una vez descargado el archivo WordPress.phar debemos ubicarlo en la carpeta C:\temp.

Ejecutar el scaffolder de WordPress

Cuando ejecutamos el scaffolder de WordPress, como resultado obtendremos los archivos como un proyecto Azure de Visual Studio, para este ejemplo vamos a usar la siguiente ubicación C:\temp\WordPress.

Parámetros

El scaffolder de WordPress tiene varios parámetros que sus valores se integran al archivo ServiceConfiguration.cscfg.

-DB_NAME – Nombre de la base de datos

-DB_USER – Usuario para accede a nuestra base de datos con formato usuario@db_host

-DB_PASSWORD – Password del usuario para acceder a la base de datos

-DB_HOST – Hostname de la base de datos. Se utiliza la url complete de nuestro servidor SQL Azure

-sync_account – Endpoint del storage de Windows Azure Storage. NOTA: Debemos crear un container publico con el nombre ‘wpsync’

-sync_key – Access key del storage de  Windows Azure Storage

Nota: Si necesitas modificar alguno de los valores de los parámetros enumerados anteriormente, no es necesario ejecutar nuevamente el scaffolder. Podes abrir el archivo ServiceConfiguration.cscfg y editar los valores ingresados.

Parámetros adicionales

Existen mas parámetros de los listados anteriormente, todos estos tienen valores por default que en general no va a ser necesario modificar, pero, si asi lo desearamos, podemos ejecutar el siguiente comando para ver los parámetros disponibles:

scaffolder help -s="C:\temp\WordPress.phar"

Crear el proyecto

Para crear el proyecto, debemos ejecutar el scaffolder ejecutando el siguiente comando:

scaffolder run -s="C:\temp\WordPress.phar" -out="C:\temp\WordPress" -DB_NAME=**** -DB_USER=****@**** -DB_PASSWORD=**** -DB_HOST=tcp:****.database.core.windows.net,1433 -sync_account=**** -sync_key=****

La ejecución puede demorar varios minutos, porque se ejecutan las siguientes tareas:

• La ultima version de WordPress se descarga desde http://wordpress.org y se desempaqueta
• Se descarga el plugin WordPress database abstraction  para SQL Azure y se agrega al proyecto
• Se descarga el plugin Windows Azure Storage plugin for WordPress y se agrega al proyecto
• Se configura WordPress para poder correr en el servicio de Windows Azure
• Se genera el Windows Azure service configuration file

Una vez finalizado todo esto, podemos ingresar a C:\temp\WordPress y veremos la siguiente estructura de carpetas y archivos:

• WebRole/
• ServiceConfiguration.cscfg
• ServiceDefinition.csdef

Los archivos de WordPress se encuentran dentro de la carpeta WebRole.

Instalar el plugin Windows Azure FileSystemDurabilityPlugin

El plugin database abstraction de WordPress nos da la posibilidad de utilizar otros motores de base de datos, como por ejemplo, SQL Azure.

FileSystemDurabilityPlugin  esta hosteado por Github. Solamente necesitamos descargarlo y ubicarlo en la carpeta de instalación del SDK de Windows Azure.

• Descargar FileSystemDurabilityPlugin desde https://github.com/downloads/Interop-Bridges/Windows-Azure-File-System-Durability-Plugin/FileSystemDurabilityPlugin.zip
• Copiar los archivos recién descargados en
  C:\Program Files\Windows Azure SDK\<YOUR VERSION>\bin\plugins

Les dejo el link de acceso para ver el evento EN VIVO durante todo el día

http://www.uai.edu.ar/transmision-en-vivo.asp?title=//codecamp/buenos_aires/2011&str=radio.edu.ar/codecamp

Codecamp es un evento orientado a desarrolladores de software. Estudiantes, profesionales y empresas en el que nos reunimos una vez al año a compartir un espacio de trabajo donde a través de sesiones, charlas y ejercicios cooperativos, ponemos en uso nuevas tecnologías para encontrar soluciones prácticas para usuarios de software

¿Quienes hacemos CodeCamp?

Universidad Abierta Interamericana

Diferentes Universidades participan año a año de la organización de CodeCamp. Estamos muy contentos de volver a visitar la Universidad Abierta Interamericana, repitiendo CodeCamp como lo hicimos en el año 2008. Queremos agradecer al Dr. Marcelo De Vincenzi, y al equipo de la UAI por el compromiso y el trabajo para hacer CodeCamp, abriendo las puertas de la Universidad para invitar a la gente de la comunidad.

Grupo de Usuarios Microsoft

El MUG ha participado de CodeCamp desde el principio. CodeCamp es un evento donde participa toda la comunidad: oradores, empresas, profesionales, estudiantes y Universidades. Esto requiere un gran trabajo de organización, y experiencia en trabajar para la comunidad, lo cual el MUG realiza desde hace más de 15 años. Además de organizar este año CodeCamp, el MUG realiza diferentes tipos de actividades durante todo el año para la comunidad, en todo el país: Conocélos.

Digital Idea Solutions

Si participaste de otros CodeCamp, seguramente conocerás a Jonas Stawski, de Digital Idea Solutions. Jonas es Argentino y vive en Estados Unidos, donde participa del CodeCamp de Florida desde hace varios años, y en el año 2007 trajo la idea a Argentina, participando en la organización de cada CodeCamp desde entonces.

Microsoft Argentina

Desde el grupo de Nuevas Tecnologías, CodeCamp es un evento en el que nos encanta participar. Definitivamente se trata de un encuentro de toda la comunidad, y es un placer ser parte de su organización.

En los próximos días se irá develando la agenda. Recordá que el ingreso es gratuito, y requiere inscripción, la cual ya está abierta! Registrate!

Si el comando “PHP”  no es reconocido desde nuestra consola de comandos, debemos seguir los siguientes pasos para resolverlo..

Botón derecho en Computer, seleccionamos “Propiedades”

En el menú ubicado en la izquierda de la ventana, hacemos click en la opción “Advanced system settings”, y luego, en el botón “Environment Variables”.

La sección que figura en la parte inferior de la ventana de “Environment Variables”, contiene variables de sistema “System variables”, la variable que estamos buscando es “Path”, esta, contiene los path (separados por punto y coma ; ) donde la consola de comandos busca programas a ejecutar. Seleccionamos la variable path, y luego tocamos el botón “Edit..”. Se abrirá una ventana que nos permite editar el valor de esta variable. Sin eliminar lo que yá existe, agregamos el path donde tenemos instalado PHP en nuestro sistema “C:\Program Files\PHP\v5.3”, luego le damos OK a todas las ventanas que abrimos para guardar los cambios.

Reiniciamos nuestra consola de comandos, y deberíamos poder utilizar el comando PHP.

El mismo procedimiento se puede aplicar a los paths que contienen programas ejecutables desde la consola, y no solamente para el comando PHP.

Introducción

En este post aprenderemos como desarrollar una aplicación PHP para Windows Azure. Empezaremos de cero hasta que tengamos nuestra aplicación online. Nuestro objetivo será aprender a tener nuestra aplicación lista para Windows Azure, y no focalizaremos en el como se programa en PHP.

Para empezar, debemos asegurarnos de haber instalado el ambiente de desarrollo de Windows Azure, y el SDK de Windows Azure para PHP. Seguí en detalle cada paso para estar listos, haciendo click en los links en la sección “pre-requisitos”.

Cabe aclarar, que en todo lo que haremos, asumiremos que nuestro proyecto se encuentra en “C:\temp\WindowsAzurePHPApp”

Pre-Requisitos

• Instalar el ambiente de desarrollo de Windows Azure con Microsoft Web Plattform Installer
• Instalar el SDK de Windows Azure para PHP

Crear una aplicación PHP base para Windows Azure

Crear una aplicación en PHP para Windows Azure se puede convertir en un proceso realmente muy complejo, que involucra generar los archivos del paquete de deploy “ServiceConfiguration.cscfg” y “ServiceDefinition.csdef”, codificar scripts para instalar PHP, etc… Todo esto se hace simple con el SDK de Windows Azure para PHP, que nos permite generar la estructura básica para crear una aplicación PHP lista para Windows Azure. Haciéndolo tan simple, que solo es necesario copiar y pegar los archivos del proyecto, para que el SDK se encargue de generar un paquete listo para deployar.

Para crear una aplicación PHP básica para Windows Azure, debemos abrir una consola de comandos, y ejecutar el siguiente comando:

  scaffolder run -out="C:\temp\WindowsAzurePHPApp"

Ahora podemos acceder a la carpeta C:\temp\WindowsAzurePHPApp donde encontraremos la siguiente estructura de carpetas y archivos:

Ahora, podemos empaquetar y deployar esta aplicación, PHP se va a instalar automáticamente en nuestro deployment de Windows Azure.

La estructura de directorios es la siguiente:

• PhpOnAzure.Web – Esta carpeta es el directorio raíz de nuestra aplicación, todos los archivos de nuestra aplicación PHP van allí
  • bin – Contiene los scripts que se ejecutan al iniciar las instancias de Windows Azure para instalar PHP
  • php – Contiene un archivo php.ini personalizable con la posibilidad de agregar extensiones que necesitemos para nuestra aplicación.
  • resources – Contiene archivos para soportar el deploy
  • diagnostics.wadcfg – Archivo de diagnostico de la instalación. Se puede usar para trackear el uso del CPU, ancho de banda, etc..
• ServiceConfiguration.cscfg – Archivo de configuración para el deploy en Windows Azure
• ServiceDefinition.csdef – Contiene información acerca de la instalación de nuestro deployment.

Build de la aplicación PHP

Ahora viene la parte mas divertida. Desarrollar tu nueva aplicación PHP!. Para simplificar esta parte, que no es el foco de este post, vamos a armar una pagina simple que nos muestre información de PHP (PHPInfo).

Dentro de la carpeta PhpOnAzure.Web, creamos un nuevo archivo con el nombre “index.php”, lo abrimos con un editor de texto (notepad++), y le agregamos el siguiente código y lo guardamos.

<?php

phpinfo();

?>

Nada del otro mundo, pero nos sirve para mostrar todas las variables de PHP en nuestra instancia de Windows Azure.

Ejecutar la aplicación en un amiente local

Generalmente, aunque debería ser siempre, uno quiere testear su aplicación antes de la puesta en producción. Para hacer esto, tenemos dos opciones; nuestro ambiente de desarrollo local, y el ambiente de staging de Windows Azure.

Para utilizar el ambiente de staging de Windows Azure, lee como subir una aplicación a Windows Azure.

Para probar la aplicación en nuestro ambiente local, debemos hacer lo siguiente:

• Abrir la consola de comandos
• Ejecutar el comando ‘package create -in=”C:\temp\WindowsAzurePHPApp” -out=”C:\temp\WindowsAzurePHPApp\build” -dev=true’ (Si el comando package no es reconocido, lee como instalar el ambiente de desarrollo para Windows Azure)
• Una vez que termine de generar el paquete, se abrirá nuestro navegador, y deberíamos ver nuestra aplicación corriendo (phpinfo())

Ejecutar nuestra aplicación PHP en Windows Azure

Para ejecutar cualquier aplicación en Windows Azure, necesitamos dos archivos, el paquete, y el service configuration file. Modificando un poco el comando anterior, en lugar de ver nuestra aplicación corriendo localmente, el SDK de PHP para Windows Azure generará estos dos archivos, para luego poder subirlos desde la interfaz web del Windows Azure Platform.

• Abrir la consola de comandos
• Ejecutar el comando ‘package create -in=”C:\temp\WindowsAzurePHPApp” -out=”C:\temp\WindowsAzurePHPApp\build” -dev=false’

Ahora en la carpeta “C:\temp\WindowsAzurePHPApp\build” obtendremos los dos archivos para subir a Windows Azure; WindowsAzurePHPApp.cspkg y ServiceConfiguration.cscfg

Ahora subimos nuestros archivos a Windows Azure, siguiendo los pasos de este post:

• Deploy de aplicaciones en Windows Azure

Una vez subido el paquete y el service configuration file, Windows Azure puede demorar unos minutos en crear una instancia de Windows Server 2008, instalar PHP, e instalar nuestra aplicación.

En este post quiero hacer una recopilación de algunas de las mejoras y nuevas características que trae Windows 8, la mayoría de las cosas están realmente muy interesantes.

Al final, voy a dejar unos links para los desarrolladores que quieran empezar a trabajar en aplicaciones para Windows 8 .

Soporte a USB 3.0

Una de las cosas mas importantes para un sistema operativo es soportar nuevo hardware. Se tiene estimado que USB 3.0 para el 2015 sea usado por casi el 100% de los usuarios.

Este video explica mas en detalle que esta haciendo el equipo de ingenieros de Windows 8 respecto a USB 3.0

Descargar video: High quality MP4 | Low quality MP4

Mas info en Build Windows 8 Team Blog

Mejoras en la administración de archivos: copy paste rename y delete

Las mejoras que introdujeron al sistema de archivos, a mi personalmente, son las que mas me gustaron. En especial el de poder agrupar los procesos de movidas, copias, y eliminación de archivos y que realmente te marque la taza de transferencia y el tiempo que demora cada proceso individualmente, y como uno repercute en el otro. Además, ahora, esta la posibilidad de pausar los procesos de manera individual, y sin volverse locos si un proceso lentifica el otro, simplemente pausando el que consideremos de menor prioridad, vamos a lograr aprovechar al máximo el procesamiento de lo que nosotros consideremos mas importante para que termine primero.

Otra mejora importante, es el del momento de elegir entre que archivos quedarme ante una colisión de nombre. Con Windows 8 todas las colisiones se pueden solucionar de una manera mas amigable y clara.

Descargar video: High quality MP4 | Low quality MP4

Mas info en Improving our file management basics y Designing the Windows 8 file name collision experience

Explorador de Windows

Después de analizar en profundidad el uso que le dan los usuarios al explorador de Windows, teniendo en cuenta las resoluciones de pantalla, y en particular a lo que los usuarios desean, el equipo de Windows 8 modifico la forma de acceder a las opciones dentro de las carpetas, haciéndolas mas parecidas al layout del Office 2007/2010, con tabs. Este cambio genero muchos comentarios positivos y negativos de parte de la comunidad. A mi particularmente me agrada, porque muestra una homogeneidad de parte de Microsoft para con todos sus productos. A la larga es un bien para los usuarios acostumbrarse a una única forma de buscar las herramientas, estés trabajando en Office, navegando en el explorador de Windows, escribiendo en Windows Live Writer, desarrollando en Web Matrix,etc..

Descargar video: High quality MP4 | Lower quality MP4

Acceso a archivos ISO y VHD

Windows 8 nos permitirá “montar” archivos ISO como DVDs, emulándolo como un dispositivo conectado a nuestro equipo. Y de la misma forma con archivos VHD emulando un disco rígido. Todo esto prácticamente con un click.

Descargar video: High quality MP4 | Lower quality MP4

Metro Style UI

Un nuevo concepto en user experience. Totalmente apto para touch screens, nos permite tener todo lo que queremos al alcance de nuestras manos (literalmente). Pero, podría escribir muchos párrafos explicando como se usa. Pero nada mejor que un video que lo muestre y explique mucho mas claro.

Información para desarrolladores

Si estas ansioso como yo con todo lo que se viene, te dejo algunos links que pueden serte útiles, para empezar a desarrollar para Windows 8.

· Windows Dev Center – http://dev.windows.com

· Building Windows 8 Blog – http://blogs.msdn.com/b/b8/

· Building Windows 8 Twitter – http://twitter.com/#!/BuildWindows8

· BUILD Conference Site – http://www.buildwindows.com/

· BUILD Conference Twitter – http://twitter.com/#!/bldwin

· BUILD Conference Facebook – https://www.facebook.com/#!/pages/Build/156095381124816

En mi próximo post voy a comentar todo lo que se esta viviendo dentro del evento de Build Windows con mas detalle técnico, pero para empezar a entusiasmarse, todo esto, me parece más que suficiente.

En este post voy a explicar como crear una aplicación Windows Azure, compilarla, generar el paquete, subirlo y publicarlo.

Antes de empezar, necesitamos instalar nuestro entorno de desarrollo, solicitar un trial de Windows Azure, y obviamente, Visual Studio 2010 SP1, hay que tener en cuenta que Windows Azure SDK no es compatible con las versiones Express de Visual Studio.

Para empezar, debemos abrir Visual Studio, con privilegios de administrador, haciendo click derecho en el acceso directo, y seleccionando “Run as administrator”.

Una vez abierto, desde el menú debemos acceder a “File” –> “New” –> “Project” [Ctrl + Shift + N]. En el menú izquierdo, elegir  “Cloud”, y seleccionar “Windows Azure Project”. Personalmente yo elijo C#, pero también se podría utilizar VB.NET.

Escribí el nombre de tu aplicación como prefieras, y luego clickea en el botón OK.

Cuando hacemos click en OK, nos aparecerá una ventana como la de la imagen anterior.

En esta ventana debemos seleccionar de entre muchas opciones. En este post no voy a explicar en detalle cada Role, pero sí una pequeña explicación para tener una idea de lo que estamos haciendo.

Un Windows Azure Role es un componente (escalable) corriendo individualmente en la nube que se corresponde a una instancia de una maquina virtual (Virtual Machine/VM).

Hay 2 tipos de Roles:

• Un Web role es una aplicación Web corriendo en un IIS. Es accesible vía HTTP o HTTPS (endpoint).
• Un Worker role es una aplicación que procesa en background que ejecuta código .NET.

Para continuar nuestra idea de deployar nuestra primera aplicación, crearemos un WebRole con el nombre “MiPrimerAPP” por ejemplo. Una vez apretado el botón OK, crearemos nuestra aplicación que debería tener la siguiente estructura:

Si queremos, podemos agregar otro Role haciendo click derecho en Roles (dentro de nuestro proyecto de Windows Azure), luego en “Add”, y seleccionar el Role que queramos agregar.

Para eliminar un Role, debemos seleccionarlo en el listado de Roles, y tocar la tecla “supr” o “delete”.

Ahora, volviendo a la aplicación web. Vamos a dejar como ejemplo el código que viene por default, y presionamos F5. Visual Studio va a hacer build al proyecto, va a ejecutar e iniciar el Development Fabric, inicializar el Development Storage (si se ejecuta por primera vez), va a empaquetar el deployment, atachar todas las instancias de los roles, y luego ejecutar la aplicación en el browser apuntando al Web Role.

En el taskbar nos va a aparecer el icono del Development Fabric, que sirve para probar en un ambiente local las funcionalidades de Windows Azure.

Haciendo click con el botón derecho en el icono, y seleccionando “Show Compute Emulator UI”, se abrirá el “Windows Azure Compute Emulator”, que nos permite efectuar operaciones sobre nuestro deployment. Como, ver en detalle los logs, reiniciar y eliminar deployments.

Con nuestra aplicación corriendo, deberíamos ver nuestra instancia de Web Role y un Worker Role.

Espero que hasta el momento no se hayan cruzado con algún error. Si es así, nuestra aplicación de ejemplo está lista para hacer deploy. Si ya tenés una cuenta de prueba de Windows Azure, debemos ingresar a http://windows.azure.com iniciando sesión con tu Windows Live ID. Una vez que estas logueado, se nos presentará una nueva interfaz web de Windows Azure Platform,construida en Silverlight.

Para empezar el proceso de deployment, tenemos que hacer Publish a nuestro proyecto (WindowsAzureProject) desde el Visual Studio, seleccionando “Create Service Package Only”, para que genere el paquete en nuestro file system, y subirlo manualmente desde la interfaz web de Windows Azure Platform,al que accedimos anteriormente.

El empaquetado consta de 2 archivos, “” y “”, que se crearán en el directorio “\bin\Release\Publish”.

Con el empaquetado generado, vamos a la interfaz web de Windows Azure Platform, hacemos click en “Hosted Services, Storage Accounts & CDN” desde el menú que se encuentra en la esquina inferior izquierda.

Luego desde el menú superior seleccionamos “New hosted service”

Nos aparecerá un popup como el siguiente:

Primero debemos seleccionar nuestra subscripcion, un nombre, la región y un prefijo de URL (podemos apuntar un dominio propio, pero es necesario generar un subdominio *.clounapp.net). Es posible que elijamos un nombre de subdominio que ya tenga otro usuario, si esto pasa, debemos buscar otro nombre.

Seleccionar entre los “Deployment options”, seleccionamos “stage environment”, voy a hablar sobre las opciones de deployment en otro post.

También tenemos que poner un nombre al deploy (Deployment name), por ejemplo, MiPrimerAPP-FECHA.

Y seleccionar de nuestro file system los archivos del empaquetado que generamos desde el Visual Studio al hacer Publish (Package location, Configuration file).

Una vez que llenamos todos los campos, hacemos click en el boton OK al popup. Va a aparecer una ventana de alerta, podemos ignorar esta ventana (nos alerta de que nuestro nuevo hosted service se va a inicializar con una sola instancia).

Luego comenzará el proceso de subida del paquete y creación del hosted service, este puede demorar unos minutos, no hay que cerrar el explorador durante este proceso, ni refrescar la pagina.

Al crear un hosted service, a este se le asigna un ID random para el ambiente de staging “Staging Environment”, que sirve para poder acceder a nuestra aplicación remotamente, como muestra la imagen.

Nuestra evaluación de Windows Azure incluye un Hosted Service, de modo que, si queremos subir otra aplicación, debemos eliminar la que subimos.

Para eliminar nuestro Hosted Service, primero debemos detenerlo, una vez detenido, se habilitará el botón “delete” para poder eliminarlo.

Siguiendo todos los pasos, ya estamos listos para poder empezar a utilizar Windows Azure, en los próximos posts voy a dar mas detalles sobre los tipos de Roles, los ambientes de deploy, y la configuración de nuestra aplicación desde el Azure Configuration File.

Introducción al SDK de Windows Azure para PHP

El SDK de Windows Azure para PHP es un proyecto Open Source que te permite integrar tu aplicación PHP con la API de Windows Azure. El SDK esta construido y sus principales componentes son los siguientes:

• Command Line Tools
• Code Library
• Scaffolders

Code Library

El SDK de Windows Azure para PHP contiene una gran cantidad de elementos para interactuar con nuestras aplicaciones PHP. Las siguientes son algunas de las funciones disponibles en el SDK actual:

• Storage
• • Provee acceso a las APIS de los Blobs, Queues, y Table storage
• Diagnostics
• • Permite el manejo de la infraestructura de diagnostico vía API REST
• Service Management
• • Provee un fácil acceso a la administración del servicio de Windows Azure
• Deployment Management
• • Proporciona una manera sencilla de administrar todos los aspectos relacionados al deployment
• Logging
• • Una forma simple de almacenar logs en una cuenta de Storage

Command line tools

El SDK de Windows Azure para PHP provee un set de comandos que te permiten buildear paquetes, deployar nuestra aplicación, y administrar nuestros servicios de manera fácil y rápida.

El siguiente es un listado de los comandos disponibles actualmente por el SDK:

• package
• • Herramienta que nos permite empaquetar nuestro proyecto. Crear los archivos necesarios para el deploy en Windows Azure
• scaffolder
• • Creación y build de Scaffolds. Acelera el desarrollo de nuestras aplicaciones, proporcionando un esqueleto de una aplicación pre-construida
• deployment
• • Herramienta de administración y creación de deployments
• certificate
• • Herramienta de administración de certificados de Windows Azure
• storage
• • Herramienta que nos permite administrar el Storage de Windows Azure
• service
• • Herramienta de administración del servicio de Windows Azure

El uso en detalle de todos estos comandos se puede consultar directamente ejecutandolos desde la consola.

Scaffolding

El SDK de Windows Azure para PHP contiene funcionalidad de scaffolding, que nos permite acceder a aplicaciones pre-construidas, que podemos usar como esqueleto de nuestro proyecto, para poder estar up and running rápidamente. Un ejemplo podría ser una aplicación de blog pre-desarrollada, que podemos configurar y ejecutar, sin necesidad de programar ni una sola línea de código.

Como obtener el SDK de Windows Azure para PHP

El SDK de Windows Azure para PHP es un proyecto gratuito hosteado en CodePlex. Hay dos formas de obtenerlo, desde un sistema de versionado de código, o por descarga directa.

Descarga directa

Si no utilizas un sistema de versionado de código, CodePlex nos ofrece un archivo ZIP con la versión estable deseada. Este archivo contiene una release o pre-release del código disponible del proyecto.

Para descargarlo, hay que acceder a la sección “Downloads” de la pagina:

http://phpazure.codeplex.com/releases

Subversion

Usar un sistema de versionado para obtener el SDK, te asegura que vas a tener la ultima versión del código. El trunk del proyecto contiene pre-releases estables que incluyen nueva funcionalidad que será luego un lanzada como release final.

El repositorio del proyecto se encuentra en la siguiente dirección:

https://PHPAzure.svn.codeplex.com/svn

Para obtener mas información en el uso de Subversion con CodePlex, ingresa a la siguiente página:

http://codeplex.codeplex.com/Wikipage?title=Source%20Control%20Clients

Team Foundation Server

CodePlex también soporta Team Foundation Server (TFS). El servidor de TFS se encuentra en la siguiente dirección:

https://tfs.codeplex.com/tfs/TFS10

Para obtener mas información en el uso de TFS con CodePlex, ingresa a la siguiente página:

http://codeplex.codeplex.com/Wikipage?title=Source%20Control%20Clients

Instalar los archivos del SDK de Windows Azure para PHP

Después de descargar los archivos, es necesario instalarlos para poder usarlos. El SDK no contiene un instalador. Es un paquete de archivos que se pueden usar directamente. Para un uso mas cómodo del SDK, se recomienda poner los archivos del SDK para PHP dentro de la carpeta del SDK de Windows Azure, que instalamos con el ambiente de desarrollo para Windows Azure.

Ubicá los archivos descargados en la siguiente carpeta:

C:\Program Files\Windows Azure SDK for PHP

Agregar el SDK de Windows Azure para PHP al variable PATH

Lo ultimo que debemos hacer es actualizar la variable PATH del sistema para incluir la ubicación del command line tool del SDK. Esto se hace en pocos pasos de la siguiente manera:

• Botón derecho en “Equipo”, seleccionamos “propiedades”
• En el panel izquierdo de la ventana de propiedades hacer click en “Configuración avanzada del sistema”
• Seleccionar el botón “variables de entorno”, del tab “opciones avanzadas”
• Bajando con el scroll en las variables de sistema hasta encontrar la variable “path”
• Hacer click en “editar”, al final del valor de la variable, agregar el path de donde se ubican los archivos del command line tools del SDK de Windows Azure para PHP
  • Si lo descargaste directamente, el path es el siguiente: C:\Program Files\Windows Azure SDK for PHP\bin
  • Si utilizas un sistema de versionado de código, utilizar el siguiente path: C:\Program Files\Windows Azure SDK for PHP\trunk\bin
    
• Hacer click en “aceptar” hasta cerrar todas las ventanas abiertas.

Ahora estamos listos para poder usar el command line tools del SDK de Windows Azure para PHP, sin necesidad de navegar hasta el directorio donde se encuentra desempaquetado (instalado). Es necesario reiniciar cualquier consola abierta antes o durante la instalación del SDK para que los cambios tengan efecto.

Probar si instalamos correctamente el SDK de Windows Azure para PHP

Probar el SDK de Windows Azure para PHP nos asegura haberlo instalado correctamente, y hacerlo es muy simple. Podes tipear cualquier comando que interprete el command line tools del SDK. Si recibimos un mensaje de ayuda, habremos instalado todo correctamente.

• Abrir una ventana de consola
• Escribir el comando “package” y luego enter
• En la consola debería aparecer un mensaje de ayuda para el comando “package”

Con mas y mas sitios que utilizan AJAX el “hace esto cada vez que carga la pagina”, ya no funciona en todos los casos. Por ejemplo, en un sitio que utiliza algún sistema de publicidad basado en iframes cada vez que recarga la pagina se contabiliza como un page-view en la publicidad, y si nuestro sitio utiliza un paginador basado en AJAX, los page-views de nuestras publicidades se verán reducidas considerablemente. Lo mismo pasa si queremos trakear la navegación de los usuarios por nuestro sitio basado en AJAX. Google, siempre pensando un paso adelante, ya provee la posibilidad de hacer esto con Google Analytics.

El código

El código para cargar Google Analytics actual, utiliza un método de carga asincrónico:

var _gaq=[["_setAccount","UA-#######-#"],["_trackPageview"]];
(function(d,t){var g=d.createElement(t),s=d.getElementsByTagName(t)[0];g.async=1;
g.src=("https:"==location.protocol?"//ssl":"//www")+".google-analytics.com/ga.js";
s.parentNode.insertBefore(g,s)}(document,"script"));

El código anterior trakea la carga inicial de la pagina, pero no trakea las llamadas AJAX posteriores, para hacer esto, debemos añadir el siguiente código:

// "_trackEvent" is the pageview event,
_gaq.push(['_trackPageview', '/some-page']);

_trackPageview es usado nuevamente, pero esta vez le pasamos como segundo parámetro la URL de la llamada a AJAX que queramos trakear. Simplemente con esta línea podremos trakear las llamadas AJAX al igual que las cargas iniciales de las paginas.

El método anterior

Si todavía utilizas en tus paginas el método viejo de llamadas sincrónicas, también podes trakear llamadas AJAX, pero con el siguiente código:

pageTracker._trackPageview('/some-page');

Es realmente excelente saber que Google Analytics es tan dinámico como nuestras aplicaciones, brindando estadísticas detalladas, sin necesidad adoptar métodos alternativos para obtenerlas.

Antes de poder generar un paquete, y probar tus aplicaciones con el emulador local de Windows Azure, hay que instalar un ambiente de desarrollo para Windows Azure, en este post veremos como instalar uno, y adicionalmente orientaremos la instalación para poder soportar PHP en nuestras aplicaciones para la nube.

Descarga Microsoft Web Platform Installer

Nuestro primer paso es instalar Microsoft Web Platform Installer, que lo podemos descargar desde el siguiente link:

http://www.microsoft.com/web/downloads/platform.aspx

Luego de hacer click en el botón “Download It Now”, se lanzará la descarga de el archivo de instalación.

Una vez descargado, abrirlo, y seguir los pasos del instalador.

Elegir los componentes a instalar

Windows Azure SDK

En el campo de búsqueda, escribir “azure” y presionar enter. Luego clickear en “agregar” en la fila correspondiente a “Windows Azure SDK”, y también a “Windows Azure SDK 1.4.1 Refresh”

PHP

Ahora en el campo de búsqueda, escribir “PHP”, y clickear en “agregar” a la fila que contiene “PHP 5.3.6 For WebMatrix”. Hay que tener en cuenta que Web Platform Installer va a agregar automáticamente a nuestro listado pendiente de instalación todas las dependencias de los productos que hayamos seleccionado.

SQL Server Express

Finalmente, escribir “SQL Server Express” en el campo de búsqueda, y clickear en “agregar” en la fila correspondiente a “SQL Server Express 2008 R2”, y después clickear en el botón “Instalar” que se encuentra en la parte inferior derecha de la ventana.

Revisar y aceptar los términos de uso

Tendremos que aceptar los términos de uso de los productos seleccionados y sus dependencias (luego de leerlas).

El software seleccionado comenzará a descargarse e instalarse, dependiendo de tu conexión a internet, puede demorar unos minutos.

SQL Server Express Password

SQL Server Express, en su instalación, nos pedirá que creemos un password para el administrador del servidor.

Finalmente, y luego de terminada la instalación, saldrá la siguiente ventana.

Probar el ambiente instalado

Compute Emulator y Storage Emulator

En el menú inicio, deberíamos tener, luego de la instalación anterior, un nuevo item “Windows Azure SDK v1.4”, dentro clickear “Compute Emulator”, para ejecutar el emulador. Si aparece un mensaje de seguridad de Windows, clickear en “permitir”.

Después de que el Compute Emulator haya iniciado, aparecerá un nuevo icono en nuestro system tray. Desde ahí podremos abrir el Compute UI, apagar o iniciar el Compute Emulator, o el Storage Emulator.

Luego de seguir estos pasos, tendremos nuestro ambiente preparado para desarrollar, probar, y deployar aplicaciones para Windows Azure, inclusive aplicaciones en PHP, que en mi siguiente post explicaré como compilar y subir una de ejemplo a Windows Azure.

Vengo hace tiempo diciendo que voy a armar mi blog, y me parecio buena oportunidad comenzar con este humilde aporte.

El logo de #HTML5DevsArg  (una muy buena idea de @masaez) en canvas HTML5 a pedido de @TrueNacho

Esta dentro de un iframe, para acceder pueden entrar acá.