
Dance Dance Revolution S 1.0.3 120MB
http://rapidshare.com/files/221770164/iP_DancDRS_1.0.3.rar

Metal Gear Solid Touch 91MB
http://rapidshare.com/files/221843457/iP_MetGeaSol_1.0.rar

Hysteria 1.0 120MB
http://rapidshare.com/files/221878241/iP_Hyst_1.0.rar

Armado 1.1 58MB
http://rapidshare.com/files/221708688/iP_Armad_1.1.rar

Real Soccer 2009 66MB
http://rapidshare.com/files/221680497/iP_ReSocc2009_1.2.rar

GTS World Racing 1.01 8MB
http://rapidshare.com/files/221496029/iP_GTWorld_1.01.rar

Catch the Egg 1.0 9MB
http://rapidshare.com/files/221456550/iP_Eggo_1.0.rar

Tetris 1.1.86 10MB
http://rapidshare.com/files/221489859/iP_Tet_1.1.86.rar

Adrenaline Pool Online 1.5 10MB
http://rapidshare.com/files/221492853/iP_Adpool_1.5.rar

Astraware Board Games 1.0 5MB
http://rapidshare.com/files/220945294/iP_Astra_1.0.rar

Crash Bandicoot: Nitro Kart 0.7.6 7MB
http://rapidshare.com/files/221429592/iP_Crash_0.7.6.rar

Let’s Golf 1.0.7 82MB
http://rapidshare.com/files/220894224/iP_LG_1.0.7.rar

Penalty 1.0.1 17MB
http://rapidshare.com/files/221076480/iP_Penal_1.0.1.rar

Super Monkey Ball 1.02 38MB
http://rapidshare.com/files/221041272/iP_SMonkey_1.02.rar

Silent Hill: the escape 17MB
http://rapidshare.com/files/221048075/iP_SH_1.0.rar

2XL SuperCross 1.0 69MB
http://rapidshare.com/files/221453312/iP_SCross1.0.rar

Trism 1.2 6MB
http://rapidshare.com/files/220949581/iP_Trys_1.2.rar

