martes, 28 de septiembre de 2010

PS-HTTPD

PS-HTTPD: "

web-server-1


PS-HTTPD es un servidor web muy simple escrito en… sí: PS, Postscript!


Aquí copio el código fuente para los curiosos…



%!
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% @(#)ps.ps
% PostScript meta-interpreter.
% Copyright (C) 1989.
% By Don Hopkins. (don@brillig.umd.edu)
% All rights reserved.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% This program is provided for UNRESTRICTED use provided that this
% copyright message is preserved on all copies and derivative works.
% This is provided without any warranty. No author or distributor
% accepts any responsibility whatsoever to any person or any entity
% with respect to any loss or damage caused or alleged to be caused
% directly or indirectly by this program. If you have read this far,
% you obviously take this stuff far too seriously, and if you're a
% lawyer, you should give up your vile and evil ways, and go find
% meaningful employment. So there.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Problems:
% How do we catch the execution of event Name and Action dict values,
% executed by awaitevent?

systemdict begin

/iexec-types 100 dict def
/iexec-operators 100 dict def
/iexec-names 200 dict def
/iexec-exit-stoppers 20 dict def
/iexec-single-forall-types 20 dict def
/iexec-array-like-types 20 dict def

/iexec-continue-procs? true def
/iexec-continue-names? true def

/iexecing? false def

/signal-error { % name => -
dbgbreak
} def

/iexec-stopped-pending? { % - => bool
false
ExecSP 1 sub -1 0 {
ExecStack exch get % ob
dup type /dicttype eq {
dup /continuation known {
dup /continuation get /stopped eq {
pop true exit
} { pop } ifelse
} { pop } ifelse
} { pop } ifelse
} for
} def

/olddbgerrorhandler /DbgErrorHandler load ?def

/iexec-handle-error {
iexec-stopped-pending?
true { stoppedpending? } ifelse
{
/stop load PushExec
} {
$error /errorname get signal-error
} ifelse
} def

/DbgErrorHandler {
iexecing? {
iexec-handle-error
} //olddbgerrorhandler ifelse
} def

/isarray? { % obj => bool
type iexec-array-like-types exch known
} ?def

%
% A procedure to allow programmer to know if there is a "stopped"
% pending somewhere within the scope of the call. This is used
% to check if it's safe to rely on stopped to handle an error,
% rather than the errordict. The debugger can use this to
% catch errors that have no stopped call pending.
%
/stoppedpending? { % - => bool
false currentprocess /ExecutionStack get % result a
dup length 1 sub -2 1 { % result a i
2 copy get % result a i index
exch 1 sub 2 index exch get % result a index proc
dup isarray? {
exch 1 sub get % result a caller
/stopped load eq {pop true exch exit} if
} {
pop pop
} ifelse
} for
pop
} ?def

/?iexec-handle-error { % - => -
{ iexec-handle-error } if
} def

% interpretivly execute an object

/iexec { % obj => ...
100 dict begin
% This functions "end"s the interpreter dict, executes an object in the
% context of the interpreted process, and "begin"'s back onto the
% interpreter dict. Note the circularity.
/MumbleFrotz [ % obj => ...
/end load /exec load currentdict /begin load
] cvx def

/ExecStack 32 array def
/ExecSP -1 def

/PushExec [ % obj => -
/ExecSP dup cvx 1 /add load /store load
ExecStack /exch load /ExecSP cvx /exch load /put load
] cvx def

/PopExec [ % obj => -
ExecStack /ExecSP cvx /get load
/ExecSP dup cvx 1 /sub load /store load
] cvx def

/TraceStep {
iexec-step
} def

PushExec

{ ExecSP 0 lt { nullproc exit } if % nothing left to execute? goodbye.

ExecStack 0 ExecSP 1 add getinterval
TraceStep pop

% pop top of exec stack onto the operand stack
PopExec

% is it executable? (else just push literal)
dup xcheck { % obj
% do we know how to execute it?
dup type
//iexec-types 1 index known { % obj type
//iexec-types exch get exec % ...
} { % obj type
% some random type. just push it.
pop % obj
} ifelse
} if % else: obj

} loop % goodbye-proc

currentdict /MumbleFrotz undef % Clean up circular reference
end
exec % whoever exited the above loop left a goodbye proc on the stack.
} def

% visually execute an object, dumping drawing of stacks to trace-file

/vexec { % obj => ...
{ {
(
%!
/l { % gray x y lastx lasty
moveto
2 copy lineto
0 setgray
stroke

2 copy .3 0 360 arc
0 setgray
fill

.25 0 360 arc
setgray
fill

pause
} def
/e { % x y => -
gsave
translate
0 setlinewidth
360 32 div rotate
16 {
0 0 moveto
1 0 rlineto
0 setgray
stroke
1 0 .1 0 360 arc
random setgray
fill
360 16 div rotate
} repeat
grestore
} def
systemdict /pause known not {
/pause {} def
} if
gsave
20 20 scale
1 1 translate
0 setgray
0 setlinewidth
erasepage
)
trace-print
/TraceX 0 def
/TraceY count 1 sub def
/TraceZ 0 def
/TraceStep {
% (\() print ExecSP iexec-printexec (\)print ) trace-print
TraceY TraceX % x y
/TraceX ExecSP def
/TraceY count 2 sub def
/TraceZ TraceZ 1 add 360 mod def
TraceZ 15 mul cos 1 add 3 div 1 exch sub trace-print#
TraceX trace-print# TraceY trace-print#
trace-print# trace-print# % print x,y
(l\n) trace-print
random .2 le { flush pause pause pause } if
} def
/signal-error { % name => -
/TraceX ExecSP def
/TraceY count 3 sub def
TraceX trace-print# TraceY trace-print#
(e\n) trace-print
(grestore showpage\n) trace-print trace-flush
/stop load PushExec
} def
} meta-exec
exec
(grestore showpage\n) trace-print trace-flush
} iexec
} def

/trace-file (%socketc2000) (w) file def

/trace-flush {
trace-file dup null eq { pop currentfile } if
flushfile
} def

/trace-print { % string => -
trace-file dup null eq { pop currentfile } if
exch writestring
} def

%/trace-print# {typedprint} def
%/trace-print# {=} def
/trace-print# {
(%\n) sprintf trace-print
} def

