Controla tu banshee desde tu cel con Remuco y Ubuntu
En ubuntu karmic debes seguir la siguiente receta
Agregar al repositorio las siguientes entradas (sudo gedit /etc/apt/sources.list)
deb-src http://ppa.launchpad.net/remuco-team/ppa/ubuntu karmic main
Actualizamos el repositorio:
Instalamoso el cliente Remuco para nuestro reproductor favorito (en mi caso es el banshee)
Bajamos e instalamos el cliente (midlet) en nuestro celular con soporte para aplicaciones java.
Descargamos la última versión de aquí, descomprimimos el .rar y buscamos en la siguiente ruta la aplicación .jar, en mi caso:
Enviamos por bluetooth el .jar a nuestro teléfono, aceptamos la aplicación y el Remuco queda instalado. Ahora hay que levantar el cliente en nuestro ubuntu de la siguiente forma:
Log output will be stored in /home/dennys/.cache/remuco/banshee/log
Contribute to Remuco: Please run 'remuco-report' once a client has connected, thanks!
Para no hacer el paso anterior cada vez que encendemos la compu, lo agregamos como una aplicación de inicio:
Sistemas>Preferencias>Aplicaciones de Inicio
Luego el botón Añadir y escribimos:
También tenemos que abrir nuestro Banshee y agregar canciones a la cola de reproducción, las cuales podrá “ver” el cliente Remuco en el teléfono.
¡Listo!, abre la aplicación en el teléfono y disfruta tu controlo remoto 
.
Más información:
Using mobile phone as remote for linux media players is fun!
Recorrido sobre un árbol de Jerarquías en SQL Server
Necesitarás la estructura de la tabla y unos cuantos datos de prueba que puedes copiar de aquí, lo he tomado de la página Recursive Queries Using Common Table Expressions del msdn.
CREATE TABLE dbo.MyEmployees
(
EmployeeID smallint NOT NULL,
FirstName nvarchar(30) NOT NULL,
LastName nvarchar(40) NOT NULL,
Title nvarchar(50) NOT NULL,
DeptID smallint NOT NULL,
ManagerID int NULL,
CONSTRAINT PK_EmployeeID PRIMARY KEY CLUSTERED (EmployeeID ASC)
);
-- Populate the table with values.
INSERT INTO dbo.MyEmployees VALUES
(1, N'Ken', N'Sanchez', N'Chief Executive Officer',16,NULL)
,(273, N'Brian', N'Welcker', N'Vice President of Sales',3,1)
,(274, N'Stephen', N'Jiang', N'North American Sales Manager',3,273)
,(275, N'Michael', N'Blythe', N'Sales Representative',3,274)
,(276, N'Linda', N'Mitchell', N'Sales Representative',3,274)
,(285, N'Syed', N'Abbas', N'Pacific Sales Manager',3,273)
,(286, N'Lynn', N'Tsoflias', N'Sales Representative',3,285)
,(16, N'David',N'Bradley', N'Marketing Manager', 4, 273)
,(23, N'Mary', N'Gibson', N'Marketing Specialist', 4, 16);
Tenemos un árbol de jerarquías como este:
-- / | \
--16 274 285
--/ / \ \
--23 275 276 286
¿Como puedo conocer los nodos ancestros del nodo 286?
Este query soluciona el problema, empleando un CTE (Common Table Expression) que entre cosas permite ser autoreferenciado.
AS
(
-- Anchor member definition
SELECT e.ManagerID, e.EmployeeID, e.Title, 0 AS Level
FROM dbo.MyEmployees AS e
INNER JOIN HumanResources.EmployeeDepartmentHistory AS edh
ON e.EmployeeID = edh.EmployeeID AND edh.EndDate IS NULL
WHERE e.EmployeeID IN (1,274,276,275) --COMO PARAMETRO LAS HOJAS
UNION ALL
-- Recursive member definition
SELECT e.ManagerID, e.EmployeeID, e.Title, Level + 1
FROM dbo.MyEmployees AS e
INNER JOIN HumanResources.EmployeeDepartmentHistory AS edh
ON e.EmployeeID = edh.EmployeeID AND edh.EndDate IS NULL
INNER JOIN DirectReports AS d
ON e.EmployeeID = d.ManagerID
)
SELECT * FROM MyEmployees
-- Statement that executes the CTE
SELECT DISTINCT ManagerID, EmployeeID--, Title, Level
FROM DirectReports
Cuando el número de nodos se encuentra en el orden de los miles, el tiempo de ejecución toma importancia y es mejor tener una versión iterativa de la solución.
CREATE TABLE #Tree
(
cid INT NOT NULL,
pid INT NULL,
lvl INT NOT NULL,
);
declare @lvl AS int
SET @lvl = 0
--Inserta al conjunto los nodos raíz
INSERT INTO #Tree(lvl,cid, pid)
SELECT @lvl,EmployeeID, ManagerID
FROM dbo.MyEmployees
WHERE EmployeeID IN (1,274,276,275)
-- select * from #Tree
WHILE @@rowcount > 0
BEGIN
SET @lvl = @lvl + 1;
INSERT INTO #Tree(lvl,cid, pid)
SELECT @lvl, C.EmployeeID, C.ManagerID
FROM #Tree AS P
JOIN dbo.MyEmployees AS C
ON P.lvl = @lvl - 1 AND
P.pid = C.EmployeeID;
END
SELECT DISTINCT cid,pid FROM #Tree
Increible tetris en 19 líneas escrito en c
Código ganador del “The International Obfuscated C Code Contest“ del 2007 hecho en México.
¡Completamente inspirador!
=0,i=276,j,k,q[276],Q[276],*n=q,*m,x=17,f[]={7,-13,-12,1,8,-11,-12,-1,9,-1,1,
12,3,-13,-12,-1,12,-1,11,1,15,-1,13,1,18,-1,1,2,0,-12,-1,11,1,-12,1,13,10,-12,
1,12,11,-12,-1,1,2,-12,-1,12,13,-12,12,13,14,-11,-1,1,4,-13,-12,12,16,-11,-12,
12,17,-13,1,-1,5,-12,12,11,6,-12,12,24};u(){for(i=11;++i<264;)if((k=q[i])-Q[i]
){Q[i]=k;if(i-++I||i%12<1)printf("\033[%d;%dH",(I=i)/12,i%12*2+28);printf(
"\033[%dm "+(K-k?0:5),k);K=k;}Q[263]=c=getchar();}G(b){for(i=4;i--;)if(q[i?b+
n[i]:b])return 0;return 1;}g(b){for(i=4;i--;q[i?x+n[i]:x]=b);}main(C,V,a)char*
*V,*a;{h[3]=1000000/(l=C>1?atoi(V[1]):2);for(a=C>2?V[2]:"jkl pq";i;i--)*n++=i<
25||i%12<2?7:0;srand(getpid());system("stty cbreak -echo stop u");sigvec(14,v,
0);t();puts("\033[H\033[J");for(n=f+rand()%7*4;;g(7),u(),g(0)){if(c<0){if(G(x+
12))x+=12;else{g(7);++w;for(j=0;j<252;j=12*(j/12+1))for(;q[++j];)if(j%12==10){
for(;j%12;q[j--]=0);u();for(;--j;q[j+12]=q[j]);u();}n=f+rand()%7*4;G(x=17)||(c
=a[5]);}}if(c==*a)G(--x)||++x;if(c==a[1])n=f+4**(m=n),G(x)||(n=m);if(c==a[2])G
(++x)||--x;if(c==a[3])for(;G(x+12);++w)x+=12;if(c==a[4]||c==a[5]){s=sigblock(
8192);printf("\033[H\033[J\033[0m%d\n",w);if(c==a[5])break;for(j=264;j--;Q[j]=
0);while(getchar()-a[4]);puts("\033[H\033[J\033[7m");sigsetmask(s);}}d=popen(
"stty -cbreak echo stop \023;sort -mnr -o HI - HI;cat HI","w");fprintf(d,
"%4d from level %1d by %s\n",w,l,getlogin());pclose(d);}
Para verlo en acción abran una terminal, compilen y ejecuten:
$ gcc tetris.c -o tetris
$ ./tetris
Concurso de Programación ANPA10
Faltan pocos días para el ANPA 2010
El próximo concurso de la ANPA será el 24 de Abril del presente año en León, Guanajuato; no es necesario pertenecer a alguna institución para poder participar y para que se animen a participar, este es uno de los problemas del ANPA07.
Problema: Cajas (ANPA 07 Semifinal)
Autor: Fory
Historia
El encargado de “Empresa productora de cartón” decidió lanzar una línea nueva de cajas. La línea consiste en una colección de cajas cúbicas de diferentes tamaños. Como promoción de lanzamiento se hicieron paquetes de cajas de tal forma que al abrir una puedas encontrar otra y dentro de esta una más y así sucesivamente hasta abrir la caja más pequeña incluida en el paquete. De improviso llega un cliente a la fábrica pidiendo un paquete de lanzamiento; desafortunadamente todos los paquetes ya fueron enviados a las tiendas. Dado que tú eres el responsable de armarlos decides formar uno con el mayor número posible de cajas existentes en la fábrica.
ProblemaHacer un programa que lea el tamaño de cada una de las cajas que hay en la fábrica y escriba el mayor número de cajas que puede tener el paquete. Dentro de una caja de tamaño T puedes meter otra de tamaño t sólo sí t < T.
Entrada
La primer línea de la entrada contendrá un sólo número entero n (1 ≤ n ≤ 100). Dicho número representa el número de casos de prueba para este problema. Cada una de las siguientes n líneas describirá un caso de prueba. En cada caso debes leer primero un entero k (1 ≤ k ≤ 1000) que indica cuantas cajas hay en la fábrica y después leer el tamaño de cada una de las cajas. El tamaño de cada caja será un entero entre 1 y 1000.
Ejemplo:
4
11 1 2 3 4 5 6 7 8 9 10 11
1 10
4 2 2 2 2
5 1 2 2 3 10Salida
Para cada caso de prueba debes escribir una línea de texto con el mensaje “El paquete mayor tiene N cajas.”, siendo N el número de cajas en el paquete más grande. Ejemplo (estas salidas corresponden al ejemplo que se da en Entrada):
El paquete mayor tiene 11 cajas.
El paquete mayor tiene 1 cajas.
El paquete mayor tiene 1 cajas.
El paquete mayor tiene 4 cajas.Nombre del programa
cajas.cpp, cajas.java, cajas.cs, cajas.vb
Como pueden ver, no es nada del otro mundo y la solución se puede escribir en pocas lineas en c++:
#include <cstdio>
#include <set>
using namespace std;
int main(){
int casos, ncajas, tamCaja;
scanf("%d",&casos);
while(casos--){
set<int>cajas_no_repetidas;
scanf("%d",&ncajas);
for(int i=0; i<ncajas;i++){
scanf("%d",&tamCaja);
cajas_no_repetidas.insert(tamCaja);
}
printf("El paquete mayor tiene %d cajas.\n",cajas_no_repetidas.size());
}
}
Les dejo algunos de los problemas aquí para que se terminen de animar.
¿Cómo pasar parámetros por default en C#?
¿Cuántas veces nos encontramos con funciones que por algún ajuste o cambio funcionarían mejor si contarán con otro parámetro más? Esto es muy común cuando tenemos proyectos “grandes” o de tiempo atrás y estamos tratando de realizar una modificación. El problema toma especial importancia si el código que deseamos modificar no fue escrito por nosotros o si no conocemos su funcionamiento del todo.
Un enfoque podría ser sobrecargar la función agregando el segundo parámetro, pero muchos de nosotros (desarrolladores) no nos agrada mucho la idea de repetir código. La solución idonea para mí es pasar el segundo argumento que necesitamos en la misma función y establecer un valor por default que no afecte el comportamiento actual de dicha función.
Es ahí donde entran en juego el uso de parámetros por default, en c++ la sintaxis nos ayuda y la solución se vuelve simple:
using namespace std;
int potencia(int a, int b=2)
{
int factor=1;
for(int i=0; i<b; i++)
factor*=a;
return factor;
}
int main()
{
cout << potencia(2,3) << endl;
cout << potencia(2) << endl;
}
¿Qué pasa si deseamos hacerlo en C#?
Resulta que el lenguaje no soporta esta sintaxis (C# 4.0 sí lo hace), por lo que necesitamos buscar otra manera de hacerlo. La manera sencilla es definiendo el prototipo de la función con una lista de argumentos de longitud variable.
¿cómo hacemos esto?
Podremos “llamar” a nuestra función potencia con uno, dos o cualquier cantidad de parámetros que queramos de tipo entero separados por coma. Al reescribir nuestro programa de ejemplo en C#, nos queda de la siguiente manera:
{
int valor = args[0];
int potencia = 2;
if(args.Length > 0)
potencia = args[1]
int factor=1;
for(int i=0; i<potencia; i++)
factor*=valor;
return factor;
}
Marquesina basada en Arduino
Después del sketch del Knight Rider, fue imposible evitar la tentación de escribir otro sketch para el Arduino, que transformará la matriz de leds de 8×8 en una mini-banner. Solo bastaron un pocos cambios en el contador 4017 para ¡tener el hardware listo! (eliminar el reset autómatico al llegar al Output 8).
banner
La mayor parte del código está basado en el instructivo de Syst3mX.
//22 Noviembre de 2009
int col[] = {0,1, 2, 3, 4, 5, 6, 7};
int clock = 9;// goes to the clock pin on the 4017 IC
int reset = 8;//goes to the reset pin on the 4017 IC
const int numPatterns = 18 ;
byte patterns[numPatterns][8]={space,M,lit_a,lit_k,lit_e,dos_pts,space,lit_e,lit_n,space,E,lit_s,lit_p,lit_a,lit_nh,lit_o,lit_l,space};
void setup(){
//simple stuff here
pinMode(clock,OUTPUT);
pinMode(reset,OUTPUT);
//simple stuff here
for (int thisPin = 0; thisPin < 8; thisPin++) {
// initialize the output pins for matrix 1:
pinMode(col[thisPin], OUTPUT);
}
//reseting the 4017 IC, you have to do this
digitalWrite(reset,HIGH);
delayMicroseconds(5);
digitalWrite(reset,LOW);
}
void display_pattern(int loops)
{
//for each pattern
for(int x=0; x<numPatterns-1; x++){
for (int z=0;z<8;z++){
//scrolls one bite at a time
// the delay we get with loops
for(int t=0;t<loops;t++){
//reseting the 4017 IC, you have to do this
digitalWrite(reset,HIGH);
delayMicroseconds(5);
digitalWrite(reset,LOW);
for(int y=0; y<8; y++){
byte temp = patterns[x][y];
byte temp_2=patterns[x+1][y];
//writes digital outputs, Z is for how much bites it need to scroll
PORTD = B11111111 - ((temp<<z) + (temp_2>>7-z));
delayMicroseconds(400);// the time every row is one
PORTD= B11111111;// all pins are low, fixes the ghosting effect
digitalWrite(clock,HIGH);
delayMicroseconds(50);
digitalWrite(clock,LOW);
}
}
}
}
}
void loop(){
display_pattern(50); // int loop = 15(if you do more loop the pattern whould scrrol slower).
}
Aquí esta la representación de los caracteres para la matriz de 8×8
#define B {B01111100,B01000010,B01000010,B01111100,B01000010,B01000010,B01000010,B01111100}
#define C {B00111110,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B00111110}
#define D {B01111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01111100}
#define E {B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01111110}
#define F {B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01000000}
#define G {B00111100,B01000010,B01000010,B01000000,B01000111,B01000010,B01000010,B00111100}
#define H {B01000010,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010,B01000010}
#define I {B00111000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00111000}
#define J {B00011100,B00001000,B00001000,B00001000,B00001000,B01001000,B01001000,B00110000}
#define K {B01000100,B01001000,B01010000,B01100000,B01010000,B01001000,B01000100,B01000010}
#define L {B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01111110}
#define M {B10000010,B11000110,B10101010,B10010010,B10000010,B10000010,B10000010,B10000010}
#define N {B01000010,B01100010,B01010010,B01001010,B01001010,B01001010,B01000110,B01000010}
#define O {B00111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define P {B01111100,B01000010,B01000010,B01000010,B01111100,B01000000,B01000000,B01000000}
#define Q {B00111100,B01000010,B01000010,B01000010,B01000010,B01000110,B00111110,B00000001}
#define R {B01111100,B01000010,B01000010,B01000010,B01111100,B01000100,B01000010,B01000010}
#define S {B00111100,B01000010,B01000000,B01000000,B00111100,B00000010,B01000010,B00111100}
#define T {B11111110,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define U {B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define V {B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00100100,B00011000}
#define W {B10000010,B10000010,B10000010,B10000010,B10010010,B10010010,B10101010,B01000100}
#define X {B01000010,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B01000010}
#define Y {B10000010,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define Z {B01111110,B00000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}
#define lit_a {B00000000,B00110000,B01001000,B00001000,B00111000,B01001000,B01001000,B00110100}
#define lit_b {B00000000,B00100000,B00100000,B00100000,B00111100,B00100010,B00100010,B00111100}
#define lit_c {B00000000,B00000000,B00000000,B00111100,B01000000,B01000000,B01000000,B00111100}
#define lit_d {B00000000,B00000100,B00000100,B00000100,B00111100,B01000100,B01000100,B00111100}
#define lit_e {B00000000,B00111000,B01000100,B01000100,B01111100,B01000000,B01000100,B00111000}
#define lit_f {B00011000,B00100100,B00100000,B00100000,B01110000,B00100000,B00100000,B00100000}
#define lit_g {B00011100,B00100010,B00100010,B00011100,B00001000,B00001100,B00100010,B00011100}
#define lit_h {B01000000,B01000000,B01000000,B01000000,B01111000,B01000100,B01000100,B01000100}
#define lit_i {B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define lit_j {B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B01010000,B00100000}
#define lit_k {B00000000,B01000000,B01001000,B01010000,B01100000,B01100000,B01010000,B01001000}
#define lit_l {B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000}
#define lit_m {B00000000,B00000000,B10110110,B01001001,B01001001,B01001001,B01001001,B01001001}
#define lit_n {B00000000,B00000000,B10111000,B01000100,B01000100,B01000100,B01000100,B01000100}
#define lit_nh {B01111100,B00000000,B10111000,B01000100,B01000100,B01000100,B01000100,B01000100}
#define lit_o {B00000000,B00000000,B00000000,B00011100,B00100010,B00100010,B00100010,B00011100}
#define lit_p {B00000000,B00011100,B00100010,B00100010,B00111100,B00100000,B00100000,B00100000}
#define lit_q {B00000000,B00000000,B00111000,B01000100,B01000100,B00111100,B00000100,B00000100}
#define lit_r {B00000000,B00000000,B00111000,B01000000,B01000000,B01000000,B01000000,B01000000}
#define lit_s {B00000000,B00111000,B01000100,B01000000,B00111000,B00000100,B01000100,B00111000}
#define lit_t {B00100000,B00100000,B00100000,B01111100,B00100000,B00100000,B00100100,B00011000}
#define lit_u {B00000000,B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00111000}
#define lit_v {B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00101000,B00010000}
#define lit_w {B00000000,B00000000,B00000000,B01000100,B01000100,B01010100,B01010100,B00101000}
#define lit_x {B00000000,B00000000,B00000000,B00000000,B00100100,B00011000,B00011000,B00100100}
#define lit_y {B00000000,B01000100,B01000100,B00111100,B00000100,B00000100,B01000100,B00111000}
#define lit_z {B00000000,B00000000,B00000000,B01111100,B00001000,B00010000,B00100000,B01111100}
#define space {B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define num_0 {B00111100,B01000110,B01001010,B01001010,B01001010,B01010010,B01100010,B00111100}
#define num_1 {B00001000,B00011000,B00001000,B00001000,B00001000,B00001000,B00001000,B00011100}
#define num_2 {B00111100,B01000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}
#define num_3 {B01111110,B00000010,B00000010,B00011100,B00000010,B00000010,B01000010,B00111100}
#define num_4 {B00000100,B00001100,B00010100,B00100100,B01000100,B01111110,B00000100,B00000100}
#define num_5 {B01111110,B01000000,B01000000,B00111100,B00000010,B00000010,B00000010,B01111100}
#define num_6 {B00111100,B01000000,B01000000,B01111100,B01000010,B01000010,B01000010,B00111100}
#define num_7 {B01111110,B00000010,B00000100,B00001000,B00010000,B00010000,B00010000,B00010000}
#define num_8 {B00111100,B01000010,B01000010,B00111100,B01000010,B01000010,B01000010,B00111100}
#define num_9 {B00111100,B01000010,B01000010,B01000010,B00111110,B00000010,B00000010,B00111100}
#define times {B00000000,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B00000000}
#define dos_pts{B00000000,B00000000,B00110000,B00110000,B00000000,B00110000,B00110000,B00000000}
Knight Rider effect based on Arduino
I confess that I liked so much the TV show “Knight Rider” (”Kit, el auto increíble” in Mexico) of eighties. I have seen the new version, the effects are cool but not so much the story. Here is an sketch that looks like the ancient panel of Kit. Take a look and leave me your comments!
matrix 8x8
Here is the Arduino sketch, it’s a mod of Tom Igoe’s code that reduce the number of ports that we need to control the matrix adding an 4017 counter.
// by Dennys Regalado Díaz <http://challenges.qumax.org>
int clock = 9;// goes to the clock pin on the 4017 IC
int reset = 8;//goes to the reset pin on the 4017 IC
int row[]={0,1,2,3,4,5,6,7}; //PORTD(0-7)
void setup(){
//simple stuff here
pinMode(clock,OUTPUT);
pinMode(reset,OUTPUT);
for (int thisPin = 0; thisPin < 8; thisPin++) {
// initialize the output pins for matrix 1:
pinMode(row[thisPin], OUTPUT);
// take the row pins (i.e. the cathodes) low to
// the LEDS are off:
digitalWrite(row[thisPin], HIGH);
}
//reseting the 4017 IC, you have to do this
digitalWrite(reset,HIGH);
delayMicroseconds(5);
digitalWrite(reset,LOW);
}
void display_pattern(int loops)
{
for (int thisrow = 0; thisrow < 8; thisrow++) {
// take the row pin (cathodes) high:
digitalWrite(row[thisrow], LOW);
// iterate over the cols (anodes):
for (int thiscol = 0; thiscol < 8; thiscol++) {
// when the row is low and the col is high,
// the LED where they meet turns on:
//send a clock signal to the counter 4017
digitalWrite(clock, LOW);
delay(50);
digitalWrite(clock, HIGH);
}
// take the row pin high to turn off the whole row
digitalWrite(row[thisrow], HIGH);
}
}
void loop(){
display_pattern(100);// calls for the display_pattern function and says that int loop = 15(if you do more loop the pattern whould scrrol slower).
}
Reciclando casetes
Lámpara DIY con 30 casetes y unas cintas para mantenerlos unidos. ¿Alguna idea para reutilizar esos casetes viejos que tienes en casa? Admito que me costó un poco convencerme de armar el cubo de casetes, pero ¡al final lo logré!. Quizá realizarlo en dos sesiones es la mejor idea, empezar formando las 5 caras y unirlas al final.
El resultado fue esa lámpara de arriba que luce poco ordinaria sobre mi mesa de trabajo.
[vía ooomydesign]
Editors Day 2009
Conferencias de Intel LABS en Ixtapan de la Sal.
[vía bytepodcast]
Concepto Nokia Morph
Hoy por la mañana me tocó ver este video en una presentación relacionada con gadgets y me quedé con la interrogante: ¿hoy en día qué tan avanzada está la nanotecnología?¿en verdad se puede construir?¿ustedes qué opinan?