Truco 5MB
http://rapidshare.com/files/220952647/iP_Trick.rar
This document goes over some best practices for using the Linked Mode feature of vCenter 4.
The Linked Mode feature provides a way to greatly improve the efficiency of managing multiple vCenter instances. After you form a Linked‐Mode group, you can log in with the vSphere Client to any single instance of vCenter and view and manage the inventories of all the vCenter Servers in the group. For more background information on Linked Mode, please see the vSphere product documentation, or view this video.
Overview of Linked Mode Capabilities
Choose the boundaries for Linked Mode deployments based on these considerations
Linked vCenter instances share the following
Roles definitions
Licenses, e.g. ESX host license or individual features license
NOTE: it's impossible to not share these
Linked vCenter instances cannot share
ESX hosts
Clusters
VMs
Linked vCenter instances do not share these directly, but can be shared indirectly
Roles assignments (share by explicitly duplicating; this could be scripted using the PowerCLI or Perl Toolkit)
Templates (share using common datastores)
ISOs, other utility files (share using common datastores)
Dormant VMs (share using common datastores; remove from one inventory and add to other; this migration could be scripted)
With Orchestrator, these processes can be shared across Linked vCenter instances
Deployment of VMs (i.e., you can initiate a VM deployment within Orchestrator, and then indicate which vCenter instance the VM should go to)
Migrating from vCenter 2.5 to vCenter 4Scenario 1: Multiple independent vCenter 2.5 deployments
Recommendation: upgrade each deployment independently to vCenter 4, and then join into Linked Mode group
Scenario 2: One large vCenter 2.5 deployment
Recommendation: split the deployment by desired organizational boundaries into multiple separate ones, according to Proven Practice: Splitting a VirtualCenter Server Installation. Then, follow recommendations from Scenario 1. Note that this is a one-time procedure: you cannot go back to the first vCenter and then move additional hosts, unless you are willing to lose performance data.
Approaches for Assigning Permissions across Linked Mode vCenter
Choose from the following two scenarios based on your own internal administration model and processes. Make sure the vCenter administration model is aligned with your other IT policies and configurations, e.g. AD domains, network access, etc.
Scenario 1: site-specific permissionsIn this scenario, only a top-level administrator has privileges across all linked vCenter instances. Lower level admins and all users have privileges only for specific sites.
Super Administrator | ||
Site Administrator | Site Administrator | Site Administrator |
Site Operator | Site Operator | Site Operator |
Site User | Site User | Site User |
Scenario 2: universal permissions
In this scenario, all administrators have privileges across all sites, with fewer or greater privileges depending on seniority. Only the least privileged users have site-specific permissions.
Super Administrator | ||
Junior Administrator | ||
Operator | ||
User | ||
Site User | Site User | Site User |
Linked Mode Operational ConsiderationsPrerequisites
The vCenter Server instances in a Linked Mode group can be in different domains if the domains have a two-way trust relationship. Each domain must trust the other domains on which vCenter Server instances are installed.
For transitive trust between domains: the same user should be able to be authenticated on any of the domains from any of the instances
vCenters in Linked Mode cannot run on a Domain Controller
When adding a vCenter instance to a Linked Mode group, the installer must be run by a domain user who is an administrator on both the machine where vCenter is installed and the target machine of the Linked Mode group.
All vCenter Server instances must have network time synchronization. The vCenter Server installer validates that the machine clocks are not more than 5 minutes apart.
DNS resolution needs to works correctly from any instance to all other instances
For more information, please see the section on Linked Mode prerequisites in the vSphere documentation
Other Considerations
If you are joining a vCenter Server to a standalone instance that is not part of a domain, you must add the standalone instance to a domain and add a domain user as an administrator.
The vCenter Server instances in a Linked Mode group do not need to have the same domain user login. The instances can run under different domain accounts. By default, they run as the LocalSystem account of the machine on which they are running, which means they are different accounts.
During vCenter Server installation, if you enter an IP address for the remote instance of vCenter Server, the installer converts it into a fully qualified domain name.
You cannot join a Linked Mode group during the upgrade procedure when you are upgrading from VirtualCenter 2.x to vCenter Server 4.0. You can join after the upgrade to vCenter Server is complete. See the vSphere Upgrade Guide.
Known Issues
For the latest list of known issues, please see the Release Notes for your version of vCenter.
Joining a Linked mode group after installation is unsuccessful if UAC is enabled on Windows Server 2008
Joining two vCenter Server instances fails with an error message in status.txt about failure to remove VMwareVCMSDS
For large vCenter Server inventories, when you open the vSphere Client in Linked Mode with the inventories of all vCenter Server systems fully expanded, the vSphere Client might be nonresponsive for several minutes
When you run the Linked Mode Configuration Wizard after linking a vCenter Server system to a group in a pure IPv6 environment, there is no option to isolate the vCenter Server system from Linked Mode
If you remove a role, the operation only checks the status of the role on the currently selected vCenter Server system. However, it removes the role from all vCenter Server systems in the Linked Mode group without issuing a warning that the role might be in use on the other servers.
Troubleshooting
Please see the section on Troubleshooting Linked Mode in the vSphere documentation.
A estas alturas es dificil que alguie no conozca el polémico y terrible video de Two Girls One Cup, aquel de la generosa amiga que compartía un helado con otra. Si aún hay algún rezagado os refrescamos con aquella versión animal del video en cuestión que recogía además algunos enlaces interesantes a versiones y reacciones varias.
Hoy lo que traemos es una bella versión de la parte musical de aquel mítico y bizarro video pseudo lésbico con un toque diferente.
basehttp://blog.adnstream.tv/feed/Colorburned is having a giveaway, and the prize is a free limited edition copy of Obox Design’s WordPress theme, Hash One. [Link]
basehttp://feeds2.feedburner.com/wpcandyHere's a quick tip that Jonathan Yurek, author of Paperclip, was kind enough to help me with. It's a simple way to have a randomized filename for uploaded content. This is useful for security through obscurity, especially when used with Paperclip's id_partition interpolation helper:
class Photo < Asset has_attached_file :image, :path => ":class/:attachment/:id_partition/:basename_:style.:extension" before_create :randomize_file_name private def randomize_file_name extension = File.extname(image_file_name).downcase self.image.instance_write(:file_name, "#{ActiveSupport::SecureRandom.hex(16)}#{extension}") end endThat would, for example, change an uploaded image named "DS_100.JPG" into:
http://example.com/photos/images/000/001/204/e15f64f5e7gjdo3e4ae58f4ed9j925f5.jpg
That makes it effectively impossible to guess the location of an image, provided that you don't allow people to browse around the directories on your server. This is the same method of privacy protection that Flickr uses, and it ought to be enough for most non-governmental privacy needs :)
basehttp://feeds2.feedburner.com/almosteffortless
i have disabled the isci initiator rescan renable then rescan still the same problem.
If you've used CVS before, you know that CVS doesn't play well with HTTP proxies. I was looking for a way to run cvsup on FreeBSD behind a proxy when I found a post on the FreeBSD China mailing list. It described using Proxychains with Desproxy to tunnel CVS over a SOCKS proxy through HTTP.ya habíamos escrito en un articulo anterior sobre la posibilidad de hacer flotar una carta e inclusive es vendida por 6.95 dólares en youtube.. vayaaa!!?El truco genero un gran debate entre los comentarios?
hey, tu?pagarías por aprender el truco??..Pues personalmente no pagaría si es que encuentro la forma de aprenderlo en el Internet, ustedes como yo, saben que en la web, como un poco de investigación, podemos encontrar muchas cosas interesantes..
Lo que más me impresiono de todos los comentarios recibidos, es que la mayoría pudo acertar de lo que de trataba!!.. Mis aplausos!!!..
Aquí les dejo algunas opiniones que vale la pena estudiar:
yo siento ke el tipo tiene algún tipo de hilo agarrado de su cabeza o de su pañoleta o lentes?
por ke miren, como mueve la cabeza al mover las cosas
las cosas se mueven exactamente como el mueve la cabeza!
pareciera ke tuviera un hilo de su frente o algo asi y al mover la cabeza, se mueven los objetos!
=)
eso es mi punto de vista, claro?
Es un truco relativamente sencillo, lo q tiene nuestro amigo en un hilo que le pasa por la cabeza baja por el cuello hasta la mano derecha. Porque si se fijan la carta cuando se para y la hace subir el baja dicha mano. y con el billete usa el mismo procedimiento.
Por lo menos este es el procedimiento q uso yo =)
Si os fijáis en el minuto 1:16 se le ve el hilo en el cuello, quizá sea un colgante, yo creo que efectivamente es el hilo.
Sin embargo, da un efecto bastante bueno =)
Saludos
Es fácil, tiene el hilo ese que se usa para pescar que es invisible, lo ata a la carta y el otro extremo a su oreja y pasa el hilo por sus dedos y la mueve
De que se trata el truco????
Todos acertaron, aunque por allí hubierón algunas cositas que corregir, pero todo bien!!!..La solución esta en el vídeo, pero lo que si quiero recalcar es que el hilo, está pegado detrás de la oreja para evitar que alguien lo vea?
El truco está explicado y revelado gracias al inmenso aporte de mis amigos lectores?
<embed pluginspage="http://www.macromedia.com/go/getflashplayer" src="http://www.metacafe.com/fplayer/330426/amazing_card_trick_revealed.swf" width="400" height="345" type="application/x-shockwave-flash" wmode="transparent"/>
Etiquetas de Technorati: Amazing Card Trick Revealed,flotar una carta revelado,hacer flotar una carta explicado,trucos de cartas,hacer volar unna carta,cartas,magia con cartas,magia gratis.
Ahora, pagarías por el truco???.. Pues es sencillo, simplemente ponle muchas ganas y buscate los implementos.. el resto es historia!!..
Las plantillas de código (code templates en inglés) son pequeños snippets de código fuente que se expanden automáticamente permitiéndonos modificar determinadas partes, mientras que otras partes se mantienen fijas. Aunque son una funcionalidad disponible en todo editor que se precie, no todo el mundo parece darse cuenta de su potencial: las plantillas de código son a los editores / IDEs lo que el DRY es a la programación.
Las plantillas se invocan normalmente escribiendo una pequeña palabra en el editor y pulsando una tecla o una combinación de teclas para ??dispararlas?. Para quien no conozca el mecanismo, las dos siguientes imágenes sirven como ejemplo: al escribir en el editor del NetBeans la palabra def y pulsar a continuación la tecla tab (primera imagen), obtenemos la expansión de una definición de un método en Ruby (segunda imagen).
El cursor queda situado automáticamente en method_name, permitiéndonos escribir el nombre que queramos, y una vez pulsamos enter o bien tab de nuevo, el cursor pasa al cuerpo del método, para que podamos seguir codificando.
NetBeans trae una serie de plantillas definidas por defecto, pero a través del menú Tools > Options > Editor > Code templates podemos acceder a un panel en el que, además de poder ver todas esas plantillas predefinidas, podemos crear las nuestras propias. Hay bastantes opciones a la hora de controlar cómo se expande la plantilla; para una descripción más exhaustiva de todas ellas, aquí está la página del wiki de NetBeans dedicada a las RubyCodeTemplates.
Aquí sólo vamos a mostrar la definición de la plantilla def tal y como viene ??de serie? con el NetBeans:
La sintaxis es sencilla:
Las posibilidades son muchas (no tantas como en el TextMate, quizás, pero muchas al fin y al cabo :P). Como ejemplo, sirvan un par de plantillas que utilizamos muy a menudo en nuestros editores:
Plantilla b <% ${0 default="block"} do %> ${selection}${cursor} <% end %>
Con esta plantilla definimos bloques en Erb, algo que hacemos muy a menudo ya que normalmente usamos helpers de este tipo para capturar las distintas partes de nuestro layout.
Una cosa que hemos aprendido con la experiencia: algunas plantillas, se utilizan tanto para rodear código ya existente como para generar código desde cero. En esos casos el truco de poner ${selection}${cursor} permite utilizar la plantilla para ambos fines. ¡Y otra cosa importante! Las plantillas que incluyen el parámetro ${selection} se pueden invocar de dos maneras: utilizando una tecla (p.e. tab), en cuyo caso contarán con una selección vacía, o utilizando la combinación Alt+Enter. En funcionamiento:
Plantilla t <${0 default="div"} id="${1 default=""}">${selection}${cursor}</${0}>
Esta plantilla la utilizamos para generar tags HTML con un id. En este caso el parámetro 0 se sustituye con el nombre del tag, tanto en la apertura como en el cierre. El parámetro 1 se sustituye por el id del elemento. Y de nuevo utilizamos el truquillo de la selección para poder rodear HTML si lo deseamos.
Son sólo dos ejemplos, pero en nuestro trabajo diario utilizamos un buen puñado de plantillas que nos permiten acelerar las tareas de codificación y evitar errores al teclear. Pensad en el código que repetís constantemente y definid vuestras propias plantillas para facilitaros la tarea; una vez lo hagáis no podréis vivir sin ellas.
Server push is the most efficient and low latency way to exchange data. If both the publisher and the receiver are publicly visible then a protocol such as PubSubHubbub or a simpler Webhook will do the job. However, if the receiver is hidden behind a firewall, a NAT, or is a web-browser which is designed to generated outbound requests, not handle incoming traffic, then the implementation gets harder. If you are adventurous, you could setup a ReverseHTTP server. If you are patient, you could wait for the WebSocket's API in HTML5. And if you need an immediate solution, you could compromise: instead of a fully asynchronous push model, you could use Comet, also known as Reverse Ajax, HTTP Server Push, or HTTP Streaming.
Coined by Alex Russell in early 2006, the term Comet is an umbrella term for technologies which take advantage of persistent connections initiated by the client and kept open until data is available (long polling), or kept open indefinitely as the data is pushed to the client (streaming) in chunks. The immediate advantage of both techniques is that the client and server can communicate with minimal latency. For this reason, Comet is widely deployed in chat applications (Facebook, Google, Meebo, etc), and is also commonly used as a firehose delivery mechanism.
Converting Nginx into a Long Polling Comet ServerA large entry barrier to Comet adoption is the implicit requirement for specialized, event driven web servers capable of efficiently handling large numbers of long polling connections. Friendfeed's Tornado server is a good example of an app level server that meets the criteria. However, thanks to Leo Ponomarev's efforts, you can now also turn your Nginx server into a fully functional Comet server with the nginx_http_push_module plugin.