/annealexec { % obj => ...
{ {
(
%!
/F /Times-Roman findfont
/s { % str point h s b x y
moveto sethsbcolor
F exch scalefont setfont
show
} def
gsave
)
trace-print
/TracedObjects 2000 dict def
/TracedTypes 20 dict def
TracedTypes begin
/nametype 0 def
/array .2 def
/packedarray .2 def
/operatortype .4 def
/dicttype .6 def
/canvas .8 def
end

/!FieldWidth 100 def
/!FieldHeight 100 def

/!StartBrightness .5 def
/!StartSaturation 1 def
/!StartPoint 18 def

/!StepBrightness .2 def
/!StepSaturation .2 def

/!DecayBrightness .95 def
/!DecaySaturation .95 def

/!TraceHistory 10 def

/!DistNear 5 def
/!DistFar 50 def
/!DistGrav .1 def
/!DecaySpeedNear .5 def

/!MagDecay .9 def
/!Friction .95 def

/LastTraced [] def

/TraceStep { % estack => popped
dup length 1 sub get % obj
dup type TracedTypes known {
TracedObjects 1 index known not {
30 dict begin
TracedObjects 1 index currentdict put
/Hue TracedTypes 2 index type get def
/Saturation !StartSaturation def
/Brightness !StartBrightness def
/Point !StartPoint def
/X !FieldWidth random mul def
/Y !FieldHeight random mul def
/DX 0 def
/DY 0 def
/String 1 index cvs def
end
} if
10 dict begin
/Other null def /Dist 0 def /Dir 0 def /Mag 1 def
TracedObjects exch get begin
LastObjects {
TracedObjects exch get
dup currentdict eq { pop } {
/Other exch store
Other /X get X sub
Other /Y get Y sub
2 index dup mul 2 index dup mul sub sqrt
/Dist exch store
Dist !DistNear lt {
% Wow, they're close together:
% Let's slow the other one down!
pop pop
Other begin
/DX DX !DecaySpeedNear mul def
/DY DY !DecaySpeedNear mul def
end
} {
atan /Dir exch store
Dist DistFar min
DistFar div DistGrav mul
/DX 1 index Dir cos mul Mag mul DX add store
/DY 1 index Dir sin mul Mag mul DY add store
} ifelse
/Brightness Brightness !StepBrightness add 1 min def
/Mag Mag !DecayMag mul store
} ifelse
} forall
/LastObjects [
currentdict LastObjects {
counttomark !TraceHistory ge { exit } if
} forall
] store
end
end
TracedObjects {
begin
/X X DX add !FieldWidth add !FieldWidth mod def
/Y Y DY add !FieldHeight add !FieldHeight mod def
/DX DX !Friction mul def
/DY DY !Friction mul def
/Brightness Brightness !DecayBrightness mul def
Y X Brightness Saturation Hue Point Str
((%) % % % % % % F\n) sprintf trace-print
end
} forall
null % for pop
} ifelse
} def
} meta-exec
exec
(grestore showpage\n) trace-print trace-flush
} iexec
} def

/iexec-printexec { % index => -
ExecStack 1 index get
dup type /dicttype eq {
dup /namestring known {
begin namestring end
} if
} if
exch (% %\n) printf
} def

/iexec-where {
0 1 ExecSP {
iexec-printexec
} for
} def

% execute step by step on the cyberspace deck stack display.
% To step, execute 'exit'. (make an 'exit' button to step with the mouse).

/cexec {
{ { /TraceStep {
ExecSP
iexec-printexec
select-object
/ThisStep ThisStep 1 add def
ThisStep Steps ge {
/ThisStep 0 def
_SendUpdateStack
eventloop
} if
null
} def
/Steps 1 def
/ThisStep 0 def
} meta-exec
exec
} iexec
} def

/iexec-step { % operand stack ... execee
} def

/iexec-sends { % - => context0 context1 ... contextn
ExecSP 1 sub -1 0 {
ExecStack exch get % ob
dup type /dicttype eq {
dup /continuation known {
dup /continuation get /send eq {
/context get
dup null eq { pop } if
} { pop } ifelse
} { pop } ifelse
} { pop } ifelse
} for
} def

% Re-enter the NeWS PS interpreter, execute object, and return.
% We need to construct the currentprocess's /SendStack from the interpreter's
% send stack, so ThisWindow and other functions that look at the SendStack
% will work.
/iexec-reenter { % obj => ...
mark
/ParentDictArray where pop
iexec-sends % obj mark context0 context1 ... contextn
{ { % obj mark context0 context1 ... contextn {func}
1 index mark eq { % obj mark {func}
pop pop % obj
{exec} stopped % ... bool
} { % obj mark context0 context1 ... contextn {func}
dup 3 -1 roll send % ...
} ifelse
} dup exec
} MumbleFrotz
?iexec-handle-error
} def

iexec-array-like-types begin
/arraytype true def
/packedarraytype true def
end % iexec-array-like-types

/iexec-token { % token => ...
dup xcheck {
% This is the "weird" thing about PostScript:
% If object is isn't an executable array, execute it, else push it.
//iexec-array-like-types 1 index type known not { PushExec } if
} if
} def

iexec-types begin

/nametype { % name => ...
pause
iexec-continue-names? {
% We push a dummy name continuation on the exec stack here to
% help with debugging, by making stack dumps more informative...
10 dict begin
/continuation /name def
/continue { % dict
pop
} def
/name 1 index def
/namestring {
/name load cvlit (name: % *done*) sprintf
} def
currentdict cvx PushExec
end
} if
//iexec-names 1 index known { % name
//iexec-names exch get % func
exec %
} {
% name
{{load}stopped} MumbleFrotz {
true ?iexec-handle-error
} {
PushExec
} ifelse
} ifelse
} def

/arraytype { % array => ...
iexec-continue-procs? {
10 dict begin
/continuation /procedure def
/proc exch def
/i 0 def
/len /proc load length def
/continue { % dict => -
begin
i len lt {
currentdict cvx PushExec
/proc load i get iexec-token
/i i 1 add def
} if
end
} def
/namestring {
(procedure % @ %: %)
[ /proc load i
1 index length 1 index gt { 2 copy get } (*done*) ifelse
] sprintf
} def
currentdict cvx PushExec
end
} {
dup length dup 0 eq { % array length
pop pop %
} { % array length
1 eq { % array
0 get %
iexec-token %
} { % array
dup 0 get % array head
% push rest of array to execute later
exch 1 1 index length 1 sub getinterval % head tail
PushExec % head
iexec-token %
} ifelse
} ifelse
} ifelse
} def

/packedarraytype /arraytype load def

/stringtype { % string => ...
dup token { % string rest token
exch dup length 0 eq { pop } { PushExec } ifelse % string token
exch pop % token
iexec-token % ...
} { % str
dup length 0 eq {
pop %
} { % str
/syntax signal-error
} ifelse
} ifelse
} def

/filetype { % file => -
dup token { % file token
exch dup % token file file
status { PushExec } { pop } ifelse % token
iexec-token % ...
} { % file
dup status {
/syntax signal-error
} {
pop
} ifelse
} ifelse
} def

/operatortype { % operator => -
//iexec-operators 1 index known {
//iexec-operators exch get exec
} {
{{exec}stopped}
MumbleFrotz
?iexec-handle-error
} ifelse
} def

