Está en la página 1de 58

Una entrega más de Código Latino, ya han pasado 15 días desde la última, ya es la segunda en

manos mías y para esta edición tendremos mucho mucho código, estoy tratando de mejorar el
aspecto, pero sigo pidiendo ayuda para esto, YO SOY MALO PARA EL DISEÑO.

Comenzaremos con un código mío, por qué no??? :P jejeje y seguiremos con manuales de
grandes de la programación hispanohablante.

Espero la disfruten leyendola tanto como yo la hicé editandola!!!

PD. Soy malo para esto de la primera página también :P


● Aplicación Cliente – Servidor (Python)
● Crear nuestra propía RunTime Library I Parte ( C )
● Transferir el foco desde un JTextArea al recibir un 'Tab Key'(Java)
● Renombrar archivos (Ruby)
● Fundamento    de  los   ataques por desbordamiento de Buffer [FADB 
1­2] (ASM)
● Entrevista a FrankGK
● El   futúro   del   Scripting   –   Arquitectura   –   PowerShell   para   IT's 
(PowerShell)
● Historia del Lenguaje de Programación Python
● Tutorial BATCH
● Review de Inform 7 (Inform) 
● Entrevista a F_Tanori
Aplicación Cliente - Servidor
Por RadicalEd http://radicalpython.blogspot.com
Hoy explicaremos cómo hacer una sencilla aplicación cliente servidor con Python; con muy pocas líneas de
código se puede hacer una especie de Troyano , algo que nunca pude ni siquiera en Visual Basic con su
control Winsock >:-( ; en la próxima entrega explicaré como hacer un Troyano de Conexión Inversa.

Ahora veamos el código del Servidor:


#!/usr/bin/env python
#server.py
#Desarrollado por RadicalEd

import socket
from subprocess import *

#Creamos un objeto socket


sock = socket.
socket.socket(
socket(socket.
socket.AF_INET,
AF_INET, socket.
socket.SOCK_STREAM)
#Nos enlazamos directamente al equipo
sock.bind((
sock.bind((socket
socket..gethostbyname(socket
gethostbyname(socket..gethostname()),
gethostname()), 3128))
3128))
#Nos ponemos a la escucha
sock.listen(
sock.listen(55)
try:
try:
while True:
True:
#Aceptamos la conexion quedandonos a la escucha
conn, addr = sock.accept()
sock.accept()
#Recibimos hasta 2KB de datos
command = conn.recv(
conn.recv(2048
2048))
try:
try:
#Para mas info
#http://www.python.org/doc/2.5/lib/node529.html
echo = Popen(
Popen(command, shell=True
shell=True,, stdout=PIPE)
stdout=PIPE).stdout.
stdout.read()
#Enviamos los datos mostrados al cliente
conn.send(
conn.send(echo
echo))
except:
except:
#En caso de no ejecutarse se muestra un error
conn.send(
conn.send('Error'
'Error'))
#Cerramos la conexion
conn.close()
conn.close()
#Si llegan a oprimir Ctrl + Z que no muestre nada
except KeyboardInterrupt:
KeyboardInterrupt:
pass
Ahora veamos el código del Cliente:
#!/usr/bin/env python
#cliente.py
#Desarrollado por RadicalEd

import socket,
socket, sys

print 'Para salir oprima Ctrl + Z'


IP = raw_input(
raw_input('Digite la IP: ')
')

try:
try:
#Un bucle infinito para enviar peticiones
while True:
True:
#Creamos un objeto socket
sock = socket.
socket.socket(
socket(socket.
socket.AF_INET,
AF_INET, socket.
socket.SOCK_STREAM)
#Nos conectamos
sock.connect((
sock.connect((IP,
IP,3128
3128))))
#Empezamos a enviar peticiones
send = raw_input(
raw_input('>>> ')') #El prompt de Python :P
sock.send(
sock.send(send
send))
#Recibimos hasta 2KB de datos
print sock.recv(
sock.recv(2048
2048))
#Cerramos la conexion
sock.close()
sock.close()
#En caso de haber un KeyboardInterrupt salimos sin mostrar nada
except KeyboardInterrupt:
KeyboardInterrupt:
pass

Este coloreado de Sintáxis es gracias al Geshi de SoloCodigo


Crear nuestra propia Run Time Library (Primera Parte)
Por Eternal_Idol
Alguna vez se preguntaron por que un programa como este puede llegar a ocupar unos 24KB?

int main(int
main(int argc, char *argv, char *env)
{
return 50;
50;
}

Este programa no hace NADA, solo nos devuelve un 50 (si recuerdan nuestro último tutorial esto es mov eax,
50). El 'problema' es que VC++ por defecto incorpora su Run Time Library que contiene muchisimas
funciones indispensables como strlen, malloc, printf y muchas más. Esta Run Time Library ocupa bastantes
KB, si hacemos un programa extenso su tamaño no tiene la más mínima importancia, pero si sólo escribimos
un par de instrucciones ...

Linkeen el código anterior con esta línea de comandos:


link código.obj /NODEFAULTLIB /ENTRY:main

Paso a explicar, NODEFAULTLIB le indica al linker que quite las librerias que utiliza para resolver
referencias externas por defecto.
ENTRY le indica al linker la función que dará comienzo al programa que por defecto nunca es main, nuestras
funciones main o WinMain son llamadas por otras que antes hacen inicialización de la Heap para utilizar
malloc y free, que nos devuelven argc, argv y env por ejemplo. Estas funciones se llaman mainCRTStartup
para main y WinMainCRTStartup para WinMain.

Que hemos logrado con esta línea de comandos? Reducir el tamaño de nuestro ejecutable a nada más y nada
menos que 1024 bytes (si no lo consiguieron es porque tienen una versión del linker que usa un align grande
prueben con: link código.obj /NODEFAULTLIB /ENTRY:main /ALIGN:512 y lo van a conseguir).

Esto está muy bien pero en realidad no nos sirve de mucho, ahora tenemos un programa que está
discapacitado, no puede llamar ni siquiera a la función strlen(). Pero como el título de este tutorial dice vamos
a crear nuestra propia Run Time Library para reemplazar la de VC++, el objetivo no es hacer una mejor que
los muchachos de Microsoft, sino tener nuestra propia Run Time Library unicamente con las funciones que
necesitemos y de paso aprender MUCHO sobre programación.
Primero vamos a ver un ejemplo de Run Time Library muy simple escrito en C++. Nuestro objetivo en este
momento es compilar este programa (COMUN.CPP) sin la STDLIB por defecto:

#include <windows.h>
int main(int
main(int argc, char *argv, char *env)
{
char *dos = (char
(char*)malloc(55);
*)malloc(55);
int x = strlen("hola"
strlen("hola");
);
wsprintf(dos,"%d"
wsprintf(dos,"%d",x);
,x);
MessageBox(0,dos,dos,0);
free(dos);
return 50;
50;
}

Con esta línea de comandos LINK COMUN.OBJ /NODEFAULTLIB user32.lib kernel32.lib nos enteramos
que nos faltan un par de funciones, estas cuatro exactamente:

COMUN.OBJ : error LNK2001: unresolved external symbol _free


COMUN.OBJ : error LNK2001: unresolved external symbol _strlen
COMUN.OBJ : error LNK2001: unresolved external symbol _malloc
LINKASM : error LNK2001: unresolved external symbol _mainCRTStartup
COMUN.exe : fatal error LNK1120: 4 unresolved externals

Al crear nuestra librería la vamos a hacer lo más módular posible, porque cada archivo objeto (código
compilado) que sea llamado se cargará completamente, por ejemplo si tenemos todas las funciones dentro de
un solo archivo .cpp, lo compilamos y solo utilizamos strlen() dentro del programa que usa nuestra Run Time
Library también serán cargadas strcpy(), malloc(), free() y todas las funciones que hagamos.

Sabiendo esto que es muy importante vamos a crear cuatro archivos, C_STR.CPP con las funciones strlen() y
strcpy(), C_MAIN.CPP con mainCRTStartup, C_WMAIN.CPP con WinMainCRTStartup y C_ALLOC.CPP
con malloc() y free().

C_STR.CPP:
extern "C" size_t strlen(const
strlen(const char *s)
{
unsigned long Result = 0;
while(*s++)
while(*s++) { Result++; }
return Result;
}
extern "C" char *strcpy(char
*strcpy(char *dest, const char *src)
{
char *cp = dest;
while(*cp++
while(*cp++ = *src++);
return (dest);
}

C_MAIN.CPP:
extern int main(int
main(int argc, char *argv, char *env)
extern "C" void mainCRTStartup() { main(0,0,0);}

C_WMAIN.CPP:
#include <windows.h>
extern WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int
lpCmdLine,int nCmdShow);
extern "C" void WinMainCRTStartup() { WinMain(GetModuleHandle(NULL
WinMain(GetModuleHandle(NULL),
), NULL,
NULL, GetCommandLine(), SW_SHOW); }

C_ALLOC.CPP:
#include <windows.h>
void *malloc(size_t size) { return HeapAlloc(GetProcessHeap(), NULL,
NULL, size); }
void free(void
free(void *block) { HeapFree(GetProcessHeap(), NULL,
NULL, block); }

Bueno, la mayoria de las cosas las deben entender sin ningún problema, C_STR.CPP tiene dos funciones
muy simples strlen() y strcpy() de la STDLIB. C_MAIN.CPP tiene una función que llama al main del
programa que estemos escribiendo y le pasa como parámetros el argc, argv y env (en este caso solo le
pasamos ceros para no complicarnos). C_WMAIN.CPP llama a WinMain() la instancia anterior del
programa, la línea de comandos y SW_SHOW. Finalmente C_ALLOC.CPP usa la Heap del proceso para
asignar y liberar memoria.

Ahora que tenemos todos los archivos de la CLIB (nuestra libreria para reemplazar la Run Time Library de
VC++) podemos compilarla y linkearla así:

cl /c C_ALLOC.CPP C_MAIN.CPP C_STR.CPP C_WMAIN.CPP


lib /out:CLIB.LIB C_ALLOC.OBJ C_MAIN.OBJ C_STR.OBJ C_WMAIN.OBJ

Esto nos va a generar nuestra clib.lib.


Ahora teniendo el comun.cpp podemos hacer:
LINK COMUN.OBJ /NODEFAULTLIB user32.lib kernel32.lib clib.lib y se va a generar un ejecutable que
nos va mostrar un MessageBox con el número 10. Ocupa 2.560 bytes en mi PC. Si prueban a compilar el
mismo programa con la STDLIB por defecto verán que lo mínimo que consigan serán 14.484 bytes.

En la segunda parte vamos a ver como mejorar nuestra libreria con más rutinas, como por ejemplo
implementar los operadores new y delete, entre otras cosas.

Saludos,
Mariano.
El uso de los Jtextarea al recibir un 'Tab Key'
Por shakka http://mbrenes.blogspot.com

El uso de los JTextArea es muy util emplearlos para que el usuario ingrese una cantidad relativamente grande
de información y/o cuando se require darle un tratamiento especial, como por ejemplo: desplegar texto en
varias líneas.
Sin embargo, debido a estas caracteristicas reacciona distinto ante el evento de captura de pulsación de
teclas(caso concreto: la tecla de tabulación), la cual en ciertos escenarios es necesario cambiar este
comportamiento.
Esto se puede hacer de varias maneras, una es llamando al metodo setFocusTraversalKeys() al cual se le
pasan 2 parámetros : un entero, para el cual utilizamos unas constantes que indican el sentido en que se
transfiere el foco, y en el segundo parámetro indicamos el conjunto de teclas.

Set<AWTKeyStroke> setKeys = new HashSet<AWTKeyStroke>();


/**
* Reciba o pase el foco al dispararse el evento, cual sea pulsada la tecla de tabulacion
*/
setKeys.add
setKeys.add(AWTKeyStroke.
(AWTKeyStroke.getAWTKeyStroke
getAWTKeyStroke(KeyEvent.
(KeyEvent.VK_TAB
VK_TAB,, 0));
/**
* Para esta instancia:
* le indico que reciba el foco (KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS),
* y que lo devuelva (KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS)
* solo para el conjunto de teclas que estableci en setKeys.
*/
txtArea1.setFocusTraversalKeys
txtArea1.setFocusTraversalKeys(KeyboardFocusManager.
(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS
FORWARD_TRAVERSAL_KEYS,, setKeys);
txtArea1.setFocusTraversalKeys
txtArea1.setFocusTraversalKeys(KeyboardFocusManager.
(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS
BACKWARD_TRAVERSAL_KEYS,, setKeys);

Si usamos NetBeans para diseñar la interfaz de usuario, veremos que desde el editor del IDE no podremos
editar el código correspondiente a la inicialización de la instancia, pero evidentemente si lo podemos hacer
cerrando NB y editando el código fuente o bien, sin salir del NB, damos click derecho sobre el control y
vamos a Customize Code.
Code.

Más información: http://www.chuidiang.com


Renombrar archivos en Ruby
Por Blag http://atejada.blogspot.com
Lo bueno de ser programador es que cuando necesitas algo, no tienes que buscarlo, comprarlo o descargarlo...
Puedes programarlo -;)

Eso justamente fue lo que hice -:P Quería tener un renombrador de archivos en batch... Por lo tanto decidí que
lo mejor era hacerlo yo mismo...Tenía por supuesto muchos lenguajes de programación entre los cuales
escoger...Pero últimamente mi amor por Ruby ha regresado, así que esto es lo que hice -:)
$Folder = Array.
Array.new
$Files = Array.
Array.new
$counter = 0
print(
print("Ingrese la carpeta: ") ")
$Dir_Text = gets.
gets.chop!
chop!
print(
print("Ingrese la extension: ") ")
$Ext_Text = gets.
gets.chop!
chop!
$Dir_Text.
$Dir_Text.sub!(
sub!("\\"
"\\",,"\\ \\").
\\").delete
delete!(
!("" ")
")
Dir.
Dir.foreach(
foreach($Dir_Text)
$Dir_Text) {|x| $Folder.
$Folder.push(x)}
push(x)}
for file in $Folder
$long = file.length
file.length - 3
if(file[
if(file[$long
$long,3]
,3] == $Ext_Text)
$Ext_Text)
$Full_File = $Dir_Text + "\\\\" + file
$Files.
$Files.push(
push($Full_File)
$Full_File)
end
end
for file in $Files
$counter += 1
$New_File = $Dir_Text + "\\\\" + $counter. $counter.to_s + "." + $Ext_Text
File.
File.rename(file,
rename(file,$New_File
$New_File))
end
puts "#{$counter} archivos convertidos"

Lo que hace, es simplemente leer una carpeta, tomar los archivos con la extensión que queremos y
renombrarlos numéricamente.

El Array.sort no funciona bien con valores alfanuméricos...

Esto significa que la primera versión de mi programa no funciona -:( Es decir, funciona la primera vez, pero
la segunda por el error en el Array.sort comienza a eliminar archivos... Algo que nadie quiere que pase... A
mi me pasó -:(
En fín...Luego de algunos cambios y varias pruebas, tengo la versión final del programa que ahora si
funciona sin ningún problema -;)

$Folder = Array.
Array.new
$Files = Array.
Array.new
$counter = 0
$count = 0

print(
print("Ingrese la carpeta: ")")
$Dir_Text = gets.
gets.chop!
chop!
print(
print("Ingrese la extension: ") ")
$Ext_Text = gets.
gets.chop!
chop!
$Dir_Text.
$Dir_Text.sub!(
sub!("\\"
"\\",,"\\ \\").
\\").delete
delete!(
!("" ")
")

Dir.
Dir.foreach(
foreach($Dir_Text)
$Dir_Text) {|x| $Folder.
$Folder.push(x)}
push(x)}
for file in $Folder
$long = file.length
file.length - 3
if(file[
if(file[$long
$long,3]
,3] == $Ext_Text)
$Ext_Text)
$Full_File = $Dir_Text + "\\\\" + file
$Files.
$Files.push(
push($Full_File)
$Full_File)
end
end

for file in $Files


$count = 0
for do_fiile in $Files
$len_count = $Files[
$Files[$count].
$count].length
length
$len_counter = $Files[
$Files $counter].length
[ $counter]. length
$last_count = $Files[
$Files[$count].
$count].rindex
rindex(("\\" ) + 1
$len_count -= $last_count
$len_counter -= $last_count
if $Files[
$Files[$count].
$count].slice
slice(($last_count,
$last_count, $len_count).
$len_count).to_i
to_i > $Files[
$Files[$counter ].slice
].slice(($last_count,
$last_count, $len_counter).
$len_counter).to_i
to_i
$aux = $Files[
$Files[$count]
$count]
$Files[
$Files[$count]
$count] = $Files[
$Files[$counter ]
$Files[
$Files[$counter]
$counter] = $aux
end
$count += 1
end
$counter += 1
end
$counter = 0
for file in $Files
$counter += 1
$New_File = $Dir_Text + "\\\\" + $counter.
$counter.to_s + "." + $Ext_Text
File.
File.rename(file,
rename(file,$New_File
$New_File))
end

puts "#{$counter} archivos convertidos"

Ruby es un lenguaje excelente, pero como siempre tiene sus pequeños detalles, que debemos investigar y
probar -:)

Saludos,

Blag.
Fundamentos de los Ataques por Desbordamiento de Buffer
Por m0skit0 http://fr33kk0mpu73r.blogspot.com
Las intrucciones CALL y RET
La instrucción CALL sirve para hacer llamadas a funciones en ensamblador. Veamos el siguiente código de
ejemplo:

0x0804836C -> PUSH EBP


0x0804836D -> MOV ESP,EBP
0x0804836F -> CALL 0x0804829C
0x08048374 -> ADD 0x10,ESP
0x10,ESP

En la dirección 0x0804836F tenemos una llamada a una función, que comienza en 0x0804829C, mediante la
instrucción CALL. Lo primero que va a hacer CALL es meter en la pila la dirección de la siguiente
instrucción, o dirección de retorno.
retorno. Suponiendo que ESP = 0x09000000 primero le restamos 4,
0x08FFFFFC, y metemos en la pila los 4 bytes de la dirección donde se encuentra ADD 0x10,ESP. La pila
quedaría tal que así:

0x09000000 XX <-- El byte más bajo de EBP (PUSH


(PUSH EBP)
0x08FFFFFF 08
0x08FFFFFE 04
0x08FFFFFD 83
0x08FFFFFC 74
0x08FFFFFB ??

Acto seguido, CALL pone en el registro EIP (Extended Instruction Pointer), que es el encargado de apuntar a
la siguiente instrucción a ejecutar, la dirección de la función, es decir, 0x0804829C. Con esto ya se
comienzan a ejecutar las instrucciones de la función. Supongamos ahora que la función consta del siguiente
código:

0x0804829C -> MOV EAX,EBX


0x0804829E -> RET

La instrucción RET (RETurn) realiza la operación contraria a CALL, es decir, devuelve el flujo del programa
donde estaba antes de la llamada a la función. Primero saca de la pila 4 bytes, los pone en EIP y luego suma 4
a ESP. Así que la siguiente instrucción en ejecutarse después de RET es aquélla cuya dirección se encuentre
en la cima de la pila antes de ejecutarse RET. En nuestro caso, RET extrae de la pila (ESP = 0x08FFFFFC) el
valor 0x08048374, lo pone en EIP y suma 4 a ESP. Así que la siguiente instrucción en ser ejecutada después
de RET (dirección 0x0804829E) es ADD 0x10,ESP (dirección 0x08048374).
¿Qué pasaría entonces si ejecutásemos el siguiente código?

0x08000000 -> PUSH 0x08000000


0x08000005 -> RET

Pues que entraríamos en un bucle infinito. ¿Por qué? Supongamos que antes de ejecutar nada,
ESP=0x09000000 y EIP = 0x08000000. Al ejecutar la instrucción apuntada por EIP, PUSH 0x08000000,
metemos en la pila el valor 0x08000000. Después, al ejecutar RET, esta instrucción saca el valor que haya en
la pila (0x08000000) y lo copia a EIP. Así la siguiente instrucción que pasaría a ejecutarse sería la ubicada en
la dirección 0x08000000, es decir, PUSH 0x08000000, y de vuelta al principio.
¿Qué sonsacamos de esto? Pues que podemos hacer que el flujo de un programa cambie al modificar la
dirección de retorno almacenada en la pila. Éste es uno de los fundamentos de los ataques por
desbordamiento de buffer.

El paso de parámetros por pila
Generalmente, al llamar a funciones también queremos pasarles unos ciertos valores para que trabajen con
ellos, lo que llamamos parámetros.
parámetros. El convenio más utilizado es el paso de parámetros por pila. pila. Los
parámetros en la pila se pasan en orden inverso a como los recoge la función (¡recordemos el funcionamiento
de la pila!).
Supongamos por ejemplo que tenemos una función que realiza alguna operación con dos números enteros,
cuya entrada se encuentra en la dirección 0x07000000. Para pasarle por pila los números 10 (A en
hexadecimal) y 20 (14 en hexadecimal) como primer y segundo parámetro respectivamente, necesitaríamos el
siguiente código:

0x08000000 -> PUSH 20 (Segundo parámetro)


0x08000005 -> PUSH 10 (Primer parámetro)
0x0800000A -> CALL 0x07000000
0x0800000F -> MOV EAX, EBX

Después de la llamada CALL, la pila quedaría como sigue (si consideramos inicialmente ESP=0x09000000):

0x09000000 -> ??
0x08FFFFFF -> 00
0x08FFFFFE -> 00
0x08FFFFFD -> 00
0x08FFFFFC -> 14 <-- Segundo parámetro (PUSH 20)
0x08FFFFFB -> 00
0x08FFFFFA -> 00
0x08FFFFF9 -> 00
0x08FFFFF8 -> 0A <-- Primer parámetro (PUSH 10)
0x08FFFFF7 -> 08
0x08FFFFF6 -> 00
0x08FFFFF5 -> 00
0x08FFFFF4 -> 0F <-- Dirección de retorno de CALL

con ESP = 0x08FFFFF4 y EIP = 0x07000000. La función entrante en 0x07000000 se encuentra pues que
tiene el primer parámetro en ESP+4 y el segundo en ESP+8 (y sucesivamente de 4 en 4 si son varios
parámetros). Así pues el código

0x07000000 -> ADD 0x4,


0x4, ESP
0x07000003 -> POP EAX
0x07000004 -> POP EBX

pone el primer parámetro (0x0000000A) en EAX y el segundo (0x00000014) en EBX, quedando


ESP=0x09000000. Por lo tanto, antes de poder ejecutar la instrucción RET para retornar de la función,
tendremos que devolver ESP a su valor original para que pueda extraer la dirección de retorno adecuada:

SUB 0xC,
0xC, ESP
RET

Restamos 12 (C en hexadecimal), 2 x 4 bytes por cada parámetro + 4 bytes de la dirección de retorno, 12


bytes en total, a ESP = 0x09000000 para convertirlo en 0x08FFFFF4, donde se encuentra la dirección de
retorno correcta (0x0800000F). Acto seguido RET saca de la pila 0x0800000F y pone este valor en EIP, con
lo que la ejecución continúa en dicha dirección con la instrucción MOV EAX,EBX, con ESP = 0x08FFFFF8.
FrankGK es un recien iniciado en este mundo de la programación, se le ve el interes pues lo he visto
preguntado por JAVA, Visual Basic, C e incluso hasta ASM; se ha entrenado mucho en BATCH, incluso
tenemos un manual de él aca en Código Latino y se está volviendo un experto, ha demostrado sus habilidades
en el foro de TrucosWindows este pedazo de entrevista nos ha regalado este Newbie de la programación.

1) ¿De dónde eres? página del congreso y no sé que pusieron, de todas


España, Madrid formas opino que más ayudas al sector de la
informatica (por lo menos aquí en España lo estan
2) ¿Hace cuánto que comenzaste a programar? diciendo a voces).
Este año, en el mes de Junio
8) ¿Cuáles son tus nuevos proyectos?
3) ¿Cuáles son tus lenguajes de programaciónHe de empezar poco a poco y estoy dandome caña con
favoritos? C, me gusta el tema de los algóritmos y en C estoy
VB, C & BATCH (no sé si cuenta BATCH) empezando a hacerlos. En VB me queda tanto o más
por aprender como en C, pero sé hacer cosillas
4) ¿Cuáles son tus programas favoritos de Diseño?
¿Diseño grafico?, no manejo mucho, el photoshop y el9) ¿Que te gustaría ver en los próximos años en el
paint ocasionalmente xD mundo de la programación?
Que comercializen ordenadores más baratos, mejores,
5) ¿Qué te inspiró a ser programador? y respecto a la informática quiero ver como avanza
Pensar que hay detras de las ventanas, ytodo lo relacionado con el tema cuántico, ya q me
posteriormente TrucosWindows.net llama bastante la atención..

6) ¿Cuéntanos un poco acerca de tu compañía? 10) ¿Cuál es tu mensaje final para la comunidad?
Sorry no sé q te refieres, no tengo ninguna empresa :P Sigan así, hay muy buena gente (y bastante
inteligente), ojala en un tiempo podamos hacer
7) ¿Qué opinas de la escena de programadores enconcursos (me refiero a programación), y llegar a
crear buenas ideas, luego plasmarlas en algunos
Latinoamérica?
proyectos.
Por lo que se allí hay muy buenos programadores, creo
recordar que hace 1 mes o 2 como mucho hackearon la

un saludo
PowerShell
Por JuanK http://juank.black-byte.com
Parte I - El futuro del scripting
Como logro automatizar mis labores administrativas? Quiero ser más eficiente? esa es la pregunta que a
diario tienen muchos administradores de red y personal de IT en general, pueden existir muchas opciones:
• Desarrollos personalizados
• Aplicaciones de terceros
• Automatización por medio de scripts
Como es de suponerce este tipo de demandas suelen ser imposibles sobre todo dentro del tiempo requerido
o con un presupuesto ajustado. Entonces cual es la respuesta a esa pregunta?: PowerShell.
Antes de entrar en materia revisemos unos conceptos importante.

Qué es un script?
Un script es un conjunto de instrucciones utilizadas para automatizar un conjunto de tareas.
Funciona como el guión de una película, donde se describen paso a paso las diferentes acciones que un actor
debe efectuar. En nuestro caso el actor el sistema operativo y el guionista es quien hace el script.

Qué es un shell?
Un shell es una pieza de software que provee una interfaz de uso, desde el punto de vista de la computación
se puede definir en varios niveles.
Un componente que provee acceso al kernel (núcleo) del sistema operativo, en el caso de los desarrolladores
esa interfaz puede ser Shell32.dll , User32.dll y otras.
Desde el punto de vista de los usuarios el Shell pueden ser el sistema de ventanas de Windows o una consola
de símbolo de Sistema.
PowerShell, es un shell que brinda una interfaz robusta para que el usuario IT realice tareas de administración
dentro del sistema.
Evolución de los Shell

Sistemas operativos de la familia UNIX desde su comienzo han tenido un shell de consola de comandos
robusto, en contraste Windows siempre se caracterizo por tener falencia en ese sentido debido a que, desde
luego, no era algo importante en sus primeras versiones pues la prioridad siempre era brindar una interfaz de
usuario(shell) amistosa, mientras que en UNIX esa casí siempre (hasta hace relativamente poco)ha sido una
debilidad.
Con el paso del tiempo los sistemas operativos de la familia de windows fueron fortaleciendose y su
incursión en la rama empresarial y de IT fue cada vez más notoria lo cual fue volviendo las labores de
administración un tema cada vez más complejo y extenso. Para cubrir esas necesidades Windows cada vez
incorporo más herramientas de línea de comandos, no solo fortaleciendo su clásica interfaz del símbolo del
sistema (conocida vulgarmente como ventana del DOS) sino además incluyendo nuevos shell para ejecutar
script, sin embargo algunos de estos shell realmente eran más las vulnerabilidades que abrían en el sistema
que la utilidad que se les lograba sacar, con el tiempo estos shell se fueron fortaleciendo y surgieron muchos
nuevos principalmente orientados a realizar tareas usando wmi (Windows Management Instrumentation)
combinado con scripts de tipo VBScript y javascript.
Si bien el ambiente de script cada vez era más diverso y extendido, hacia falta algo fundamental: Integración,
interoperabilidad y flexibilidad.
Así que para cubrir esta nueva necesidad surgió El proyecto Monad el cual más adelante se llamaría:
PowerShell 1.0. y hoy día ya estamos ad portas de la versión 2.0.
Parte II - Arquitectura
Modelo Básico

Powershell se compone de 4 elementos fundamentales:


• .Net FrameWork
• Sistema operativo (Windows XP / Vista / Server 2003 / Server 2008)
• CommandLet s (Cmdlet s), Data Providers
• PowerShell Host
Desde el punto de vista de desarrollo El .NEt Framework aporta el soporte para CLR 2.0 y junto con el todos
los beneficios de el desarrollo sobre esta platáforma.

El sistema operativo desde luego provee a PowerShell de las API s necesarias para interactuar con las
características del sistema como: archivos, registro, dispositivo, usuarios etc.
Los Cmdlet s, como veremos más adelante, son una parte fundamental de PowerShell que esencialmente
brindan una interfaz unificada de programación para hacer uso de las características de scripting a través del
pipeline processor.

Finalmente encontramos el PowerShell Host, por defecto es una consola de comandos de texto, pero no es
una restricción, en los últimos capítulos que traten el tema de PowerShell veremos como podemos hostear
tanto la interfaz de entrada de scripts, como la interfaz de resultados en aplicaciones independientes con
interfaces gráficas Web o de aplicaciones de windows.
Modelo Funcional
El gráfico se debe revisar de abajo hacia arriba, en un primer nivel tenemos al sistema operativo, quien brinda
las API s necesarias para la ejecución e interacción de PowerShell, sobre el sistema operativo tenemos el
CLR que en adelante brinda sus servicios a PowerShell, estos servicios son un entorno de ejecución con
administración de memoria, aislamiento de dominios de aplicación, etc.
Sin embargo para que el CLR sea realmente útil se requiere una seríe de interfaces de adquisición de datos:
los PowerShell Providers. Estos Providers se encargan de envíar a los diferentes CmdLets instalados en
PowerShell la información solicitada, es decir son fuentes de datos que bien pueden devolver un conjunto de
llaves de registro, un listado de archivos, registros de un base de datos, los procesos en ejecución etc etc.
Una vez los datos son accedidos por los Providers esos envían o reciben información de los CmdLet s, un
CmdLet por si solo solo puede realizar un conjunto de tareas limitado, por ejemplo consultar los procesos en
ejecución, y otro CmdLet puede por ejemplo ordenar un arreglo según un criterio de ordenamiento. El
verdadero poder de los CmdLet esta en la capacidad que tienen para hacer que el resultado de uno de ellos
sirva como fuente de datos a otro CmdLet y a su vez el resultado de este CmdLet sirva como entrada a otro
más& y así puede funcionar de manera ilimitada, dicha interacción entre CmdLet s se lleva a acabo gracias a
otra parte fundamental de PowerShell : El Pipeline Processor.
El PipeLine Processor tiene una función sencilla, pero crítica para que la magia comience a surtir efecto, es el
encargado de hacer que la información fluya entre CmdLet s, el que recibe los datos de entrada desde el host
de comandos y el que envía el resultado final al host de salida. El PipeLine Processor es el hilo conductor que
hace que muchos componentes logren ser PowerShell .
En el gráfico podemos observar como en el nivel más superior se encuentran los comandos, cada comando se
separa de otro a través de un | (un pipe) este pipe representa el Pipeline Processor por lo cual podemos
visualizar como cada un comando envía su información al pipeline y este redirecciona su salida al comando
siguiente y así sucesivamete hasta que tras el último comando envía el resultado final al host de salida.
Parte III PowerShell para IT's
En las dos anteriores entregas nos hemos dedicado al sustento teórico y al background necesario para saber
de que estábamos hablando. Ya falta poco para comenzar, pero antes una información importante para seguir
adelante.

Instalar PowerShell
Requerimientos
• Net Framework 2.0
• Windows XP SP2 +, Windows Vista, Windows Server 2003 SP1+, Windows Server 2008
Una vez ya tengas esto debes bajarte la versión de PowerShell de tu preferencia:
Link de descarga

Integración de tecnologías de automatización


Este es el primero de dos puntos clave que PowerShell brinda a los IT s y es que por primera vez despues de
muchos años existe una tecnología de script capaz de integrar todas las tecnologías de script existentes bajo
Windows en una sola, pero esto solo es la parte de agrupar tecnologías de script, pero que tal poder acceder
por medio de scripts a toda la infraestructura desde un punto central? bueno el dibujo habla por si solo:

PowerShell nos permite interactuar con cada uno de los componentes de nuestra infraestructura de red, ISA
Server, Exchange System Center, Active Directory y muchos más, pero por si fuera poco tenemos (sobre todo
para desarrolladores pero le impacta a los IT s) .NET Framework, es decir tenemos las puertas abiertas a
hacer lo que queramos, el framework nos lo permite.

Beneficios para crear scripts


Tanto para developers como para IT s estas características son muy importantes, sere breve:

Bueno ya fue suficiente. Recuerden que esto no es un curso de PowerShell, es un overview donde se
mostraran algunas cosas interesantes de manera general.
Let s begin!!!

Primeros scripts
Nivel de seguridad
PowerShell posee niveles de seguridad en cuanto a la ejecución de script así que nuestro primer script
establecera un nivel de seguridad adecuado para los demos. Los posibles valores son:
• Unrestricted : todo script es permitido
• RemoteSigned : todo script local es permitido, pero si son remotos deben estar firmados digitalmente
• AllSigned : todo script debe estar firmado digitalmente
Se debe ejecutar este comando como administrador o en Windows Vista inicializando la aplicaion con
elevación de privilegios.
Set-ExecutionPolicy RemoteSigned
1- Nombre de los procesos que tienen ventana con nombre no vacío

get-process | where-object{$_.MainWindowTitle
where-object{$_.MainWindowTitle -ne ""}
Aquí podemos observar el pipe | que redirecciona la salida de get-process a where-object, dentro de where
object ({}) utilizamos $_ para representar a cada uno de los objetos que devuelve el comando anterior (en
este caso get-process) lo cual quiere decir que verificamos los objetos donde el atributo MainWindowTitle no
sea igual (-ne
(-ne =not
=not equal) a vacío.
La salida arrojara algo parecido a esto:

Handles NMP(K) PM(K) WX(K) VM(M) CPU(s) Id ProcessName


448 37 70908 85920 287 832,44 5964 Dreamweaver
302 26 64152 73592 181 36,07 5808 Firefox
642 62 112576 128432 415 28,88 5616 Fireworks
638 40 65780 66892 239 25,18 5720 iexplor
796 74 41960 23080 234 40,39 4196 msnmsgr
783 81 59944 25084 353 31,26 2880 POWERPNT
283 14 56836 47896 562 0,67 1256 powershell

2- Procesos que comienzan por letras y tienen números, este es aparentemente más complejo, pero es
realmente básico la parte compleja son las expresiones regulares ("^[a-z]+[^0-9]+$") pero basicámente es
solo un patrón de busqueda.

get-process | where-object{$_.Name
where-object{$_.Name -math "^[a-z]+[-9]+$"}
"^[a-z]+[-9]+$"}

La salida

Handles NMP(K) PM(K) WX(K) VM(M) CPU(s) Id ProcessName


61 5 1988 4532 52 0,02 2164 MSCamS64
42 6 3984 6140 79 0,05 4152 rundll32
93 8 5200 8088 83 0,05 4432 rundll32
75 5 2184 4984 54 0,09 3964 splwow64
Prueben esta variante, es muy parecida pero hace lo contrario, trae procesos que comiencen por letras y que
no tengan números.

get-process | where-object{$_.Name
where-object{$_.Name -math "^[a-z]+[^0-9]+$"}
"^[a-z]+[^0-9]+$"}
3- Generar la salida filtrada y direccionarla luego en un archivo html y luego adicionarle un estilo. Vamos a
ponerle más detallitos, tal ves se les complique para algunos IT s pero para otros& . será genial, debemos
crear un archivo de texto con este contenido:
<style>
.fila_par
.fila_par
{ background-color:
background-color:#FFFFCC;}
#FFFFCC;}
.fila_impar
.fila_impar {background-color
{background-color:
:#CCFFFF;}
#CCFFFF;}
</style>

<script type="text/javascript"
type="text/javascript"> >
<!--
function AplicarCebra ()
{
tables = document.getElementsByTagName
document.getElementsByTagName(("table");
"table");
for ( i = 0; i < tables.length
tables.length;; i++)
{
ColoreaFilas(tables[i]);
}
}

function ColoreaFilas(tabla)
{
filasTabla = tabla.rows
tabla.rows;;
for(j=0;
for(j=0; j < filasTabla.length
filasTabla.length;; j++)
{
if(j%2==0)
if(j%2==0)
{
filasTabla[j].className
filasTabla[j].className=="fila_par";
"fila_par";
}else
} else
{
filasTabla[j].className
filasTabla[j].className=="fila_impar";
"fila_impar";
}
}
}
// -->
</script>
<body onload=
onload="AplicarCebra();"/>
"AplicarCebra();"/>

Guardemos esto en un archivo de texto llamado EstiloYScript.txt, básicamente hemos creado una pequeña
hoja de éstilos, y algunas funciones útiles de jscript, al final hemos invocado uno de los script desde el
body& por el momento no se fijen en lo que hace eso sino lo entienden& ese no es el tema, conformense
con saber que es para crear una tabla en una página Web y hacer que quede coloreada automáticamente.
Ahora desde la consola de PowerShell nos vamos a la carpeta donde guardamos el archivo (sí& se hace igual
que en una consola DOS, recuerden que PowerShell extiende las funcionalidades de los antiguos bat). Ahora
vamos a aprender varias cosas:
Acá vemos como definir una variable ( head, para definirla se le pone $), y también vemos como leer un
archivo y asignar sus contenidos a la variable:

$head = get-content "EstiloYScript.txt"

Ahora veamos el siguiente comando, nos permite no solo seleccionar la lista de procesos sino traer
únicamente la información que deseamos. Estamos buscando los procesos que comiencen por r. Atención al
comando select.

get-process |
where-object{
where-object{ $_.Name -like "r*"}
"r*"} |
select-object id, processname, handles

La salida:

Id ProcessName Handles
2556 rosetta_beta_5.96_windows_intelx86 52
3740 rosetta_beta_5.96_windows_intelx86 53
2520 Rtvscan 594
4152 rundll32 42
4432 rundll32 93

Espero que les este gustando, ahora veamos como redireccionar la salida en formato html

get-process |
where-object{
where-object{ $_.Name -like "r*"}
"r*"} |
select-object id, processname, handles |
convertto-html
La salida html:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
html>
<head
<head> >
<title
<title>HTML
>HTML TABLE</title
TABLE</title> >
</head
</head> >
<body>
body>
<table
<table>>
<colgroup
<colgroup> >
<col
<col><
><col
col><
><col
col>>
</colgroup
</colgroup> >
<tr
<tr><
><th
th>Id</
>Id</th
th><
><thth>ProcessName</
>ProcessName</th th><
><th
th>Handles</
>Handles</th
th></
></tr
tr>
>
<tr
<tr><
><td
td>2556</
>2556</td td><
><td
td>rosetta_beta_5.96_windows_intelx86</
>rosetta_beta_5.96_windows_intelx86</td td><
><td
td>52</
>52</td
td></
></tr
tr>
>
<tr
<tr><
><td
td>5776</
>5776</tdtd><
><td
td>rosetta_beta_5.96_windows_intelx86</
>rosetta_beta_5.96_windows_intelx86</td td><
><td
td>53</
>53</td
td></
></tr
tr>>
<tr
<tr><
><td
td>2520</
>2520</td td><
><td
td>Rtvscan</
>Rtvscan</td
td><
><td
td>594</
>594</td
td></
></tr
tr>
>
<tr
<tr><
><td
td>4152</
>4152</tdtd><
><td
td>rundll32</
>rundll32</td
td><
><td
td>42</
>42</td
td></
></tr
tr>
>
<tr
<tr><
><td
td>4432</
>4432</td td><
><td
td>rundll32</
>rundll32</td
td><
><td
td>93</
>93</td
td></
></tr
tr>
>
</table
</table>>
</body
</body>>
</html
</html>>

Como direccionarla a un archivo de texto? se puede pasándole por pipe al comando out-file, o bien como en
los antiguos bat con el operador > o >>:
get-process |
where-object{
where-object{ $_.Name -like "r*"}
"r*"} |
select-object id, processname, handles |
convertto-html > htmlFile.html

Este archivo ya es legible y lo podemos abrir desde el browser, recuerdan el estilo y script que cargamos antes
en la variable $head? es momento de usarlo, adicionemosle algo de sabor al html generado:

get-process |
where-object{
where-object{ $_.Name -like "r*"}
"r*"} |
select-object id, processname, handles |
convertto-html -head $head > htmlFile.html

Y al abrirlo desde el explorador& revísenlo uds mismos.


4- Matar un proceso recurriendo a Windows Management Instrumentation (WMI), para este ejemplo lo
primero que debemos hacer es abrir un bloc de notas. Luego anotar esto en la consola:

$a = get-wmiobject win32_process |
where-object {$_.name -eq "notepad.exe"}
"notepad.exe"}
$a.terminate()
$a.terminate()

5- Consultar el consumo de CPU de un proceso recurriendo a Windows Management Instrumentation


(WMI), la salida es formateada con el comando fotmat-table para pesonalizar los labels, y se usa el comando
select para determinar que datos serán procesados en la salida.

get-wmiobject Win32_PerfFormattedData_PerfProc_Process |
select-object name, PercentProcessorTime |
where-object { $_.Name -eq "powershell"}
"powershell"} |
format-table @{Label="Nombre
{Label="Nombre del proceso";
proceso"; Expression={$_.name}},
@{Label="Tiempo
{Label= "Tiempo de CPU";
CPU" ; Expression={$_.PercentProcessorTime}} -auto

La salida&
Nombre del Proceso Tiempo de CPU
------------------ -------------
powershell 0

6- Sentencias de control de flujo, ya a estas alturas lo único por explicar es que es que es write-host &
escribir en el host , en este caso la consola y throw es para envíar una excepción en un programa.

$a = "white"
if ($a -eq "red")
"red")
{"The
{"The color is red."}
red."}
elseif ($a -eq "white")
"white")
{"The
{"The color is white."}
white."}
else
{"The
{"The color is blue."}
blue."}

Ejecutenlo& creo que es claro. Hagan pruebas cambiando el valor de la variable $a para que vean como
cambia el flujo de las instrucciones.
7- Definir funciones, es un ejemplo muy similar al anterior, pero se añaden algunos modificadores a write-
host para cambiar los colores de fondo y de fuente.

function ElColor($color
ElColor($color))
{
"El color es:"
if ($color
($color -eq "amarillo")
"amarillo")
{ write-host "amarillo" -foregroundcolor "yellow" }
elseif ($color -eq "azul")
"azul")
{ write-host "azul" -foregroundcolor "blue" -backgroundcolor "white"}
"white"}
elseif ($color -eq "rojo")
"rojo")
{ write-host "rojo" -foregroundcolor "red"}
"red"}
else
{ throw "No reconozco ese color"}
color"}
}

Con lo anterior hemos creado la función, ahora probemosla


ElColor( amarillo );
El color es: amarillo

ElColor( azul );
El color es:azul
es:azul

ElColor( rojo );
El color es:rojo
es:rojo
ElColor( xxx );
No reconozco ese color
En línea:11 carácter:10
+ { throw <<<< "No reconozco ese color"}

8- Switches de funciones, ahora rescribamos la función de esta forma:

function ElColor($color
ElColor($color,, [switch
[switch]] $comoWarning)
$comoWarning)
{
if(
if($comoWarning)
$comoWarning)
{ write-warning "El color es: " }
else
{ "El color es: " }
if ($color
($color -eq "amarillo")
"amarillo")
{ write-host "amarillo" -foregroundcolor "yellow" }
elseif ($color -eq "azul")
"azul")
{ write-host "azul" -foregroundcolor "blue" -backgroundcolor "white"}
"white"}
elseif ($color -eq "rojo")
"rojo")
{ write-host "rojo" -foregroundcolor "red"}
"red"}
else
{ throw "No reconozco ese color"}
color"}
}

La función ahora recibe un parámetro de tipo switch, el cual luego es verificado para determinar si el mensaje
se muestra o no a manera de advertencia, la salida y el uso sería igual al ejemplo anterior desde que no se use
el switch. Para usar el switch se debe hacer de la siguiente forma:

ElColor( azul ) -comoWarning


ADVERTENCIA: El color es:
azul

Bien eso es todo, como verán aunque esto es PowerShell para IT s hubo bastante desarrollo, sin embargo lo
que tengo preparado para los developers es aún mejor, que tal en vez de solamente usar PowerShell&
extenderlo? o hacer que su salida no sea una consola sino una aplicación propia? o hacer que los comandos
no se digiten en una consola sino desde una página Web u otra aplicación?& pues de eso tratara la próxima
entrega.
Historia de Python http://es.wikipedia.org
Python fue creado a finales de los ochenta por Guido van Rossum en CWI en los Países Bajos como un
sucesor del lenguaje de programación ABC,ABC, capaz de manejar excepciones e interactuar con el sistema
operativo Amoeba .
Van Rossum es el principal autor de Python, y su continuo rol central en decidir la dirección de Python es
reconocido, refiriéndose a él como Benevolente dictador vitalicio o Benevolent Dictator for Life (BDFL).
En 1991, van Rossum publicó el código (versión 0.9.0) en alt.sources.
alt.sources. En esta etapa del desarrollo ya estaban
presentes clases con herencia, manejo de excepciones, funciones, y los tipos modulares: list,list, dict,
dict, str y así
sucesivamente. Además en este lanzamiento inicial aparecía un sistema de módulos adoptado de Modula-3;Modula-3;
van Rossum describe el módulo como "uno de las mayores unidades de programación de Python". El modelo
de excepciones en Python es parecido al de Modula-3, con la adición de una cláusula else . En el año 1994 se
formó comp.lang.python,
comp.lang.python, el foro de discusión principal de Python, marcando un hito en el crecimiento del
grupo de usuarios de este lenguaje.
Python alcanzó la versión 1.0 en enero de 1994. Una característica de este lanzamiento fueron las
herramientas de la programación funcional:
funcional: lambda,
lambda, map,
map, filter y reduce.
reduce. Van Rossum explicó que "Hace 12
años, Python adquirió lambda, reduce(), filter() and map(), cortesía de un hacker de Lisp que las extrañaba y
que envió parches." El donante fue Amrit Prem;
Prem; no se hace ninguna mención específica de cualquier herencia
de Lisp en las notas de lanzamiento.
La última versión liberada proveniente de CWI fue Python 1.2. En 1995, van Rossum continuó su trabajo en
Python en la Corporation for National Research Initiatives (CNRI) en Reston, Virginia donde lanzó varias
versiones del software.
software.
Durante su estancia en CNRI, van Rossum lanzó la iniciativa Computer Programming for Everybody (CP4E),
con el fin de hacer la programación más accesible a más gente, con un nivel de 'alfabetización' básico en
lenguajes de programación, similar a la alfabetización básica en inglés y habilidades matemáticas necesarias
por muchos trabajadores. Python tuvo un papel crucial en este proceso: debido a su orientación hacia una
sintaxis limpia, ya era idóneo, y las metas de CP4E presentaban similitudes con su predecesor, ABC. El
proyecto fue patrocinado por DARPA.
DARPA. En el año 2007, el proyecto CP4E está inactivo, y mientras Python
intenta ser fácil de aprender y no muy arcano en su sintaxis y semántica, alcanzando a los no-programadores,
no es una preocupación activa.
En el año 2000, el principal equipo de desarrolladores de Python se cambió a BeOpen.com para formar el
equipo BeOpen PythonLabs.
PythonLabs. CNRI pidió que la versión 1.6 fuera pública, continuando su desarrollo hasta
que el equipo de desarrollo abandonó CNRI; su programa de lanzamiento y el de la versión 2.0 tenían una
significativa cantidad de translapo. Python 2.0 fue el primer y único lanzamiento de BeOpen.com. Después
que Python 2.0 fuera publicado por BeOpen.com, Guido van Rossum y los otros desarrolladores PythonLabs
se unieron en Digital Creations.
Creations.
Python 2.0 tomó una característica mayor del lenguaje de programación funcional Haskell: Haskell: list
comprehensions.
comprehensions. La sintaxis de Python para esta construcción es muy similar a la de Haskell, salvo por la
preferencia de los caracteres de puntuación en Haskell, y la preferencia de Python por palabras claves
alfabéticas. Python 2.0 introdujo además un sistema de recolección de basura capaz de recolectar referencias
cíclicas.
Posterior a este doble lanzamiento, y después que van Rossum dejó CNRI para trabajar con desarrolladores
de software comercial, quedó claro que la opción de usar Python con software disponible bajo GPL era muy
deseable. La licencia usada entonces, la Python License,
License, incluía una cláusula estipulando que la licencia
estaba gobernada por el estado de Virginia por lo que, bajo la óptica de los abogados de Free Software
Foundation (FSF), se hacía incompatible con GNU GPL. GPL. CNRI y FSF se relacionaron para cambiar la
licencia de software libre de Python para hacerla compatible con GPL. En el año 2001, van Rossum fue
premiado con FSF Award for the Advancement of Free Software.
Software.
Python 1.6.1 es esencialmente el mismo que Python 1.6, con unos pocos arreglos de bugs, bugs, y con una nueva
licencia compatible con GPL.
Python 2.1 fue un trabajo derivado de Python 1.6.1, así como también de Python 2.0. Su licencia fue
renombrada: Python Software Foundation License. License. Todo el código, documentación y especificaciones
añadidas, desde la fecha del lanzamiento de la versión alfa de Python 2.1, tiene como dueño a Python
Software Foundation (PSF), una organización sin ánimo de lucro fundada en el año 2001, tomando como
modelo la Apache Software Foundation.
Foundation. Incluido en este lanzamiento fue una implementación del scoping
más parecida a las reglas de static scoping (del cual Scheme es el originador).
Una innovación mayor en Python 2.2 fue la unificación de los tipos en Python (tipos escritos en C), y clases
(tipos escritos en Python) dentro de una jerarquía. Esa unificación logró un modelo de objetos de Python
puro y consistente. También fueron agregados los generadores que fueron inspirados por el lenguaje Icon.
Icon.
Las adiciones a la biblioteca estándar de Python y las decisiones sintácticas fueron influenciadas fuertemente
por Java en algunos casos: el package logging,
logging, introducido en la versión 2.3, el parser SAX,
SAX, introducido en
2.0, y la sintaxis del patrón decorator que usa el @, agregado en la versión 2.4
En febrero de 2008, la última versión de producción de Python es la 2.5.2
Tutorial BATCH
Por FranGK
Buenas, pues este es un tutorial sobre batch, que considero de nivel fácil/intermedio, veremos como crear
programas que nos sean útiles para el día a día.

Empezaremos por lo básico, un archivo bat es editado desde un editor de texto plano, es decir el bloc de notas
por ejemplo.

Vamos a utilizar en este primer ejemplo los siguientes comandos:


-Title
-Echo
-Set
-Pause
-Exit
Title : sirve para establecer el titulo de nuestro batch, el nombre que aparecerá en la ventana.
Echo : veremos varias formas de su uso, @echo off hará que se desactiven las líneas del comando echo
(mas adelante veremos la diferencia entre (ON/OFF).
Si queremos saltar una línea se usa echo. .
Para que una frase escrita salga en la ventana se usa echo hola , si contiene espacios poner el contenido entre
comillas dobles ( ).
Bien, el comando Set sirve para crear, modificar o visualizar variables.
Si abrimos CMD y escribimos set veremos las variables de entorno que están en uso actualmente.
Todos los comandos (o casí todos) tienen la opción de usar modificadores, los cuales indican al comando en
concreto una acción a realizar:
Set /p variable se utiliza para que lo que escriba el usuario sea guardado en variable , si la queremos
mostrar en pantalla debemos de escribir el nombre de la variable entre %%, aquí va un ejemplo:

@echo off
title Mi programa
set /p variable=Dime
variable=Dime tu nombre:
echo.
echo.
echo Tu nombre es %variable
%variable%,
%, bienvenido a la programacion batch.
echo.
echo.
pause
exit
Guardarlo en un archivo con extensión .bat y ejecutarlo.

Para ver la diferencia entre [on/off], ponerle on, guardarlo y volver a ejecutarlo (@echo on).
:O, que diferencia!

El comando pause simplemente hace una pausa, y exit sale de cmd.exe (cmd.exe interpreta los códigos de
nuestros .bat, haciendo que sea posible su uso).

Hemos visto 5 comandos (de los cuales usaremos siempre 4 ó seguramente los 5).
Sabemos que Set /p variable guarda lo que escriba el usuario, ya sean números o letras, pero ¿y si queremos
hacer una suma?
Set /a permite realizar operaciones aritméticas (suma, resta& ).
Hacemos una pequeña modificación en el código anterior:

@echo off
title Suma de dos números
set /p a=Dime un número:
echo.
echo.
set /p b=Dime un número:
echo.
echo.
set /a suma=%
suma=%aa%+%b
%+%b%
echo La suma de %a
%a% y %b
%b% es %suma
%suma%
%
echo.
echo .
Pause
Quedaría asi, excepto por los números :P :

Esto si nos sumará dos números y hacer que en vez de sumar haga una resta seria muy sencillo, sustituye el
símbolo + por - y así sucesivamente.

Crear un archivo llamado datos.txt y copiar el contenido de este manual.


Desde un batch podemos leer archivos de texto, y para ello usamos el comando type .
Su sintaxis no es difícil Type RutaDelArchivo , pero ¿y si el archivo es muy largo? Pues no podríamos leerlo
desde la ventana de ms-dos y para poder hacerlo usaremos también el comando more .
El comando more hace una pausa cada vez que la pantalla de ms-dos se llena para hacer su lectura más
fácil (y muchas veces simplemente la hace posible), presionando enter bajará línea por línea y presionando
espacio rellenará la ventana de nuevo .
Crear un nuevo bat y escribir el siguiente código:

@echo off
title Leer archivos de texto
type datos.txt | more
pause
exit
Por si hay dudas el carácter | se obtiene pulsando Alt Gr y 1.

Bueno hemos visto varios comandos y toca ver más xD, estos también son muy comunes:
-Cls
-Color
-Start
-If
-Goto
-etíquetas (esto no es un comando)
-Cd
El comando cls limpia la pantalla.
El comando color como su nombre indica sirve para poner color de fondo a la pantalla y al texto:

0 = Negro 8 = Gris
1 = Azul 9 = Azul claro
2 = Verde A = Verde claro
3 = Aguamarina B = Aguamarina claro
4 = Rojo C = Rojo claro
5 = Púrpura D = Púrpura claro
6 = Amarillo E = Amarillo claro
7 = Blanco F = Blanco brillante
Da igual como lo pongáis, por ejemplo color 1f , siempre y cuando no pongas el mismo dos veces ( color
ff ó color 44 ) en ese caso no se cambiara el color y se quedará default.
Con el comando start puedes ejecutar archivos o inicializar ventanas (abrirlas), más adelante si usamos
start más afondo veremos más opciones.
Los If son sencillos de usar y muy prácticos, un if es un proceso condicional, como en cualquier lenguaje
(C, VB& ) vamos a ver unos ejemplos:

:menu
cls
Set /p MiVariable=Dime
MiVariable=Dime la palabra clave:
If %MiVariable
%MiVariable%==hola
%==hola goto BuenosDias
If %MiVariable
%MiVariable%==%
%==%MiVariable
MiVariable%
% goto error
:BuenosDias
echo Muy buenos dias
pause
exit
:error
echo La palabra clave %MiVariable
%MiVariable%% es erronea.
pause
goto menu

En el caso de que MiVariable sea hola saldrá del procedimiento, hasta que no indiques la palabra
correcta seguiras en el programa.
Fíjate en esto:
If MiVariable==%MiVariable% exit
Cuando se ve esta expresión quiere decir que si de lo que introdujo el usuario no está en el grupo de opciones
disponibles puedes redireccionar el error que se produciría en el proceso, ya que si solo tenemos de opción
valida hola y pones jajaja se saldría (en ese caso no lo tienes controlado).
Nosotros sí lo tenemos controlado, lo redirrecionamos a la etíqueta error .
Las etíquetas (no se si realmente se llaman así :P) serían esto:
:error
.....
Es decir, pones : seguido del nombre de tú etíqueta, en el caso de que se equivoquen al poner la contraseña
pues que se vayan a esa etíqueta, en la cual les dará un mensajito de error, por ejemplo.
Y generalmente, como las etíquetas suelen estar (o quizás no :P) alejadas del lugar donde se esta operando
se usa goto .
El comando goto sería un taxi (por supuesto gratuito jaja) que te lleva de etíqueta en etíqueta.
Ahora podemos crear un inicio de sesión, humilde, en batch:

@echo off
title Inicio de sesion
set /P user=Usuario:
user=Usuario:
echo.
echo.
set /P contra=contrasena:
contra=contrasena:
if %user
%user%==trucos
%==trucos goto pass
if %user
%user%==%
%==%user
user%% exit
:pass
if %contra
%contra%==windows
%==windows goto ok
if %contra
%contra%==%
%==%contra
contra%
% exit
:ok
echo.
echo.
echo "Usuario & contrasena correctos"
echo.
echo.
pause
exit

En este caso si el usuario no es correcto se sale, si es correcto irá a verificar que la contraseña también es
correcta (si la contraseña no es correcta también se sale)
Si todo es correcto iremos a la etíqueta :ok ;)

Antes creamos un archivo llamado datos.txt , vamos a abrirlo usando el comando start :
start datos.txt
Así de sencillo (suponiendo siempre que datos.txt esta en la misma ubicación que nuestro bat) ;)
¿Cómo hacemos para movernos por los directorios usando batch?
Con el comando cd , con el podemos ir navegando por los directorios de nuestro ordenador:
Cd %windir%
Poniendo esto iremos a C:\Windows (también depende del sistema operativo)
Podemos hacer esto también:
Cd C:\Archivos de programa
Es MUY importante, usando este comando que si la ubicación hacia la que navegáis tiene espacios (como la
que puesto ahora), ponerla entre comillas ( ).

Aquí vamos a hacer un repaso rápido de lo que hemos visto antes y ampliar un poco la información que
tenemos:

En batch los espacios son malos a veces, y es frecuente que un despiste nos pueda dar un sustillo, recordar
poner las ó revisar si hay un espacio que no debería estar en ese sitio.

Hemos hablado acerca del comando set , sabes que muestran variables de entorno, pero ¿Qué es una variable
de entorno? ¿sirve para algo?
Una variable de entorno en batch& .echemos imaginación:
En una zona de la memoria de nuestro pc están guardadas una serie de variables con información acerca del
sistema operativo, de otros programas que permiten que estos puedan funcionar.
Por lo cual mejora el rendimiento , hará más rápido el acceso a dichas rutas&
No penséis que están cargadas siempre, hay un momento donde tienen que ser cargadas y ese momento es
cuando se inicia el ordenador (depende, pero aquí lo dejamos xD).
Espero que se entienda, tampoco es fácil de explicar& antes os dije que pusierais en CMD set , hacerlo y
veréis rutas:
Pues todas esas (y más) las podéis usar en batch, para distintos propósitos, por ejemplo:

ALLUSERSPROFILE =C:\Documents and Settings\All Users


APPDATA=C:\Documents and Settings\Francisco\Datos de programa
CLASSPATH=.;
CLIENTNAME=Console
CommonProgramFiles=C:\Archivos de programa\Archivos comunes
ComSpec=C:\WINDOWS\system32\cmd.exe

Estas son variables de entorno por ejemplo, todo lo que este del = a la izquierda es el nombre de la
variable, todo a la derecha del = es su valor (una ubicación, un número& ).
Copiar alguna variable de las que puse, vamos a verlo en batch.
Ya en el bloc de notas pegamos, yo he cogido dos:
ALLUSERSPROFILE
APPDATA
Vamos ha escribirlas entre %%, quedaría así
%ALLUSERSPROFILE%
% APPDATA%
Ya las podemos usar en batch:

echo %ALLUSERSPROFILE%
ALLUSERSPROFILE%
echo %APPDATA%
APPDATA%
pause
exit

:D, ya está, como veis nos muestra una ubicación, no tiene más misterio, para ir a esa ubicación desde batch
hariamos:
cd %ALLUSERSPROFILE%
Y para abrir una ventana para ver sus archivos:
Start %ALLUSERSPROFILE%

Aquí os dejo las que más uso yo (por cierto variables de entorno es lo mismo que variables de sistema en
batch, por si lo leéis por ahí)

%HOMEPATH% = %HOMEDRIVE%\Documents and Settings\%USERNAME%


%USERNAME% = Nombre del usuario que ha iniciado sesión.
%HOMEDRIVE% = La unidad (C:\, D:\, E:\...) en la que esta instalado nuestro windows.
%WINDIR% ó %SYSTEMROOT% = Ambas variables apuntan a un mismo directorio, el directorio en el
que esta windows (Casi siempre C:\Windows).
%TEMP%=Aquí se guardan archivos temporales, que son usados por programas, archivos que se guardan al
visitar páginas Web&

Hemos visto lo de las variables de entorno más a fondo , hablando de variables& sabemos preguntar al
usuario que nos de un número, y luego guardarlo en una variable, ¿Cómo haríamos para darle un valor a una
variable desde que el programa se inicia?
Set Variable=5
Veamos un pequeño ejemplo:
@echo off
title Cambio de valor
set /p a=Dime un número:
echo Tu número es %a%a%, ahora voy a cambiarlo :P
set a=0
echo.
echo.
echo El valor de la variable es ahora %a
%a%
pause
exit

En este punto aprenderemos más comandos, pero antes una curiosidad, usando el carácter & podemos
poner en una línea varios comandos, me explico:
@echo off & echo Hola & pause & exit
Bueno, los comandos a usar aquí son:
-Copy
-Dir
-Rd
-Md
El comando para poder copiar archivo es Copy .
Con Dir nos permite visualizar directorios y subdirectorios.
Md crear un directorio nuevo.
Rd elimina el directorio indicado.
La sintaxis de copy seria:
copy RutaDelArchivoACopiar RutaParaGuardarArchivo (tenemos que indicar la extensión del archivo que copiamos y de su copia).
@echo off
copy datos.txt C:\archivocopiado.txt
pause

Este ejemplo copiaría datos.txt a C:\ con el nombre y la extensión que le he puesto (por supuesto datos.txt
esta en la misma ubicación que nuestro batch).
Copy tiene varios modificadores, vamos a aprender a unir archivos de un mismo formato (extensión) en un
solo archivo final.
Antes de empezar vamos a distinguir entre estos dos tipos de archivos:
-Binario
-Ascii
Un archivo ASCII son archivos de texto, los archivos binarios todos los demás.
Bueno, coger un par de canciones que tengaís y vamos a unirlos (son archivo binarios).
copy /B cancion1.mp3 + cancion2.mp3 Final.mp3
El símbolo + indica que el archivo que viene a continuación se une a la cancion1, luego se deja un espacio y
se escribe el nombre que tendrá el archivo final con las dos canciones.
Creo recordar que no funciona con muchos formatos (mp3,wav& y alguno más).
Bueno con el comando Dir , podemos guardar por ejemplo directorios de una ubicación.
Vamos a usar el modificador /S , que sirve para mostrar todos los archivos del directorio especificado y
todos sus subdirectorios.
Dir /s %temp% >C:\temporal.txt
Con ese código guardaremos la información en temporal.txt (lo crea el bat, no hay que crearlo)
Si queremos añadir más información a un txt que ya existe, pondríamos esto:
Dir /s %temp% >>temporal.txt

Nos quedaría algo así.

El comando rd como dije antes es para eliminar directorios, usaremos los modificadores /S y /Q .
El modificador /S TODO lo que hay en el directorio que indiquemos (además del mismo directorio), el /Q
evita que nos pregunte si realmente queremos que se eliminen los directorios; dicho comando no tiene más
modificadores.

Con md creamos un directorio (no tiene modificadores, sustituye al comando mkdir ).


MD Nueva carpeta (entre comillas porque tiene un espacio).

Aun quedan muchos comandos y se acaba el tiempo, así que vamos&


-Schtasks
-Del
-Tree
El comando Schtasks permite hacer de todo respecto a lo que son las tareas programadas, las puedes crear,
modificar, borrar, ejecutar y ver cuales hay en uso actualmente.
Este comando tiene muchísimos modificadores, y creo que es mucho mejor que los busqueís vosotros en
CMD (schtasks /?).
De todas formas más adelante pondre un buen ejemplo de este comando para que le deis uso, si os sirve :P.

Del es un comando que sirve para borrar archivos, tan solo archivos.(el comando al que sustituye es
erase ).
Podemos borrar archivos según sus propiedades (archivo de lectura, ocultos, de sistema..) usando el
modificador /A .
No lo uso mucho, pero es una opción.
Vemos crear un archivo que se llame del.txt para realizar la prueba:

@echo off
del /s /q /f del.txt
pause

Si el archivo a de estar de la misma ubicación donde se ejecuta el bat, sino especificar su ubicación.
El comando Tree realiza algo parecido a dir , lo único diferente es que este representa los directorios
gráficamente (y los archivos que se encuentren en el directorio principal, es decir el que indicamos nosotros,
los demás no se verán )
Posee dos modificadores, /F que sirve para mostrar los archivos de cada carpeta.
Y /A usa ascii en vez de caracteres extendidos, pero para que veis la diferencia entre usarlo y no usarlo
luego hacemos una cosa, muy sencilla xD.
De esta forma obtendremos gráficamente en un .txt los directorios que tenemos en %TEMP% :

@echo off
tree /F /A %TEMP%>C:\tree.txt
start C:\tree.txt
exit
De esta forma cuando acabe de escribir toda la informacion en tree.txt , se abrira el archivo y se cierra el bat.
Ahora quitarle el modificador /A , y ejecutarlo.

¿Hay diferencia?
Ejemplo acerca de Schtasks :
Os comento, este bat pedirá 3 datos, los necesarios para que pueda crear el código de la tarea, con esto quiero
decir que lo creará pero no lo ejecutará.
Tan solo guardará el código en un .txt que se guardará en C:\, para usarlo abre un .bat y copialo dentro ;)
Por cierto, etíqueta de la tarea será su nombre, así que ponerle algo con sentido :P

@echo off
title Crear tarea programada
echo etíqueta de la tarea:
set /P r=
echo Directorio+Archivo+Extension:
set /P q=
echo.
echo.
echo Tipos de programacion
echo.
echo.
echo [ ONCE ] - [ ONSTART ] - [ ONLOGON ] - [ ONIDLE ]
echo.
echo.
echo [ MINUTE ] - [ HOURLY ] - [ DAILY ] - [ WEEKLY ] - [MOTHLY]
echo.
echo.
echo Tipo de programacion:
set /p t5=
t5=
echo Hora:
set /p t=
echo Minutos:
set /p t1=
t1=
echo Segundos
set /p t2=
t2=
cls
echo.
echo.
echo Operacion finalizada
echo schtasks /create /tn "%r
"%r%" /tr %q
%q% /sc %t5
%t5%
% /st %t
%t%:%t1
%:%t1%:%
%:%t2
t2%
% /ru system > C:\schtasks.txt
pause
start /I /MAX C:\schtasks.txt
exit
No recuerdo muy bien (No sirve para todos los tipos de programación que paracen en el bat (Once = Una
única vez se ejecutará; Minute = Cada minuto; Hourly= Cada 1 hora; Daily= Cada Día; Weekly= Cada
semana;)
Los que no menciono son los que no funcionan con este ejemplo, sorry ;)
Recordad que podeis ver más info abriendo CMD y escribiendo
schtasks /create /? para crear tareas; schtasks /delete /? para borrar etíquetas; schtasks /? para todo :D.

Ejemplo para conectar a un servidor FTP, bajar archivos, subirlos (si se nos permite) y varias explicaciones:
En primer lugar creamos X.bat y Z.txt.
Abrimos el X.bat y escribimos esto :

ftp -s:Z.txt amelia.es


pause
exit

(ahora explico más afondo..)


Y en el Z.txt escribimos esto:
En la primera línea escribimos el USER del FTP, en la segunda línea escribimos el PASS, en la tercera
especifico entre Bin y ascii (Bin=binario xD ), aquí en la 4ª línea escribimos Put, que serviria para SUBIR
nosotros algun archivo, en la 5ª línea podemos poner el comando GET que seria para Descargar un archivo y
por último un quit para salirnos del ftp, quedaría algo así:
Franmdd ( user )
%zn3hCj3B4 ( pass )
BIN o ASCII según nos convenga (*)
PUT (SUBIR)
GET (DESCARGAR)
QUIT (exit
(exit))

En el X.bat explico:
FTP -S ( -S es para indicar que lea el archivo que viene a continuación, que es el que contiene la informacion,
sencillamente para que no tengas que hacer nada.)
Dejamos un espacio y escribimos el HOST al que se va a conectar.

Bueno y si quieres saber ( y moverte por el ftp ) pon esto cuando este ya conectado al ftp: ls -C:, para lo
último que he dicho haría falta hacerlo "manualmente" que viene a ser esto:
Inicio>ejecutar>CMD
Ponemos FTP ( una vez puesto puedes poner HELP para obtener ayuda del FTP), luego ponemos Open (y el
server, por ejemplo amelia.es o una ip 120.45.76.33 también vale.), identificaros ( user & pass ) y ahora poner
lo de ls -C: (veréis lo archivos que os dejan ver xDD), luego ya poner lo de BIN o ASCII ( Ascii SOLO
archivos de TEXTO, Bin todos los demás exe, jpg, flv, bat..), para envíar archivos VMS se usaba (por no lo
usa ni dios ) el comando L8, ej: l8 123.VMS

Bueno espero que les sirva de algo, y recuerden que pueden ver toda la información de cualquier comando,
poniendo en CMD NombreDelComando /?

Un saludo, FranGK
Review de Inform 7
Por Blag http://atejada.blogspot.com
Saben ustedes que son los juegos de Ficción Interactiva?, Pues bueno de acuerdo con Wikipedia:
Wikipedia:

Una aventura conversacional es un género de videojuegos en el que la descripción de la situación en la que

se encuentra el jugador proviene principalmente de un texto. A su vez, el jugador debe teclear la acción a

realizar. El juego interpreta la entrada -normalmente- en lenguaje natural, lo cual provoca una nueva

situación y así sucesivamente. A veces existen gráficos en estos juegos, que sin embargo son tan sólo

situacionales o que ofrecen ayuda complementaria en algunos casos. El género de las aventuras gráficas

surgió como evolución de las videoaventuras y las aventuras conversacionales, dejando éstas últimas

'pasadas de moda' en Occidente, aunque siguen estando muy presentes en Japón.

Si no lo sabían, pues ahora lo saben...Y ya lo sabían, entonces supongo que deben de conocer a Graham

Nelson,
Nelson, el padre de la Ficción Interactiva. Si no lo conocen, el ha sido el creador de Inform,
Inform, un parser para

crear juegos de Ficción Interactiva.

Ustedes se preguntarán...Y cual es el chiste de tener un parser para este tipo de juegos? No se pueden hacer

en cualquier lenguaje y ya? La respuesta es simple, claro que se puede pero es complicado, puesto que hay

crear cuartos, objetos, situaciones, entender palabras, oraciones, etc...

Por ejemplo, esta es una muestra del juego que hice utilizando Dev-C++, llamado El Gato Cheko .

#include "Cat_Class.h"
#include "Cat_Places.h"
#include "Cat_Actions.h"

char aux[100], saved[100];


Cat Cheko;
Bird Paloma;
Rat Rata;
void ExtractDir(char
ExtractDir(char*
* filename);
int main(int
main(int argc, char *argv[])
{
char dirName[100];
strcpy(dirName, argv[0]);

ExtractDir(dirName);
strcpy(aux, dirName);

cout<<aux;
cout<<aux;

Inicio();
getch();
}

Como pueden darse cuenta, tuve que dividir al programa en 4. Un archivo principal y 3 includes para manejar
a los actores, los escenarios y las acciones.
El juego terminó con 2,458 líneas de código.
Ahora veamos, como quedó el juego cuando lo pasé a Inform 6...

constant Historia "El Gato Cheko^";


Cheko^";
constant Titular "^Blag - SinglePath games design. ";
release 1;
constant NO_PUNTUACION;
constant NO_LUGARES;

include "EParser";
"EParser";

!---MENSAJES---!

object mensajeslibreria
with
antes
[;
rezar: "¿Para qué? Si eres un gato áteo.";
áteo.";
cantar: "Cantas una canción de Dead Kennedys...Pero no te ayuda a salir de esta casa...Ni modo -:(";
-:(";
saltar: "Saltas con todas tus fuerzas.....Pero no pasa nada.";
nada.";
];

include "Acciones";
"Acciones";
include "BajoNivel";
"BajoNivel";
Como pueden ver, de todos modos utilizo 3 librerías, pero la diferencía es que estas me sirven para crear
cualquier juego. Mis librerías servían únicamente para mi juego.
El juego terminó con 1,053 líneas de código. Optimizado en un 42,8%.
Claro, todo eso parece muy bueno, pero hay que tener en cuenta que la mayoría de los autores y jugadores de
Ficción Interactiva, no tienen idea de cómo programar y aunque el Inform 6 no requería de mucha lógica (Por
lo cual los no programadores podían llegar a dominarlo), Graham Nelson pensó que era hora de hacer que los
juegos fueran incluso más sencillos de hacer. Así nació el Inform 7.
7.

Finalmente con su propio IDE.


Con documentación y ejemplos incluidos.

Nos muestra gráficamente como está construido nuestro mundo.

Veamos de cerca como es el código fuente.

"Codigo_Latino" by Blag
Include Spanish by Sebastian Arg.
The story headline is "Una revista de programación" [R: Bibliographic data]

[*** Portada ***]


The Portada is a room. The printed name is "Portada".
"Portada".
The description is "Estás dentro de la portada de Código Latino. Una revista hecha por programadores para programadores."
The articulo is here. The printed name is "Artículo sobre Inform 7".
7".

Se darán cuenta de que prácticamente estamos escribiendo más que programando, esto es porque Inform 7
hace uso del llamado Natural Language, es decir utilizar palabras del lenguaje cotidiano para poder
programar.
Como pueden ver, utilizamos un include creado por Sebastian Arg para poder utilizar comandos en español
en nuestro juego, puesto que obviamente el Inform está en Inglés.
Claro, en el código ustedes ven una mezcla entre Español e Inglés. Los comandos en Inglés y los textos en
Español, pero veamos que pasa cuando ejecutamos el programa.

Codigo_Latino
Una revista de programación por Blag
Release 1 / Serial number 081214 / Inform 7 build 5T18 (I6/v6.31 lib 6/12N) SD
Portada
Estás dentro de la portada de Código Latino. Una revista hecha por programadores para programadores.

Puedes ver un Artículo sobre Inform 7.

>examinar artículo
No observas nada especial en el Artículo sobre Inform 7.
>coger articulo
Cogido.
>sur
No puedes ir por ahí.
>norte
No puedes ir por ahí.
>

El juego se desarrolla completamente en Español. Lo cual es una gran ventaja, puesto que así cualquiera con
un poco de tiempo e imaginación puede programar sin ningún problema.
Para más información:

http://www.caad.es/informate/infsp/

Saludos,

Blag.
F_Tanori es un gran colaborador del foro SoloCodigo y un gran programador en diversos lenguajes como
Visual Basic, PHP, PowerBuilder y otros, tiene su propía empresa llamada ..... la cual ofrece x productos y
servicios; esto fue lo que nos regalo en esta entrevista.

1) ¿De dónde eres? 7) ¿Qué opinas de la escena de programadores en


Hermosillo, Sonora ,Mexico Latinoamérica?
Creo que es bastante buena, he visto por foros como
2) ¿Hace cuánto que comenzaste a programar? SoloCodigo donde uno tiene oportunidad de
Dedicarme profesionalmente a esto en el 2002 conocer grandes cerebros debido a la calidad de sus
respuestas además de culturas de diferentes, países
3) ¿Cuáles son tus lenguajes de programacióncomo Argentina, Colombia, Perú, Uruguay incluso
favoritos? México entre muchos otros , creo que existe
PHP, C/C++, Visual Basic, PowerBuilder ( y aunquemuchísima calidad y aun esta en progreso.
no es de programación me gusta mucho el SQL)
8) ¿Cuáles son tus nuevos proyectos?
4) ¿Cuáles son tus programas favoritos de Diseño? Actualmente trabajo para proyectos de Comercio
La verdad el diseño no se lleva muy bien conmigo,Electrónico y Proyectos del Sector Salud en ambiente
pero utilizo mucho el Photoshop CS2 para optimizarWeb
imágenes para Web o maquetar
9) ¿Que te gustaría ver en los próximos años en el
5) ¿Qué te inspiró a ser programador? mundo de la programación?
Bueno ,en realidad yo iba ser Ing. Químico pero enPrecisamente me gustaría ver el progreso de los países
preparatoria conocía la programación, me ha gustadode América latina avance, en forma firme (incluso no
y por eso elegí una carrera profesional donde usara lasolo en programación), me gustaría que todas las
programación, pero realmente antes de eso no teniacarreras que existen llevaran la asignatura de
idea de lo que era la programación como para queprogramación para que sepan lo que es. Y los
inspirara. desarrolladores tengamos un mejor trato, me interesan
mucho los avances de la IA pero en realidad no tengo
6) ¿Cuéntanos un poco acerca de tu compañía? pensado algo que gustaría ver.
Bueno al salir de la universidad establecimos una
pequeña empresa unos compañeros de universidad y10) ¿Cuál es tu mensaje final para la comunidad?
yo, donde realizamos desarrollos de sistemas, redes,Bueno agradezco esta entrevista, a Código Latino y a
Webhosting y soporte técnico a empresas. su nuevo Editor Edo por tomarme en cuenta, y que
sigamos compartiendo nuestros conocimientos con los
demás eso nos permitirá crecer a todos y en nuestro
propío idioma como el gran proyecto SoloCodigo.com
del cual estoy orgulloso de ser parte aunque sea un
poco.
Código Latino es posible gracias a:

NUESTRA RECOMENDADA DE ESTA EDICION ES LA REVISTA APRENDERPYTHON

Esperamos sus comentarios, códigos y artículos para la próxima entrega, esta es una revista de todos
y para todos.
Pueden escribirnos a willian.radicaled@gmail.com
Unetenos con Google Group http://groups.google.com/group/codigolatino
Visita nuestro Blog para más información: http://revistacodigolatino.blogspot.com

Hasta una próxima entrega.


Feliz Navidad y un Prospero Año Nuevo
Chao