Instead of using a custom framework, Leo's plugin exposes two endpoints on your Nginx server: one for the subscribers, and one for the publisher. The clients open long-polling connections to a channel on the Nginx server and start waiting for data. Meanwhile, the publisher simply POST's the data to Nginx and the plugin then does all the heavy lifting for you by distributing the data to the waiting clients. This means that the publisher never actually serves the data directly, it is simply an event generator! It is hard to make it any simpler then that.
Best of all, it only gets better from here. Both the client and the publisher can create arbitrary channels, and the plugin is also capable of message queuing, which means that the Nginx server will store intermediate messages if the client is offline. Queued messages can be expired based on time, size of the waiting stack, or through a memory limit.
Configuring Nginx & Ruby DemoTo get started you will have to build Nginx from source. Unpack the source tree, grab the plugin repo from GitHub and then build the server with the push module (./configure --add-module=/path/to/plugin && make && make install). Next, consult the readme and the protocol files to learn about all the available options. A simple multi client broadcast configuration looks like the following:
> nginx-push.conf # internal publish endpoint (keep it private / protected) location /publish { set $push_channel_id $arg_id; #/?id=239aff3 or somesuch push_sender; push_store_messages on; # enable message queueing push_message_timeout 2h; # expire buffered messages after 2 hours push_max_message_buffer_length 10; # store 10 messages push_min_message_recipients 0; # minimum recipients before purge } # public long-polling endpoint location /activity { push_listener; # how multiple listener requests to the same channel id are handled # - last: only the most recent listener request is kept, 409 for others. # - first: only the oldest listener request is kept, 409 for others. # - broadcast: any number of listener requests may be long-polling. push_listener_concurrency broadcast; set $push_channel_id $arg_id; default_type text/plain; }
Once you have the Nginx server up and running, we can setup a simple broadcast scenario with a single publisher and several subscribers to test-drive our new Comet server:
> comet-push-consume.rb require 'rubygems' require 'em-http' def subscribe(opts) listener = EventMachine::HttpRequest.new('http://127.0.0.1/activity?id='+ opts[:channel]).get :head => opts[:head] listener.callback { # print recieved message, re-subscribe to channel with # the last-modified header to avoid duplicate messages puts "Listener recieved: " + listener.response + "\\n" modified = listener.response_header['LAST_MODIFIED'] subscribe({:channel => opts[:channel], :head => {'If-Modified-Since' => modified}}) } end EventMachine.run { channel = "pub" # Publish new message every 5 seconds EM.add_periodic_timer(5) do time = Time.now publisher = EventMachine::HttpRequest.new('http://127.0.0.1/publish?id='+channel).post :body => "Hello @ #{time}" publisher.callback { puts "Published message @ #{time}" puts "Response code: " + publisher.response_header.status.to_s puts "Headers: " + publisher.response_header.inspect puts "Body: \\n" + publisher.response puts "\\n" } end # open two listeners (aka broadcast/pubsub distribution) subscribe(:channel => channel) subscribe(:channel => channel) }
nginx-push.zip (Full Nginx Config + Ruby client)
Downloads: 82 File Size: 2.8 KB
In the script above, every five seconds a publisher emits a new event to our Nginx server, which in turn, pushes the data to two subscribers which have long-polling connections open and are waiting for data. Once the message is sent to each subscriber, Nginx closes their connections and the clients then immediately re-establish them to wait for the next available message. End result, a real-time message push between the publisher and the clients via Nginx!
Long Polling, Streaming, and Comet in ProductionLeo's module is still very young and is under active development, but it is definitely one to keep an eye on. The upcoming release is focused on bug fixes, but looking ahead there are also plans to add a streaming protocol: instead of closing the connection every time (aka, long polling), Nginx would keep it open and stream the incoming events as chunks of data to the clients in real-time. Having such an option would make it ridiculously easy to deploy your own firehose API's (ex: Twitter streaming).
Last but not least, don't forget about the growing number of other available modules for Nginx, or if you are so inclined, get a head start on building your own by reading Evan Miller's great guide on the subject.
WebKit now supports explicit animations in CSS. As a counterpart to transitions, animations provide a way to declare repeating animated effects, with keyframes, completely in CSS.

With a recent nightly build, you can see the above animation in action.
Let??s take a look at how to use CSS animations, starting with an example of a bouncing box.

See this example live in a recent WebKit nightly build.
Specifying animations is easy. You first describe the animation effect using the @-webkit-keyframes rule.
@-webkit-keyframes bounce { from { left: 0px; } to { left: 200px; } }A @-webkit-keyframes block contains rule sets called keyframes. A keyframe defines the style that will be applied for that moment within the animation. The animation engine will smoothly interpolate style between the keyframes. In the above example we define an animation called ??bounce? to have two keyframes: one for the start of the animation (the ??from? block) and one for the end (the ??to? block).
Once we have defined an animation, we apply it using -webkit-animation-name and related properties.
div { -webkit-animation-name: bounce; -webkit-animation-duration: 4s; -webkit-animation-iteration-count: 10; -webkit-animation-direction: alternate; }The above rule attaches the ??bounce? animation, sets the duration to 4 seconds, makes it execute a total of 10 times, and has every other iteration play in reverse.
Now, suppose you want to party like it is 1995 and make your own super-blink style. In this case we specify an animation with multiple keyframes, each with different values for opacity, background color and transform.
@-webkit-keyframes pulse { 0% { background-color: red; opacity: 1.0; -webkit-transform: scale(1.0) rotate(0deg); } 33% { background-color: blue; opacity: 0.75; -webkit-transform: scale(1.1) rotate(-5deg); } 67% { background-color: green; opacity: 0.5; -webkit-transform: scale(1.1) rotate(5deg); } 100% { background-color: red; opacity: 1.0; -webkit-transform: scale(1.0) rotate(0deg); } } .pulsedbox { -webkit-animation-name: pulse; -webkit-animation-duration: 4s; -webkit-animation-direction: alternate; -webkit-animation-timing-function: ease-in-out; }
Again, see this example live in a recent WebKit nightly build.
Keyframes are specified using percentage values, defining the moment along the animation duration that the keyframe snapshots. The ??from? and ??to? keywords are equivalent to ??0%? and ??100%? respectively.
CSS Animations is one of the enhancements to CSS proposed by the WebKit project that we??ve been calling CSS Effects (eg. gradients, masks, transitions). The goal is to provide properties that allow Web developers to create graphically rich content. In many cases animations are presentational, and therefore belong in the styling system. This allows developers to write declarative rules for animations, replacing lots of hard-to-maintain animation code in JavaScript.
The other good news is that the WebKit on iPhone 2.0 already supports CSS Animations (as well as CSS Transforms and CSS Transitions). The iPhone implementation has been optimized for the platform so you get fantastic performance. Combining animations, transitions and transforms allows for some really impressive content.
We??re documenting these enhancements on webkit.org and are proposing the specifications to standards bodies. Note that since they are currently features specific to WebKit they are implemented with a -webkit- prefix, although the specifications do not use the prefix.
You can find more examples on Apple??s Web Applications Developer Center.
As always, leave feedback in the comments and file bugs at http://bugs.webkit.org/.
WebKit now supports explicit animations in CSS. As a counterpart to transitions, animations provide a way to declare repeating animated effects, with keyframes, completely in CSS.

With a recent nightly build, you can see the above animation in action.
Let??s take a look at how to use CSS animations, starting with an example of a bouncing box.

See this example live in a recent WebKit nightly build.
Specifying animations is easy. You first describe the animation effect using the @-webkit-keyframes rule.
@-webkit-keyframes bounce { from { left: 0px; } to { left: 200px; } }A @-webkit-keyframes block contains rule sets called keyframes. A keyframe defines the style that will be applied for that moment within the animation. The animation engine will smoothly interpolate style between the keyframes. In the above example we define an animation called ??bounce? to have two keyframes: one for the start of the animation (the ??from? block) and one for the end (the ??to? block).
Once we have defined an animation, we apply it using -webkit-animation-name and related properties.
div { -webkit-animation-name: bounce; -webkit-animation-duration: 4s; -webkit-animation-iteration-count: 10; -webkit-animation-direction: alternate; }The above rule attaches the ??bounce? animation, sets the duration to 4 seconds, makes it execute a total of 10 times, and has every other iteration play in reverse.
Now, suppose you want to party like it is 1995 and make your own super-blink style. In this case we specify an animation with multiple keyframes, each with different values for opacity, background color and transform.
@-webkit-keyframes pulse { 0% { background-color: red; opacity: 1.0; -webkit-transform: scale(1.0) rotate(0deg); } 33% { background-color: blue; opacity: 0.75; -webkit-transform: scale(1.1) rotate(-5deg); } 67% { background-color: green; opacity: 0.5; -webkit-transform: scale(1.1) rotate(5deg); } 100% { background-color: red; opacity: 1.0; -webkit-transform: scale(1.0) rotate(0deg); } } .pulsedbox { -webkit-animation-name: pulse; -webkit-animation-duration: 4s; -webkit-animation-direction: alternate; -webkit-animation-timing-function: ease-in-out; }
Again, see this example live in a recent WebKit nightly build.
Keyframes are specified using percentage values, defining the moment along the animation duration that the keyframe snapshots. The ??from? and ??to? keywords are equivalent to ??0%? and ??100%? respectively.
CSS Animations is one of the enhancements to CSS proposed by the WebKit project that we??ve been calling CSS Effects (eg. gradients, masks, transitions). The goal is to provide properties that allow Web developers to create graphically rich content. In many cases animations are presentational, and therefore belong in the styling system. This allows developers to write declarative rules for animations, replacing lots of hard-to-maintain animation code in JavaScript.
The other good news is that the WebKit on iPhone 2.0 already supports CSS Animations (as well as CSS Transforms and CSS Transitions). The iPhone implementation has been optimized for the platform so you get fantastic performance. Combining animations, transitions and transforms allows for some really impressive content.
We??re documenting these enhancements on webkit.org and are proposing the specifications to standards bodies. Note that since they are currently features specific to WebKit they are implemented with a -webkit- prefix, although the specifications do not use the prefix.
You can find more examples on Apple??s Web Applications Developer Center.
As always, leave feedback in the comments and file bugs at http://bugs.webkit.org/.
My team just opened a position for a Security Information and Event Management professional. This candidate will report to me in GE-CIRT but take daily direction from our SIM leader and our Lead Incident Handler. We're looking for a technical person who can not only administer our SIM, but also help our team implement our detection and response objectives and use cases in our SIM and related infrastructure. People are loving the C# Interactive Shell.
In the past people have embedded languages like Boo into their applications (MonoDevelop and Banshee for example both have options to embed Boo and a shell).
Zoltan designed a new system for Mono that allows developers to inject and execute code into running Mono applications. Paolo provided significant feedback and design guidelines for the code to be incorporated into Mono.
Thanks to both Zoltan and Paolo this functionality is now available through the Mono.Management assembly: you provide an executable and a PID, and the executable is injected and its Main method executed on the target process:
using Mono.Attach; [..] // Get a handle to a running Mono process. VirtualMachine vm = new VirtualMachine (pid); // Load hello.exe into the target process, and run it vm.Attach ("/tmp/hello.exe", "");You can use this for billions of things of course. You could patch running programs, you could attach logging software to a running program, or you could inject a C# evaluator into a live application and examine its state, or tweak it live.
Zoltan came up with a really cool extension to the the csharp command (this is the command-line C# Interactive Shell). The csharp command now takes an --attach command line argument and a PID.
The csharp shell can now use the Mono.Attach.VirtualMachine to injects itself into the remote process and then the client and server communicate through a couple of sockets.
For example, this is the sample that Zoltan used to pitch his idea for supporting attaching to the virtual machine. With the following you can pause a live Banshee process:
$ ps aux | grep banshee miguel 12359 17.0 2.7 141372 55708 pts/5 Sl+ 14:30 0:02 banshee-1 /usr/lib64/banshee-1/Nereid.exe $ csharp --attach 12359 csharp> using Banshee.ServiceStack; csharp> using Banshee.Gui; csharp> var s = ServiceManager.Get <interfaceactionservice>(); csharp> s.PlaybackActions ["PlayPauseAction"].Activate ();All of the code is now on SVN, you need both the mono and mcs modules from trunk.
A GUI ShellThe above commands are a tiny bit risky and are also limited to the shell.
The above commands will execute on a separate thread from the application, and any commands that you execute would be executed on a separate thread which could corrupt the state of your application.
So this weekend, I wrote a tool that integrates with Gtk# applications, its called gsharp and you can find it in the mono-tools module (it borrows some code from Banshee).
gsharp is a Gtk# version of the csharp command. What is important is that it also supports injection of the code on other programs, but makes sure that all the code executes in the Gtk# thread, by issuing all of its commands from the Gtk# idle handler. This means that it is safe to use gsharp with your Gtk# applications.
GUI version of the tool.
Here you can select which project you want to inject the GUI into:
Needs some work, show process names.
This version shows the gsharp tool attached to F-Spot, as I am not very familiar with the codebase, I can not do very much with it:
We will need to implement one of these as well for Windows.Forms applications. This should luckily be easy to do as most of the smarts live in the Mono.CSharp assembly (our embeddable compiler).
Security of AgentsA couple of weeks ago, I asked for people to weight in on a security concern for temporary files. This was for Zoltan's attach functionality.
The code is now implemented and I would love if security experts could do a source code audit of our implementation. And validate whether our assumptions are safe.
Here is the source code.
Amidst the cambrian explosion of alternative database engines (aka, NoSQL) it is almost too easy to lose sight of the fact that the more established solutions, such as relational databases, still have a lot to offer: stable and proven code base, drivers and tools for every conceivable language, and more features than any DBA cares to learn about. Not to mention that relational or not, they often times perform just as well as any other single instance key-value store when faced with large datasets - hence the reason why Riak, Voldemort and others use InnoDB as their data stores. Granted, the “feature bloat” is also the reason why a rewrite can be a good idea, but it also feels like this gray zone is too often overlooked in the NoSQL community - just because you are “NoSQL” does not mean you have to throw away years of work put into relational databases.
Setting aside the fact that we are yet to define what “NoSQL” actually is, some of the attributes that we commonly glob under this label are: document based, schema-free, distributed and “scalable”. The fact that being distributed and being scalable are not one and the same is a subject for another post, instead let’s take a closer look at what schema-free and document-based actually means. In fact, let me jump ahead: I am genuinely surprised that we are yet to see a schema-free engine built on top of MySQL. I know, I know, but suspend you disbelief for a second, because it is not as outrageous as it sounds.
Document Based: a Double Edged SwordThe original reason for and the benefit of the relational model is that by constraining the data schema (read, eliminating structural complexity of the data, or decomposing it into relations), you actually gain power and flexibility in the types of queries you can execute against your database. Said another way, normalized data design allows us to have a general-purpose query language, which allows for queries whose parameters we do not even know at design time, whereas denormalized designs do not. What we loose in flexibility of our data structures, we gain in our ability to interact with the data. Hence, in theory, if you have no way to anticipate the types of queries in the future, a relation model is your best bet. Lose some, win some, chose your poison.
At the same time, we all know that “no join is faster than no join”. The inherent disadvantage of decomposing your data is the required assembly. If you are looking for “speed” or “scalability”, then denormalizing your data is usually the first step. The disadvantage? Now you have introduced a number of potential anomalies into your data: updates, inserts, and deletes can cause data inconsistencies unless you keep careful accounting of all duplication. One-to-One, and One-to-Many relations are usually easy to manage, but Many-to-Many in denormalized schemas are nothing but a recipe for disaster. That is, if you care about consistency.
Finally, since you lose the power of a general purpose query language (SQL), you are now at a mercy of the DSL provided by your new database. Mongo, Couch and many others had to introduce their own query language constructs alongside "map-reduce" functionality to address the problem of querying arbitrarily deep records. Now, I am a fan of both, but frankly, none I have worked with so far are as clean, or as easy to understand as SQL (case in point) - with the downside of making me learn yet another query language.
Schema-free != Document BasedDocument based and schema-free are often used interchangeably, but there is an important difference: schema-free does not necessarily imply nested data structures. Likewise, just because MySQL is “relational” does not mean that it must be fixed to a predefined schema - at create time, maybe, but not at runtime. Intersect the two statements, and it means that there is absolutely no reason why we cannot have a schema-free engine in MySQL:
> schema-free.sql mysql> USE noschema; mysql> CREATE TABLE widgets; /* look ma, no schema! */ mysql> INSERT INTO widgets (id, name) VALUES("a", "apple"); mysql> INSERT INTO widgets (id, name, type) VALUES("b", "blackberry", "phone"); mysql> SELECT * FROM widgets WHERE id = "a"; +---------+---------------+ | id | name | +---------+---------------+ | a | apple | +---------+---------------+ mysql> SELECT * FROM widgets; +---------+---------------+--------+ | id | name | type | +---------+---------------+--------+ | a | apple | NULL | | b | blackberry | phone | +---------+---------------+--------+
As long as we avoid nested data structures, then there is no reason why we should be limited by the columns defined in our tables because we can compose and decompose any relation at runtime. Not only would this mean no migrations or need to store null values, but you could also keep all the tools, drivers, and the SQL query language while adding the full flexibility of being schema-free.
Schema-free DB on top of MySQLNot able to find any project that would give me this behavior, I ended up prototyping it myself over the weekend, and believe it or not, it works just fine. In fact, the output above is from a real console session with MySQL. All it took is an em-proxy server with a little low-level protocol and query rewriting, and all of the sudden, my MySQL forgot that it requires a schema. Take it for a test-drive yourself (you will need Ruby 1.9):
git clone git://github.com/igrigorik/em-proxy.git && cd em-proxy
ruby examples/schemaless-mysql/mysql_interceptor.rb
mysql -h localhost -P 3307 --protocol=tcp
> schema-free-mysql.rb # snip ... # build the select statements, hide the tables behind each attribute join = "select #{table}.id as id " tables.each do |column| join += " , #{table}_#{column}.value as #{column} " end # add the joins to stich it all together join += " FROM #{table} " tables.each do |column| join += " LEFT OUTER JOIN #{table}_#{column} ON #{table}_#{column}.id = #{table}.id " end join += " WHERE #{table}.id = '#{key}' " if key
mysql_interceptor.rb (MySQL Proxy in Ruby)
Downloads: 140 File Size: 0.0 KB
Of course, this is nothing but a cute code example nor does it even cover all the different use cases, but let us look at the feature set: driver support for every language (you can point Rails + ActiveRecord, JDBC, etc. at it out the box, no problem), tool support (GUI and command line), replication that works, basically impossible to corrupt, transactions, and so on. Not bad for half a day of hacking with a simple data model in the background:

Instead of defining columns on a table, each attribute has its own table (new tables are created on the fly), which means that we can add and remove attributes at will. In turn, performing a select simply means joining all of the tables on that individual key. To the client this is completely transparent, and while the proxy server does the actual work, this functionality could be easily extracted into a proper MySQL engine - I’m just surprised that no one has done so already. For a closer look, check out the proxy code itself, there are plenty of comments, which explain how it is all pieced together.
The gray zone of SQL vs NoSQLSo what is the point of all this? Well, I hope someone actually writes such an engine, because I believe there is a market for it. There is a lot to be said for a drop in, SQL compatible, schema-free engine, and unlike what the NoSQL propaganda may say, there is absolutely no reason why we can’t have many of the benefits of “NoSQL” within MySQL itself. There is no one clear winner for a database engine or model, so put some thought into your decision up front. Just because Mongo, TC, or Couch are 'document-oriented' or 'schema-free' does not mean they are necessarily better for your application. In the meantime, don't get me wrong, I am still rooting for all the NoSQL projects, as well as have high expectations for Drizzle - they are all doing fantastic work.
Un truco hecho por Criss Angel ahora reveleado por el mago enmascarado. Usando 2 chicas gemelas y algo de trucos… eso de verla sin estomago era algo raro y ahora viendo el video ya sé porque.
basehttp://www.comolohizo.com/2009/06/21/como-hacer-la-ilusion-de-desaparecer-el-estomago-de-una-persona/