/dicttype { % dict => -
dup /continuation known {
dup /continue get exec
} if
} def

end % iexec-types

iexec-operators begin

/exec load { % obj => -
PushExec
} def

/if load { % bool proc => -
exch {
PushExec
} {
pop
} ifelse
} def

/ifelse load { % bool trueproc falseproc
3 -1 roll { exch } if % wrongproc rightproc
PushExec pop
} def

iexec-single-forall-types begin
{/arraytype /packedarraytype /stringtype}
{true def} forall
end % iexec-single-forall-types

/forall load { % obj proc => -
10 dict begin
/continuation /forall def
/proc exch def
/obj exch cvlit def
/i 0 def
//iexec-single-forall-types obj type known {
/continue { % dict => -
begin
i obj length lt {
currentdict cvx PushExec
obj i get
/proc load PushExec
/i i 1 add def
} if
end
} def
/namestring {
(forall: proc=% obj=% @ %: %)
[ /proc load /obj load i
1 index length 1 index gt { 2 copy get } (*done*) ifelse
] sprintf
} def
} {
/keys [
obj {pop} forall
] def
/continue { % dict => -
begin
i obj length lt {
currentdict cvx PushExec
keys i get % key
obj 1 index get % key val
/proc load PushExec
/i i 1 add def
} if
end
} def
/namestring {
(forall: proc=% obj=% @ %: %)
[ /proc load /obj load
keys i
1 index length 1 index gt {
get 2 copy get
} {
pop null (*done*)
} ifelse
] sprintf
} def
} ifelse
currentdict cvx PushExec
end
} def

/for load { % first step last proc
10 dict begin
/continuation /for def
/proc exch def
/last exch def
/step exch def
/first exch def
/i first def
/continue { % dict => -
begin
i last step 0 gt {le} {ge} ifelse {
currentdict cvx PushExec
i
/proc load PushExec
/i i step add def
} if
end
} def
/namestring {
(for: proc=% first=% step=% last=% i=%)
[/proc load first step last i] sprintf
} def
currentdict cvx PushExec
end
} def

/repeat load {
10 dict begin
/continuation /repeat def
/proc exch def
/times exch def
/i 0 def
/continue { % dict => -
begin
i times lt {
currentdict cvx PushExec
/proc load PushExec
/i i 1 add def
} if
end
} def
/namestring {
(repeat: proc=% times=% i=%)
[/proc load times i] sprintf
} def
currentdict cvx PushExec
end
} def

/loop load {
10 dict begin
/continuation /loop def
/proc exch def
/continue { % dict => -
begin
currentdict cvx PushExec
/proc load PushExec
end
} def
/namestring {
/proc load (loop: proc=%) sprintf
} def
currentdict cvx PushExec
end
} def

/pathforallvec load {
%...
} def

iexec-exit-stoppers begin
{/forall /for /repeat /loop /pathforallvec}
{true def} forall
end % iexec-exit-stoppers

/exit load {
{ ExecSP 0 lt { % exit out of interpreter?
true exit
} {
PopExec % obj
dup dup xcheck exch type /dicttype eq and { % obj
dup /continuation known {
dup /continuation get iexec-exit-stoppers exch known {
pop false exit
} {
pop
} ifelse
} {
pop
} ifelse
} { % obj
pop
} ifelse
} ifelse
} loop

{ {exit} exit } if
} def

/stop load {
{ ExecSP 0 lt { % stop out of interpreter?
true exit
} {
PopExec % obj
dup dup xcheck exch type /dicttype eq and { % obj
dup /continuation known {
dup /continuation get /stopped eq {
pop true false exit
} {
pop
} ifelse
} {
pop
} ifelse
} { % obj
pop
} ifelse
} ifelse
} loop

{ {stop} exit } if
} def

/stopped load { % proc
10 dict begin
/continuation /stopped def
/continue { % dict => -
pop false
} def
/proc 1 index def % debugging
/namestring {
/proc load (stopped: proc=%) sprintf
} def
currentdict cvx PushExec
PushExec
end
} def

/send load { % <args> message object => <results>
{ currentdict } MumbleFrotz % message object context
2 copy eq { % message object context
pop pop cvx PushExec
} { % message object context
10 dict begin
/continuation /send def
/context
exch dup /ParentDictArray known not { pop null } if
def % message object
/object exch def % message
/message 1 index def % message
/continue { % cdict => -
{ % cdict
ParentDictArray dup type /arraytype ne { % X11/NeWS
/ParentDictArray get length 1 add
} {
length
} ifelse
1 add {end} repeat
/context get % context
dup null eq { % context
pop %
} { % idict context
dup /ParentDictArray get {begin} forall begin %
} ifelse %
} MumbleFrotz
} def
/unwind /continue load def
/namestring {
(send: message=% object=% context=%)
[/message load object context] sprintf
} def
currentdict cvx PushExec
object context % message object context
end % of cdict
{ null ne {
ParentDictArray length 1 add {end} repeat
} if
dup /ParentDictArray get
dup type /arraytype ne { % X11/NeWS
dup /ParentDictArray get
{begin} forall begin begin % message
} {
{begin} forall begin % message
} ifelse
} MumbleFrotz % message
cvx PushExec %
} ifelse
} def

% supersend (operator in X11/NeWS, proc in 1.1?)

/currentfile load { % => file
null
ExecStack length 1 sub -1 0 {
ExecStack exch get % obj
dup type /filetype eq {
exit
} {
pop
} ifelse
} for
dup null eq {
pop currentfile
} {
exch pop
} ifelse
} def

% We have to have the send contexts set up right when we do a fork, since
% the child process inherits them. (i.e. so ThisWindow works)
/fork load {
{fork} iexec-reenter
} def

/countexecstack load {
/countexecstack dbgbreak
} def

/quit load {
/quit dbgbreak
} def

end % iexec-operators

iexec-names begin

/sendstack {
[ iexec-sends
currentprocess /SendContexts get aload pop
]
} def

/iexecing? true def

% meta-exec is a hook back up to the interpreter context.
/meta-exec {
exec
} def

/append {
{{append} stopped} MumbleFrotz
?iexec-handle-error
} def

/sprintf {
{{sprintf} stopped} MumbleFrotz
?iexec-handle-error
} def

% execstack

end % iexec-names

/iexec-trace-changes {
iexec-operators begin
/def load {(/% % def\n) [3 index 3 index] dbgprintf def } def
/store load {(/% % store\n) [3 index 3 index]dbgprintf store} def
/put load {(% /% % put\n) [4 index 4 index 4 index]dbgprintf put} def
end
} def

end % systemdict



No related posts.



Creado por tuxotron for CyberHades, 2010. |
Permalink |
2 comments |


Post tags: , , ,

"

Vapor.js, la librería de JavaScript más rápida y pequeña del mundo

Vapor.js, la librería de JavaScript más rápida y pequeña del mundo: "Hay que ver las comparativas de rendimiento para creérselas. Vapor.js es la librería de JavaScript más rápida y pequeña del mundo (ver su código en GitHub). Además es compatible con las demás librerías de JavaScript (se puede usar junto con jQuery, Scriptaculous, Prototype, Dojo, lo que sea), y parece hecha a medida para compatibilizarla con Super Simple Storage Service (S4)."

¿Supercomputadoras de navegadores web?

¿Supercomputadoras de navegadores web?: "

navegadores web enjambre ¿Supercomputadoras de navegadores web?

Imagina una red compuesta de navegadores web configurados para trabajar de forma colaborativa para alcanzar una meta particular. ¿Cómo los orquestarías? ¿Cómo distribuirías las obligaciones computacionales de cada uno? ¿Qué tipo de tecnología debería tejer esa red? Las respuestas a estas preguntas definen lo que podríamos considerar como Computación Distribuida Basada en Navegadores (lo acepto, el nombre no es el más afortunado).

A lo largo de este artículo revisaré los aspectos que favorecen al navegador web como plataforma de aplicaciones distribuidas, así como algunos proyectos que ya han experimentado alrededor de esta fascinante idea.

JavaScript, ¿el nuevo CPU?

Lejos están aquellos días en los que el navegador web sólo descargaba HTML y unos pocos elementos extra para componer documentos en nuestra pantalla. En cambio, en la actualidad está transformado en una compleja y completa herramienta de software, en buena medida gracias a la cantidad de aplicaciones de escritorio que han sido trasladadas a él.

Desde el navegador ya podemos disfrutar de sofisticados clientes de correo como Gmail y hasta de videojuegos como Biolab Disaster. Y muchas otras aplicaciones escritas por programadores que están aprovechando las bondades de HTML5.

Sin duda uno de los principales protagonistas de esa evolución es el imprescindible motor JavaScript. Los navegadores web más populares ofrecen el suyo. Piensa por un momento en cada uno como si de un procesador Intel, AMD o SPARC se tratase:

  • Firefox 4 usará JägerMonkey, una gran mejora con respecto al viejo SpiderMonkey.

  • Opera 10.6 ya cuenta con el poderoso y veloz Carakan.

  • Chrome/Chromium nos impresionan en cada nueva versión con su motor V8.

  • Safari 5 emplea Nitro, que es 30% más rápido que su predecesor, según Apple. Por cierto, el generador de código nativo de JägerMonkey está basado en el de Nitro.

  • Internet Explorer 9 beta no se queda atrás con Chakra, que presume ser capaz de usar el CPU de forma paralela al navegador.

Dicho esto, ¿qué puede ofrecer el navegador para servir de plataforma de cómputación distribuida? Por ahora distingo tres puntos fuertes a su favor:

  1. Está integrado naturalmente a la Red. La comunicación entre nodos puede facilitarse.

  2. El motor JavaScript puede hacer las veces de CPU. Las aplicaciones JavaScript se ejecutarán tan rápido como sean interpretadas por su motor.

  3. Es una interfaz de usuario multiplaforma (¿universal?). Una misma aplicación puede ejecutarse en el mismo navegador sin importar sistema operativo ni CPU. El navegador hace las veces de una máquina virtual.

El trabajo realizado

La idea de distribuir tareas de cómputo para ser ejecutadas en navegadores web no es nueva en lo absoluto. En 2007 Boldrin et al. publicaron un artículo (Distributed Computing Through Web Browser) en el que propusieron una arquitectura de computación distribuida compuesta por navegadores web que ejecutan tareas en JavaScript y AJAX. El origen del tema puede rastrearse años antes en proyectos como Parasite, basados en applets de Java.

5 navegadores web ¿Supercomputadoras de navegadores web?

¿Quiénes están experimentando recientemente con el navegador cómo plataforma de computación distribuida?

  • Ilya Grigorik jugó con el asunto en 2009. Creó una pequeña aplicación en Ruby para hacer computación masivamente paralela. Hizo una implementación básica del MapReduce de Google.

  • Ivan Zuzak creó pmrpc una versión de RPC para HTML5. Con esto es posible crear aplicaciones distribuidas con el viejo paradigma RPC de paso de mensajes y llamadas a procedimientos remotos.

  • La gente del equipo Anansi hizo una implementación de MapReduce en JavaScript llamada MapRejuice. Ejecuta tareas en navegadores web y por el momento sólo es una prueba de concepto. Han estado contando palabras de manera colaborativa desde entonces.

¿Supercomputación web?

Yo no sé con exactitud qué direcciones tomará el tema. Me he convencido de que el navegador web está llamado a ser La Plataforma Universal de Cómputo. Puedo sonar exagerado (¿rimbombante?). Mis razones mucho tienen que ver con lo expuesto hasta ahora (quizá merecen otro post entero donde involucre las últimas propuestas para HTML5 y la aceleración gráfica vía GPU).

No veo lejana la fecha en la que, por ejemplo, SETI@Home, y otros proyectos similares, estén migrados completamente a Firefox en forma de un algún complemento. Los navegadores serán nodos con un aceptable desempeño para la computación voluntaria, masiva y colaborativa. Entonces veremos emerger una supercomputación web que integre PC, laptops, netbooks y hasta smartphones. ¿Será?

Imagen: Visual Complexity

¿Supercomputadoras de navegadores web? escrita en ALT1040 el 28 September, 2010 por alan.lazalde
Enviar a Twitter | Compartir en Facebook

"

Realidad aumentada, el futuro de la literatura infantil

Realidad aumentada, el futuro de la literatura infantil: "

wondla 317x420 Realidad aumentada, el futuro de la literatura infantil

Cada vez que tengo la posibilidad menciono a Neal Stephenson. No sólo es uno de mis escritores de ciencia ficción favoritos (de los más importantes en la actualidad, junto a Vernor Vinge), sino que es un verdadero experto en tecnología. Una novela suya (sobre criptografía) incluye un completo script en Perl y llegó a escribir un libro completo sobre la interacción del hombre con el ordenador, los distintos sistemas operativos y las modalidades de negocio que existen en el mundo tecnológico. Es que el hombre, en su tiempo libre (cuando no está escribiendo novelas de más de mil páginas) escribe artículos para Wired y en un tiempo colaboró en el desarrollo de un sistema para la puesta en órbita de satélites.

Esta última semana he estado leyendo, en mis ratos libres, una de sus novelas más famosas, La era del diamante. Sin entrar en spoilers (vamos, que tampoco terminé de leerla), cuenta la historia de un artifex, un hacker del futuro a quien se le encomienda la creación de un manual interactivo destinado a la educación de la nieta de una especie de señor feudal 2.0. El manual, construido en base a nanotecnología, toma información del ambiente y de la mente de la niña en cuestión para desarrollar una educación hiper personalizada, basada principalmente en las historias de los hermanos Grimm. Muy simpático, pero nada más que ciencia ficción.

Ahora bien, seguramente conozcan Las crónicas de Spiderwick. La peli me pareciò aburridisísima, pero dicen que los libros son más interesantes, sobre todo para chicos (¡claro!). El asunto es que el último libro del autor de Las Crónicas (llamado La búsqueda de WondLa), Tony DiTerlizzi, incluye actividades interactivas gracias a las cuales los lectores podrán conocer el mundo en el que transcurre la historia.

El objetivo se logra al sujetar tres emblemas distintos, que aparecen en tres páginas del libro, frente a una webcam. Gracias a un plugin que se añade al navegador web, los lectores podrán disfrutar de una experiencia de realidad aumentada que les permitirá ver un mapa interactivo del mundo que incluye tanto animaciones como sonidos.

Quienes disfrutaron de la experiencia aseguran que es muy limitada y decepcionante (aquí entran en juego las expectativas), pero el campo de la realidad aumentada recién ahora está animándose a surgir. Claro, puede faltar mucho todavía para una experiencia literaria/educativa completamente personalizada mediante la realidad aumentada, pero no creo que falte tanto como para que pueda cambiar drásticamente la manera en que contamos historias a los niños antes de que vayan a la cama. Imaginen las posibilidades, para los autores de historias fantásticas y para los pedagogos. Imaginen un aula con niños de menos de 10 años aprendiendo con entornos de realidad aumentada. Y no falta mucho.

Vía: ReadWriteWeb

Realidad aumentada, el futuro de la literatura infantil escrita en ALT1040 el 28 September, 2010 por federico-erostarbe
Enviar a Twitter | Compartir en Facebook

"

viernes, 24 de septiembre de 2010

El instalador Ninite llega a Ubuntu

El instalador Ninite llega a Ubuntu: "

ninite linux El instalador Ninite llega a Ubuntu

Ninite, para quienes no le conozcan, es una aplicación que facilita tremendamente y de forma desatendida, la instalación de software en Windows. No cualquier software sino únicamente el disponible a través del servicio que, de hecho, cuenta con varias docenas agrupadas en diferentes clasificaciones: navegadores web, mensajería instantánea, multimedia, oficina, seguridad, etc. Diego Fraga les contó mucho más en su momento.

Pues luego de muchas peticiones -es lo que mencionan en el sitio oficial- Ninite (beta) ahora también funciona en Ubuntu y ahora ya podrás instalar cierto software con esa facilidad. El proceso es simple:

  1. Elige lo que quieres instalar.

  2. Ninite hará un paquete .deb con los repositorios correspondientes.

  3. Ninite instalará el software por ti.

Intenté instalar Adobe AIR y Picasa. Me apareció el mensaje “su intalador estará listo en breve”. Me pidió abrirlo y dar clic para instalar. El paquete descargado fue un ninite.deb con AIR y Picasa dentro. Al final todo transcurrió con normalidad y mi software apareció en su lugar dentro del menú de Aplicaciones de Ubuntu.

ninite instalacion El instalador Ninite llega a Ubuntu

Es curioso. El sitio Ninite insiste en decir que es para Linux, pero en realidad está dirigido a los usuarios de Ubuntu. Supongo que asume que usar Linux es igual Ubuntu. Esto puede causar confusión entre los usuarios más noveles. Creo que debería decir que su servicio es precisamente para Ubuntu.

Por su funcionalidad, Ninite para Ubuntu parece tener el potencial para ser una buena alternativa al Centro de Software de Ubuntu. Por la cantidad de paquetes que ofrece, no. Aunque es posible que en el futuro logre un aceptable balance entre los dos. Por ahora merece la pena si quieres instalar códecs restringidos, software cerrado como Skype, Dropbox y demás.

El instalador Ninite llega a Ubuntu escrita en Bitelia el 23 September, 2010 por alan.lazalde
Enviar a Twitter | Compartir en Facebook



"

miércoles, 22 de septiembre de 2010

Nagios te alerta del estado de tus servidores

Nagios te alerta del estado de tus servidores: "

nagios service detail Nagios te alerta del estado de tus servidores

Dentro de la operación de sistemas de información, uno de los factores de medida más importantes es el de la disponibilidad de los servicios. Garantizar una alta disponibilidad del servicio es una de las tareas de más importantes y complejas dentro de la administración y explotación de sistemas. Sin embargo, para poder garantizar una alta disponibilidad, se hace necesario disponer de una herramienta que permita medirla y que ayude a los administradores de sistemas a detectar posibles errores o fallos que afecten a la disponiblidad de los servicios.

Nagios es un sistema de monitorización en software libre, bajo licencia GPL2, que nos permite conocer en todo momento el estado de nuestros sistemas, monitorizando nuestra granja de servidores y los servicios que en éstos se alojan, generando alertas y alarmas cuando el comportamiento de los mismos no sea el esperado. Esta monitorización permite a los adminsitradores de sistemas abstraerse de la vigilancia continua, permitiéndoles desempeñar otras funciones y tareas sin tener que estar constantemente revisando que todo está funcionando. Para la recepción de alarmas, la aplicación es bastante flexible puesto que éstas pueden recibirse mediante correo electrónico. SMS, a través de un servidor de mensajeria Jabber o utilizando un plugin para Thunderbird. Dentro de las capacidades de la aplicación se encuentra la de monitorizar servicios de red, la gestión vía SNMP (que quizás sea uno de los aspectos más importantes) o la monitorización de recursos hardware (carga del procesador, espacio en disco, memoria, estado de los puertos, etc). Cualquier sistema que soporte SNMP es susceptible de ser monitorizado con Nagios (switches, routers, puntos de acceso, servidores de cualquier tipo, etc).

La visualización de la información es un aspecto muy interesante, incluyéndose una vista global con el estado de todos los servicios definidos para cada elemento, host, el estado de cada host o la lista de host con problemas. Además, se incluye una sección de informes de disponibilidad, fundamental para verificar que los niveles de servicio obtenidos están dentro de los parámetros de funcionamiento definidos.

Nagios es una herramienta, yo diría, esencial dentro de la administración y explotación de sistemas de información, un vigía constante del estado de nuestros servidores y servicios. Es una de las herramientas que está dentro de mi kit de diario.

Nagios te alerta del estado de tus servidores escrita en Bitelia el 22 September, 2010 por jjvelasco
Enviar a Twitter | Compartir en Facebook



"

Crea tu propia distribución de Linux desde cero

Crea tu propia distribución de Linux desde cero: "

lfs-logo


Linux From Scratch (LFS) es un proyecto (un libro) que nos ayudará a dar los pasos necesarios para crear nuestra propia distribución de Linux.


Yo aparte de la parte educativa, no le veo mucha gracia la verdad, a menos que seas una empresa con unos requisitos muy peculiares y necesites algo muy personalizado.


En fin aquí queda la noticia para el que le interese.


Te puedes descargar el libro desde aquí.

Visto en unixmen.com




No related posts.



Creado por tuxotron for CyberHades, 2010. |
Permalink |
No comment |


Post tags: , , , ,

"

domingo, 19 de septiembre de 2010

Libro gratuito en PDF “TCP/IP Tutorial and Technical Overview” de IBM/Redbooks

Libro gratuito en PDF “TCP/IP Tutorial and Technical Overview” de IBM/Redbooks: "

libroIBMTCPIP


Echando un vistazo al repositorio de documentación de IBM llamado Redbooks, donde puedes encontrar muy buena documentación técnica sobre los productos de esta gran compañía (lugar que debes de conocer si trabajas con tecnología IBM), he encontrado este libro muy interesante sobre el protocolo de comunicaciones TCP/IP llamado “TCP/IP Tutorial and Technical Overview” con casi 1000 páginas. Es del año 2006 pero sirve perfectamente para profundizar y aprender más sobre el pilar básico de las comunicaciones y el transporte de datos en Internet.


Echa un vistazo al índice:


Part 1. Core TCP/IP protocols

Chapter 1. Architecture, history, standards, and trends

Chapter 2. Network interfaces

Chapter 3. Internetworking protocols

Chapter 4. Transport layer protocols

Chapter 5. Routing protocols

Chapter 6. IP multicast

Chapter 7. Mobile IP

Chapter 8. Quality of service

Chapter 9. IP version 6

Chapter 10. Wireless IP


Part 2. TCP/IP application protocols

Chapter 11. Application structure and programming interfaces

Chapter 12. Directory and naming protocols

Chapter 13. Remote execution and distributed computing

Chapter 14. File-related protocols

Chapter 15. Mail applications

Chapter 16. The Web

Chapter 17. Network management

Chapter 18. Wireless Application Protocol

Chapter 19. Presence over IP


Part 3. Advanced concepts and new technologies

Chapter 20. Voice over Internet Protocol

Chapter 21. Internet Protocol Television

Chapter 22. TCP/IP security

Chapter 23. Port based network access control

Chapter 24. Availability, scalability, and load balancing

Appendix A. Multiprotocol Label Switching


Puedes descargarlo desde aquí y no olvides echar un vistazo a los libros más populares de Redbooks.




Related posts:

  1. Libro gratuito “Producing Open Source Software”

  2. Libro gratuito “Graphic Adventures”

  3. Diagramas de flujo para reparar ordenadores



Creado por cybercaronte for CyberHades, 2010. |
Permalink |
No comment |


Post tags: , , , , , , , , ,

"

jueves, 16 de septiembre de 2010

Whitespace: Lenguaje de programación esotérico

Whitespace: Lenguaje de programación esotérico: "

Whitespace: Lenguaje de programación esotérico

¿Alguna vez, leyendo el código fuente de un programa, te costó trabajo entender qué había querido hacer su creador? Seguramente sí. Incluso hay concursos para ver quién escribe el código más retorcido (“C ofuscado” le dicen). Pero el premio gordo a la dificultad extrema se lo lleva Whitespace. Este lenguaje, que solo usa espacios en blanco, tabuladores y líneas nuevas en su código, es lo más esotérico que hemos visto. ¿Lo conocías?

Lenguajes de programación hay muchos. Demasiados, si tenemos que creerle a algunos expertos. Uno podría pensar que con C alcanza y sobra para programar cualquier cosa, desde un sistema operativo hasta un microcontrolador. Pero los expertos siguen desarrollando nuevas formas de convertir una idea en un montón de símbolos que indiquen a un ordenador que debe hacer. En general, esos esfuerzos se orientan a conseguir formas más “naturales” de instruir a la máquina, de forma que gente sin una formación en sistemas pueda crear sus propios programas. Pero algunas veces, seguramente como una broma o un intento de lograr cierta clase de “fama”, alguien concibe un compilador capaz de volver loco al programador más avezado. Whitespace es un ejemplo de ello: un lenguaje de programación esotérico y prácticamente desconocido, que solo usa espacios en blanco, tabuladores y líneas nuevas en su código.

Visto en Neoteo: Whitespace: Lenguaje de programación esotérico
“Hola mundo”, con los espacios aparecen en color rosa y las tabulaciones en celeste.
“Hola mundo”, con los espacios aparecen en color rosa y las tabulaciones en celeste.

Whitespace, un lenguaje de programación que seguramente sería muy apreciado por los espías, se basa en un código que resulta prácticamente invisible. Como sus instrucciones se expresan como una combinación de espacios en blanco y golpes de tabulador -ambos símbolos inimprimibles- se hace indispensable utilizar algún editor de textos que resalte con colores estos elementos para poder leerlas. La imagen anterior, en la que los espacios aparecen en color rosa y las tabulaciones en celeste, es el “Hola Mundo” de Whitespace. ¿Te cuesta trabajo entenderlo? Imagina lo que sería si no hubiesen pintando esos caracteres de colores: ¡solo verías una hoja en blanco! Este esotérico lenguaje de programación fue desarrollado por Edwin Brady y Chris Morris, quienes dieron a conocer su obra a la comunidad de programadores el 1 de abril de 2003. Es un lenguaje “imperativo”, como C, BASIC, PERL, PHP o JAVA. La programación imperativa describe la programación en términos del estado del programa y sentencias -las que en este caso se redactan con espacios y tabuladores- capaces de cambiar dicho estado. Dicho de otra forma, los programas imperativos son un conjunto de instrucciones, una especie de “receta”, que le indican al ordenador la manera en que debe realizar una tarea. Prácticamente todo el hardware existente está diseñado para ejecutar código de máquina escrito en una forma imperativa, basado en el paradigma de las Máquinas de Turing. Whitespace, a pesar de lo extraño que nos parece, es un lenguaje completamente funcional y que -al menos en teoría- nos permite realizar cualquier tarea.

Visto en Neoteo: Whitespace: Lenguaje de programación esotérico
Chuck Norris programa (obviamente) en Whitespace, con los ojos vendados.
Chuck Norris programa (obviamente) en Whitespace, con los ojos vendados.

Al igual que otros lenguajes de alto nivel, Whitespace permite el uso de variables y sentencias bastante complejas. Su funcionamiento, al igual que otros lenguajes, basa en una “pila” (stack en inglés). La pila no es más que una estructura de datos de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir). Este sistema permite almacenar y recuperar datos mediante dos operaciones básicas: apilar (“push”, que coloca un objeto en la pila) y su operación inversa, retirar (“pop”, o desapilar), que retira el último elemento apilado. Whitespace solo pude acceder a la parte superior de la pila (TOS, por “Top of Stack”), donde se encuentra el último objeto apilado. Se pueden apilar números enteros de cualquier longitud, pero no valores de coma flotante. ¿Cuál es la utilidad real de un lenguaje de programación tan extraño como este? En la práctica, ninguna. Desarrollar algo así es un excelente ejercicio intelectual, pero utilizar Whitespace para programar una aplicación no es más que una muestra de masoquismo extremo. Y ni hablar del trabajo que implicaría realizar tareas de mantenimiento al código escrito por otra persona, o por uno mismo luego de algún tiempo. Brady y Morris han conseguido un merecido lugar en el “hall of fame” de los creadores de compiladores extraños, pero nada más que eso. ¿No te parece?


Enlaces relacionados:
Visto en Neoteo: Whitespace: Lenguaje de programación esotérico
Sitio oficial de Whitespace

Technorati Tags:
Tags Blogalaxia: "

[Descarga del día] Nautilus Terminal, un terminal en tu explorador

[Descarga del día] Nautilus Terminal, un terminal en tu explorador: "

Descarga del día

Linux no es un terminal. Actualmente el pensamiento de que Linux es una pantalla negra llena de letras y comandos imposibles de recordar ha quedado atrás (o eso espero). Para un usuario medio que utilice éste sistema operativo a diario, Gnome o cualquier otro entorno de ventanas le resultará más que suficiente e, incluso, la palabra “terminal” le sonará a chino mandrín.

De todas formas, para los más avanzados, el terminal les ayudará a exprimir al máximo todo el potencial de éste sistema operativo. Uno de los problemas que tiene la ventana de la consola es que puede resultar algo incómoda. Maximizarla, minimizarla y moverla para que no ocupe un espacio innecesario puede ser una ardua tarea.

Ya hemos hablado con anterioridad de Yakuake o Tilda, ventanas desplegables que contienen un terminal siempre al alcance y que suelen ser la primera opción para acceder al mismo y teclear algo inmediatamente. Otra opción es lo que os traigo hoy, Nautilus Terminal, un añadido al explorador de carpetas Nautilus que añade una terminal embebida en la ventana.

Nautilus Terminal

Como se muestra en la captura de pantalla, es un mínimo espacio el que ocupa pero para realizar tareas sencillas es más que suficiente y no estorba.

Para poder instalarla, lógicamente sobre Linux, debemos añadir el repositorio PPA de Fabien Loison:

sudo add-apt-repository ppa:flozz/flozz
sudo apt-get update && sudo apt-get install nautilus-terminal

y posteriormente ejecutar nautilus -q en una terminal o, si preferimos, pulsar “Alt + F2” y escribirlo.

Información básica:

  • Plataforma: Linux
  • Licencia: Open Source
  • Precio: Gratuito
  • Enlace de descarga: Nautilus Terminal

[Descarga del día] Nautilus Terminal, un terminal en tu explorador escrita en Bitelia el 15 September, 2010 por Diego Fraga
Enviar a Twitter | Compartir en Facebook



"

Coffeescript, Javascript con sintaxis de Python

Coffeescript, Javascript con sintaxis de Python: "JavaScript es ese lenguaje que no es Java y que al principio parecía de juguete, sólo útil para manipular elementos en páginas web. Sin embargo, en los últimos años ha pasado a ser para algunos "el lenguaje del futuro", tanto en el servidor y en el escritorio). Otros lo llaman "el nuevo código de máquina", por la cantidad de lenguajes y proyectos que usan otro lenguaje y compilan a JavaScript, como el GWT de Google, que usa Java y el proyecto Pyjamas, que usa Python. Un lenguaje nuevo que sigue esta tendencia de usar JavaScript como objetivo de su compilación es CoffeeScript, que su autor Jeremy Ashkenas define como una forma mejor de escribir la semántica de las partes buenas de JavaScript con una sintaxis más cómoda, inspirada en Python, una semántica refinada (todo es una expresión que devuelve un valor, no hay statements o sentencias) y la adición de elementos útiles como las comprensiones. InfoQ le dedica un artículo titulado, como no, "CoffeeScript, JavaScript the Good Parts", y también se puede ver un video de la presentación de Jeremy en jsConf 2010: "A Cup of CoffeeScript"."

martes, 14 de septiembre de 2010

Escribe aplicaciones para el iPhone desde Windows (y que funcionen también en Android)

Escribe aplicaciones para el iPhone desde Windows (y que funcionen también en Android): "

Genexus Escribe aplicaciones para el iPhone desde Windows (y que funcionen también en Android)

A pesar del título comenzaré (valga la redundancia) por el inicio. Estos días se está llevando a cabo en la ciudad de Montevideo un evento importante para la industria del desarrollo Latinoamericana pero desconocido para muchas personas ajenas a ella. Se trata del evento anual que viene haciendo Artech desde hace exactamente 20 años, celebrando a su producto estrella y la comunidad que se ha generado a su alrededor. Pero en esta oportunidad hubo una noticia que les puede interesar y bastante.

En principio, GeneXus es un generador de programas, una plataforma que permite escribir completas aplicaciones de manera declarativa y sencilla, independientemente del lenguaje de programación y la base de datos elegida. El producto generado por la aplicación es código Java, C# o Ruby, pero no utilizamos los lenguajes en el proceso. De este modo, contamos con menos libertad para trastear pero a la vez se simplifica (mucho) el ciclo de desarrollo.

En fin, lo que nos importa es que al principio del día Nicolás Jodal (vicepresidente y cofundador de ArTech) anunció algunas de las nuevas funcionalidades de la futura versión de GeneXus y un servicio web que apuntan a generar aplicaciones para dispositivos móviles del mismo modo en que se venía haciendo hasta ahora en la plataforma corporativa.

Es decir, gracias a la próxima versión de GeneXus, no sólo podremos escribir aplicaciones que funcionen en iOS (iPad, iPhone, iPod Touch) sino también en el resto de sistemas operativos móviles como Android (en cualquiera de sus tantas versiones) y Blackberry, en tanto soportará también Windows Phone. Estas aplicaciones serán escritas todas con el lenguaje declarativo particular de GeneXus (seleccionando visualmente para qué sistema queremos hacerlo) y una de las mayores ventajas (además del hecho de no tener que escribir varias veces la aplicación de cero para cada dispositivo en particular) es que en consecuencia no será necesario adquirir una Mac para escribir aplicaciones para el iPhone, ya que GeneXus corre sobre Windows.

Un dato que me llamó poderosamente la atención es que, teniendo en cuenta que el código generado es Objective-C, las aplicaciones resultantes son aprobadas por la App Store. Todos sabemos el proceso engorroso de que Apple apruebe una aplicación para su plataforma móvil y a pesar de que ahora hayan quitado algunas restricciones, en Cupertino tienen infinitos motivos para rechazar una app. No hace falta decirlo, ante cualquier problema quienes utilicen la aplicación contarán con el respaldo de Artech para solucionar cualquier problema.

Hace mucho tiempo que venimos hablando en Hipertextual de nuevas tecnologías y nuevos dispositivos, pero a nivel corporativo había un gran vacío debido, en palabras de Jodal, a lo dificultoso que es escribir código para cada una de estas plataformas (con manuales y guías de miles de páginas, con distintos lenguajes, diferentes bibliotecas, distintos estándares). Este problema conlleva a la vez otro problema, quizás aún más importante: hacerlo es muy, pero muy caro.

La próxima versión de la aplicación permitirá convertir el núcleo de actividad más utilizado de una aplicación empresarial a la plataforma móvil, pero quienes sólo deseen crear aplicaciones simples para consumidores finales están desarrollando otra herramienta todavía más interesante. Se trata de GeneXus SDX, un servicio en la nube que permitirá, de manera on line, crear una simple aplicación y hostearla como para testearla en el dispositivo. Claro que, si no queremos enviar una aplicación a la App Store llena de bugs no es problema alguno, porque cuentan con una propia aplicación para cada uno de los dispositivos que permitirá ejecutar internamente nuestro programa y ver si tiene errores.

Como verán es una plataforma distinta, muy conocida en el mundo corporativo pero no tanto fuera de él. En este caso en particular creo que se trata de una excelente alternativa, si es que quieren contar con sus aplicaciones en todos (o la mayoría de) dispositivos móviles (desde smartphones a tablets), teniendo en cuenta que escribir y reescribir el código para cada uno de ellos puede ser una verdadera locura.

Escribe aplicaciones para el iPhone desde Windows (y que funcionen también en Android) escrita en Bitelia el 14 September, 2010 por federico-erostarbe
Enviar a Twitter | Compartir en Facebook



"

lunes, 6 de septiembre de 2010

Mesa con capa de agua en su superficie que crea olas cuando apoyas una taza

Mesa con capa de agua en su superficie que crea olas cuando apoyas una taza: "




mesa-capa-agua


Esta pequeña mesa lleva incorporada una capa superior que contiene agua … el relajante efecto visual que consigues es que al apoyar una taza o un vaso se forman ondas desde su base …


mesa-capa-agua-2


Está diseñada en la Masters Design Academy como parte de un proyecto de graduación, así que no esperes encontrarla a la venta, al menos en principio.


link


Compartir en Facebook


Related posts:

  1. Máquina que crea olas en el agua y consigue dibujos en su superficie

  2. Mesa con 8 patas que camina cuando la empujas

  3. Nuevo sistema que aprovecha la energía de las olas comienza a funcionar en Escocia



"

jueves, 2 de septiembre de 2010

Visualizador de Python en línea

Visualizador de Python en línea: "El Tutorial Visual de Python es un intérprete de Python 2.5 restringido (sin importación de módulos ni entrada/salida) con un debugger y un visualizador de estructuras de datos incorporado. Viene con algunos ejemplos como un fibonacci memoizado, y parece utilísimo como herramienta para enseñar programación a novatos. Su autor Philip J. Guo opina, por supuesto, que Python es un lenguaje ideal para enseñar programación."

Apple entra a las redes sociales y lanza Ping

Apple entra a las redes sociales y lanza Ping: "

pingLas redes sociales son un terreno que está que arde en este momento. Facebook ha logrado capturar la mayor cuota de mercado, superando a MySpace, y de paso ha tentado a un montón de otras empresas a aventurarse en este mundo, hambrientas de conseguir un pedacito del éxito que logró Mark Zuckerberg.

Es así como Google se trae algo entre manos que tendría que ver con videojuegos, mientras que Apple ha optado por aprovechar su imperio de la música digital y lanzó Ping.

Pero, ¿qué es Ping?

“Es como Twitter y Facebook con iTunes”, dijo Steve Jobs en su conferencia de hoy. Y básicamente es así. A diferencia de las redes sociales normales, no funciona sobre un navegador, sino que está fusionada con iTunes 10.

Ping permite seguir a otros usuarios, como se hace en Twitter, dejándote seguir a tus músicos o bandas favoritas. Además puedes ver qué música están escuchando y canciones que están componiendo. Tiene un sistema para crear listas de canciones y álbums, un feed de noticias, listas de conciertos y está disponible desde hoy para todos quienes descarguen iTunes 10.

Jobs indicó, en una nota que podría ser algo irónica, que la privacidad de Ping es “súper simple” de configurar, “cualquiera puede hacerlo”. Con problemas de privacidad tanto en Facebook como en Google, quizás es un buen punto a resaltar, aunque no sé cuánto más confiable que las dos anteriores pueda ser Apple.

Como las redes sociales hoy en día son una cosa en movimiento, donde la gente actualiza su estado mientras va en el metro o se toma un café, Ping también estará disponible para el iPhone y el iPod Touch a través de una aplicación en la App Store, que se podrá descargar gratis.

Personalmente, me recuerda un poquito a Last.fm, pero sin el streaming de música.

Se trata de una movida inteligente de parte de Apple. Si ves que tus amigos compraron el nuevo disco de Artic Fire, es muy posible que por curiosidad lo descargues también. Y ya que estás dentro de iTunes, es muy posible que lo compres ahí mismo, porque ya tienes el programa abierto, que tiene la información de tus créditos y de tu tarjeta ya guardados.

Lady Gaga ya está en Ping

Lady Gaga ya está en Ping

¿Qué significa para las demás redes sociales?

Es muy posible que Ping pueda convivir sin problemas con Facebook, así que por ese lado no hay problemas. Tiene el respaldo de una enorme compañía para empujarla al éxito, además del hecho de que una persona puede estar en las dos redes sin problemas, puesto que tienen usos diferentes. Al estar enfocada en la música, la función de Ping apunta más a discutir, comentar y recomendar discos, y no a mantener el contacto con los amigos del colegio o los primos.

Redes como MySpace, sin embargo, podrían verse en problemas. MySpace ha ido decayendo en los últimos años, e intentó re-adaptarse tras la salida de Facebook precisamente aferrándose a la música, y a la alternativa de que los artistas pudieran exponer su trabajo ahí.

Apple ya está llamando a músicos a exponerse dentro de Ping, lo que podría quitarle una buena parte de su atractivo a MySpace. Al final, la red social podría quedar reducida a los músicos independientes, que no tienen su música en iTunes ni tienen relación con Apple – y quizás eso sea muy poco para sobrevivir.

Links:
- Evento musical de Apple en Vivo [FW Live]
- Apple introduces iTunes 10 with Ping (Apple)



"