Funny t-shirt about the undo shortcut

Ctrl + Z Because Shit Happens - T-Shirt by Lamborati

http://www.zazzle.com.au/ctrl_z_because_t_shirt-235341112241598883

More funny designs by Lamborati:
http://www.zazzle.com.au/lamborati/gifts

Long ago a brilliant developer invented the Undo command — probably one of the most important features to be added in computing history. It seems funny to me that today, in 2009, it is still a very rare feature to find on a website. This isn’t to say no one is doing it but more that it isn’t a common feature to find.

Using Lambdas For Undo Actions

In .NET you can use Lambdas to create a function and pass it around like an argument and then that argument can then be invoked at a later time in a different place. That said, with a little careful planning and a few correctly stored Lambdas, you could have a working ‘Undo’ model in your ASP.NET web sites For this example I’m going to use MVC but this would really work anywhere.

Warning: This is very crude code, more of a proof of concept, so you probably don’t want to use it in your projects as is.

Let’s start with an abstract controller that contains our Undo handling code.

[UndoController.cs]

using System;
using System.Web;
using System.Web.Mvc;

namespace UndoAction {

	//class that supports an undo action
	public class UndoController : Controller {

		#region Constants

		private const string SESSION_UNDO_ACTION = "Session:UndoAction";
		private const string SESSION_UNDO_MESSAGE = "Session:UndoMessage";
		private const string TEMP_DATA_UNDO_MESSAGE = "UndoResult";
		private const string DEFAULT_UNDO_MESSAGE = "Previous action was undone!";
		private const string DEFAULT_MISSING_UNDO_MESSAGE = "No actions to undo!";

		#endregion

		#region Undo Action Container (Session)

		//contains the current undo action
		private static Action _UndoAction {
			get {
				return System.Web.HttpContext.Current
					.Session[SESSION_UNDO_ACTION] as Action ;
			}
			set {
				System.Web.HttpContext.Current
					.Session[SESSION_UNDO_ACTION] = value;
			}
		}

		//the message to return in the view data for this action
		private static string _UndoMessage {
			get {
				return System.Web.HttpContext.Current
					.Session[SESSION_UNDO_MESSAGE] as string ;
			}
			set {
				System.Web.HttpContext.Current
					.Session[SESSION_UNDO_MESSAGE] = value;
			}
		}

		#endregion

		#region Setting Undo Actions

		/// <summary>
		/// Applies an undo action
		/// </summary>
		protected void SetUndo(Action action) {
			this.SetUndo(DEFAULT_UNDO_MESSAGE, action);
		}

		/// <summary>
		/// Applies an undo action with a return message for the user
		/// </summary>
		protected void SetUndo(string message, Action action) {
			UndoController._UndoAction = action;
			UndoController._UndoMessage = message;
		}

		/// <summary>
		/// Performs the undo action (if any) and saves the message
		/// </summary>
		protected void PerformUndo() {

			//check if there is an action
			if (UndoController._UndoAction is Action) {

				//perform the action and save the message
				Action action = UndoController._UndoAction;
				action();
				this.TempData[TEMP_DATA_UNDO_MESSAGE] =
					UndoController._UndoMessage;

				//and clear out the previous information
				UndoController._UndoAction = null;
				UndoController._UndoMessage = null;

			}
			//just save a generic message
			else {
				this.TempData[TEMP_DATA_UNDO_MESSAGE] =
					DEFAULT_MISSING_UNDO_MESSAGE;
			}

		}

		#endregion

	}

}

Basically, we create an abstract Controller that allows us to set an Undo action using a Lambda. You can also set a message for to return to the user that sumarizes what the action had done. This example uses a couple Session variables to hold the parts of the undo action, except I recommend that you create an actual class to house all of the information.

Next, let’s look at how we would actually use this controller.

[HomeController.cs]

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using System.Linq;

namespace UndoAction {

	//example of using undo actions
	public class HomeController : UndoController {

		#region Constants

		private const string SESSION_LIST_CONTAINER = "Session:ListContainer";

		#endregion

		#region Properties

		//a simple list of items for the list
		public static List<string> ListContainer {
			get {
				List<string> container = System.Web.HttpContext.Current.Session[SESSION_LIST_CONTAINER] as List<string>;
				if (container == null) {
					container = new List<string>();
					System.Web.HttpContext.Current.Session[SESSION_LIST_CONTAINER] = container;
				}
				return container;
			}
		}

		#endregion

		#region Actions

		//shows the list of items
		public ActionResult Index() {
			return this.View(HomeController.ListContainer.OrderBy(item =&gt; item.ToLower()));
		}

		//adds an item to the list
		public ActionResult Add(string phrase) {

			//format the value
			phrase = (phrase ?? string.Empty).Trim();

			//add the item if it isn't there yet
			if (!HomeController.ListContainer.Any(item => item.Equals(phrase, StringComparison.OrdinalIgnoreCase)) &amp;&amp;
			    !string.IsNullOrEmpty(phrase)) {
				HomeController.ListContainer.Add(phrase);
			}

			//return to the list view
			return this.RedirectToAction("Index");

		}

		//removes an item from the list
		public ActionResult Delete(string phrase) {

			//make sure the item even exists first
			if (HomeController.ListContainer.Any(item => item.Equals(phrase, StringComparison.OrdinalIgnoreCase))) {

				//since it exists, save the logging message
				this.SetUndo(
					string.Format("Restored '{0}' to the list!", phrase),
					() => {
						HomeController.ListContainer.Add(phrase);
					});

				//and then actually remove it
				HomeController.ListContainer.Remove(phrase);

			}

			//return to the main page
			return this.RedirectToAction("Index");

		}

		//tries to undo the previous action
		public ActionResult Undo() {

			//attempts to undo the previous action (if any)
			this.PerformUndo();

			//return to the main page
			return this.RedirectToAction("Index");
		}

		#endregion

	}

}

This controller allows the user to manage a simple shopping list with an Undo action to allow them to restore a deleted item. It is some ugly code, but you get the idea on how it works.

The important thing you should note is that the Lambda doesn’t refer to the instance of the class (this) but instead that the list is a static property. This is important to keep in mind as you develop something like this. When you create the Lambda action, you can’t refer to the instance that it was created in. Instead, you need to work with static properties.

Finally, let’s look at the ViewPage that is used in this example.

[Index.aspx]

<%@ Page Language="C#"
	Inherits="System.Web.Mvc.ViewPage" %>
<%@ Import Namespace="System.Collections.Generic" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
	<head>
		<title>Shopping List</title>
	</head>
	<body>
		<% IEnumerable<string> list = this.Model as IEnumerable<string>; %>

		<h2>Shopping List</h2>

		<p><% =this.Html.ActionLink("Undo Previous Action", "Undo") %></p>

		<% if (this.TempData["UndoResult"] is string) { %>
		<p><em><% =this.TempData["UndoResult"] as string %></em></p>
		<% } %>

		<hr />

		<table>
		<% foreach(string item in list) { %>
			<tr>
				<td><% =this.Html.Encode(item) %></td>
				<td><% =this.Html.ActionLink("Remove", "Delete", new { phrase = item }) %></td>
			</tr>
		<% } %>
		</table>

		<hr />

		<form action="<% =this.Url.Action("Add") %>" method="post" >
			<strong>Add an item:</strong>
			<input type="text" name="phrase" />
			<input type="submit" value="Add" />
		</form>

	</body>
</html>

The ViewPage itself is nothing fancy — If you’re working in a project you should create a strongly-typed view but in this example we just read the information we need and go on.

Using The Page

Below are a few screen shots of what happens as the user makes changes to the page. This example starts with a list of a few different items.

After removing an item from the list (the ‘Orange’) pressing the ‘Undo Previous Action’ button will restore the item. The custom message that was added is displayed (from the TempData field).

If you press the ‘Undo’ button again there aren’t any actions waiting anymore and the default message is displayed instead (no actions waiting).

Things To Consider

This code is just a sample of how you could implement and Undo function into your web applications. Here are a few things that you might want to keep in mind before starting something like this.

• Make sure that your Undo command doesn’t cause you to duplicate code. In this example, the undo command uses a different ‘Add’ approach than the actual ‘Add’ action on the controller. This could result in duplicated code or incorrect results.
• Determine if you can queue up ‘Undo’ commands. This example can only do one action at a time, but you could potentially create a Stack of actions that are executed in the reverse order that they were added.
• Could you use the same concept to ‘Redo’ a command after it has been undone?
• Be careful with your context – Don’t use ‘this’ inside of your Undo Lambdas.

Anyways, just an interesting concept to share. This approach requires a lot more thought but could pay off in the end.

Do you have a web application that could benefit from an ‘Undo’ command?

Hey guys!

Finally, after a painstaking wait, I’m gonna write this!

Sorry about that…it has been a crazy month, with us moving and pipes bursting and attending the GIS and all that…it’s been hard to take time out and blog.

Well, without further digressing, here it is.

Going to GIS…literally blew my mind away. I mean, in the mere presence of those power players, the patina of awesomeness they exuded, I felt humbled. I truly felt a world of difference between the audience and the stage, despite the speakers’ efforts at convincing us that there’s not a lot of distance betwen us (literally…and figuratively).

So then, I thought, ‘well, the pro guys speaking up there on stage SHOULDN’T be lying.’

The more I pondered, the more I became convinced that there’s not so much difference between ‘you and me’ (quote unquote, ‘you’ being us newbies, and ‘me’ being the gurus).

I mean, looking back at the SIMPLEST model of internet marketing available, email marketing, all you have to do to get started:

1. Conduct market research (finding rabid buyers)
2. Conduct keyword research (finding those that have a modest search volume, and which you can dominate, without much competition)
3. Buy your domain name and webhosting, and transfer your DNSes to your webhost (you have to wait for it to propagate – that’s to circulate in the world’s DNSes)
4. Find a product (either buy PLRs, that’s Private Label Rights, or MRRs, Master Resell Rights) or develop your own
5. Design the marketing graphics that go with it (banner ads, text ads, front covers, etc.)
6. Build a squeeze page and FTP it to your webhost’s server
7. Link the optin form to your autoresponder
8. Write a series of emails (start with 7?) without the greens in mind and including a load of content (use ethos, logos and pathos to help elicit empathy and establish rapport)
9. Research related products that have affiliate programs
10. Contact the support team to get a sample portion of the product and review it
11. If it’s worth it, sign up. If the quality is awful, then search for another one.
12. Check conversion rates and commission payout rates (reputation of those affiliate programs and webmasters) to make sure you actually get the commissions on time.
13. Get your affiliate links.
14. Post them whenever the etiquette is appropriate in your emails (content that links to it).
15. Automate your emails using an autoresponder service.
16. Promote your squeeze page using traffic generation techniques (Q&A sites, Social media, Social bookmarking, eZines, article directories, Blogs, review sites, etc.)
17. Wait for commissions to pour in.

I mean, when you put it like that, it sounds W-A-A-A-A-Y more logical, doesn’t it?

The only difference is in the numbers. We’d probably make a few do

Lots of $$

llars – a couple hundred of bucks, while the gurus are doing this in the hundreds of thousands of dollars PER MONTH, and possibly 7-8 figures, depending on their viral marketing strategies.

So, what’s the catch?

After all, these 17 steps LOOK simple enough, aren’t they? They LOOK simple enough, don’t they…..

The catch is simple. It’s the terra incognita factor in play again.

It’s the fear of the unknown.

It’s the technicalities.

GUESS WHAT?! IT’S REALLY NOT THAT DIFFICULT!

But again, it’s not the separate components that are difficult, it’s STRINGING THE COMPONENTS TO FORM A COMPLETE PICTURE THAT IS.

What do I do with the domain name? How do I configure custom emails? How do I access them? What services should I sign up with? What happens when I do build my squeeze page?

Again, it’s really as the gurus said on stage.

‘…most people fail…because they get CAUGHT UP.’

Period.

You get caught up in life, caught up in the finer details of each step, caught up in a snag…

There’s no end to it.

So, WHAT’S THE SOLUTION???

That’s the whole point of this post. I really wanted to share my thoughts to this seemingly impossible conundrum…

But instead of being direct, I wanna use a slightly roundabout manner of expression…

So, I’m going to leave with Ewen’s slightly comical (but true) quote, with a slight extrapolation…

‘…the most important skills you must have in Internet marketing are: copy and paste.’

- Ewen Chia

A slight addition:

‘…the most important skills you must have in Internet marketing are: copy, paste AND UNDO.’

No biggie. Just one more shortcut, one more key sequence to remember (*hints hints* UNDO)…

There it is.

Do share your thoughts here (leave a comment)!

Everything in our world is about convenience: saving time because it’s priceless. Thus, the invention of keyboard shortcuts doesn’t really come as a surprise, but I’m still very grateful to whoever came up with such a concept (probably someone who didn’t like using a mouse). Most are pretty conventional, such as ctrl + i for italicise, ctrl + s for save, ctrl + n for new file/folder, so on and so forth. Substitute “ctrl” with “command/apple” key for Macs. So I never really understood why ctrl + z was undo, instead of something like, say, zip the file. I know ctrl + u is underline, so that’s taken, but why not make the underline shortcut ctrl + shift + u, and use ctrl + u as the shortcut for undo? Then it clicked: the “z” key is closest to the ctrl/command key. Hence one doesn’t have to stretch one’s fingers allllll the way over to the “u” key and waste all that energy and effort. What an ingenious decision!

Still, there are downsides to ctrl + z. Sometimes when I write or draw something on paper, and make a mistake, I catch myself doing the “ctrl + z” motion with my left fingers. It’s a big disappointment, especially when nothing happens. Oh well. If even real life could be controlled by shortcuts, everything would get too fast, and I won’t be able to catch up with myself. Otherwise, I love my keyboard shortcuts. Especially in Photoshop.

public class Undoer
    {
        private static Stack sUndoStack = new Stack();
        private static Stack sRedoStack = new Stack();
        public static int UndoStackCount { get { return sUndoStack.Count; } }
        public static int RedoStackCount { get { return sRedoStack.Count; } }

        public static bool InsertEnabled = true;

        public static void Insert(Func pObj)
        {
            if (InsertEnabled)
            {
                sUndoStack.Push(pObj());
                sRedoStack.Clear();
            }
        }

        public static T Undo()
        {
            var tObj = sUndoStack.Pop();
            sRedoStack.Push(tObj);
            if (sUndoStack.Count > 0)
            {
                return sUndoStack.Peek();
            }
            return default(T);
        }

        public static T Redo()
        {
            var tObj = sRedoStack.Pop();
            sUndoStack.Push(tObj);
            return tObj;
        }

        public static bool CanUndo { get { return sUndoStack.Count > 0; } }

        public static bool CanRedo { get { return sRedoStack.Count > 0; } }

        public static void Init()
        {
            sUndoStack.Clear();
            sRedoStack.Clear();
        }

    }

As many of you saw during our Sierra Lodge trip, Gracepoint puts on a huge performance called G-Live!  We got a chance to see various skits from the past two GLive performances.  We actually got a sneak preview prior to the official GLive release.  But that was only two clips out of the entire performance.  So many of us were left thinking, “man, that was awesome!  I want more Glive!”  Well you couldn’t!  At least until now! The official GLive DVDs have been announced! To pre-order your DVDs, click here!

To get you guys pumped up about it, here the intro video:

While this particular post might not have a whole lot to do with social media, it reminded me of a conversation I had with a former client that made me laugh, so I wanted to highlight the feature

Many rely on the popular Gmail email service and don’t use Outlook or other email formats otherwise found in a business setting.  Gmail is a great resource as it’s free and gives you many of the same capabilities as traditional services. However, in the past there has been one feature missing from Gmail that appears in other email services: the recall button. While not necessarily new news, I wanted to take the time to point out that Gmail now has a “recall” feature, or more appropriately labeled “undo.”

The undo feature allows users a 5 second window after they hit the send button to recall their email. Now, there are a whole hosts of reasons why you may want to recall an email. Reasons could include: an incorrect recipient, wrong draft email or possibly a previously missed spelling error. For whatever reason, I can safely say that most of us at one point in time have pushed the send button and immediately said “oh crap.”

Gmail also has a similar function– a service that once activated makes you solve a series of math problems and only allows your email to go out during specific hours (which default to Friday and Saturday nights). The service is supposed to stop “drunk emailing” using the notion that if you’re drunk it will be hard to do math and may deter you to not send an inappropriate email and falls in line as a preventative measure for Gmail users.

Says Michael Leggett, User Experience Designer, “This feature can’t pull back an email that’s already gone; it just holds your message for five seconds so you have a chance to hit the panic button. And don’t worry – if you close Gmail or your browser crashes in those few seconds, we’ll still send your message.”

For the skeptics out there saying that individuals should be responsible enough workers to check and double check their emails, Google included some statistics to justify the undo button. The study showed that 87% of executives reported they have mistakenly sent or received an email or other electronic message.

Email is an important aspect to our daily routine and, if you’re using Gmail, you now have the capabilities to join the other masses who have the option to recall or undo an email. Because, let’s face it, we are all human and humans make mistakes.

Iram Martínez / revistawego@gmail.com

La Universidad de Sevilla confirma su apuesta por las nuevas tendencias y la música electrónica (que no todo lo que organice la hispalense tiene que ver con música clásica, copón) y organiza el segundo Electroshock US que se celebrará del 5 al 7 de noviembre en La Pista Digital (mira por aquí el mapa) y en la Sala WAM (Hotel Los Lebreros).

La descarga de esta nueva edición la proporcionarán, ojo al cartel: Bedroom Comunity, Christ, Voodooetnies, Tensión Co, Hauschka, bRUNA y Undo.

Sigue leyendo para ver la programación, precios y datos sobre los artistas

Jueves 5 de noviembre

Pista Digital (C/ Madame Curie – Isla de la Cartuja), a las 21:00 h.

Comunidad Universitaria de la Universidad de Sevilla 3€. Entrada general 6€

Venta de entradas en el local a partir de las 19:00 h.

Chris Horne es la única persona de la que no se puede decir que tiene influencias de Boards of Canada porque conoce a los hermanos Eoin desde el colegio, y juntos han compartido multitud de grupos, risas y cervezas en los pubs de Edimburgo. Comparte con ellos su afición al sonido de los sintetizadores setenteros, las melodías agridulces y las texturas desenfocadas. Desde que lanzó en 2002 su primer EP “Pylonesque”, ha probado ser un individuo creativo que ha sabido forjarse una carrera única en cuanto a belleza se refiere.

Voodoo Etnies

Tras el nombre de Voodoo Etnies está el nombre de uno de los más prometedores productores de hip-hop español. El sevillano se caracteriza por fundir en sus ritmos la tradición rapera más clásica con influencias de lo más variopinto. Ha trabajado con MCs como Tote King, Putolargo y Shotta, con quien gira en los últimos meses. Tiene recién editado el EP “Unfinished Works” con el sello británico A Future Without, que cuenta entre sus filas con músicos tan reputados como Adrian Utley, de Portishead.

Viernes 6 de noviembre

Sala Pista Digital (C/ Madame Curie – Isla de la Cartuja), a las 21:00 hrs.  Comunidad Universitaria de la Universidad de Sevilla 3€. Entrada general 6€.  Venta de entradas en el local a partir de las 19:00 h.

Hauschka

Volker Bertelmann se ha pasado muchos años en bandas de pop y rock, peor su pasión es el piano de cola. Acompañado de ese instrumento mezcla irreverencia, delicadeza y géneros de distintas épocas. Lo suyo no es solamente tocar el piano sino que introduce (literalmente) en el distintos objetos, juega con sus piezas y consigue sonidos que no podríamos imaginar que vienen de un instrumento tan clásico. En su último trabajo “Ferndof”, incorpora al discurso la presencia de dos chelos, formación con la que se presentaría en Electrochock US 2009.

TENSION Co.

La parte local de la noche la ponen Tensión Co, dúo electrónico formado a finales de 2006 por Miriam Blanch (aka MIR), laptop y bajo (que toca, procesa y manipula en directo), y José Mª Pérez-Flor (aka Synthetic Mouse), laptop.

El grupo sevillano mezcla el noise más atmosférico, el minimalismo digital, la electroacústica y músicas de difícil tránsito que requieren una escucha un poco más comprometida. La música de TENSION Co. es electrónica ambiental oscura y minimal, ruidista y de intensidad creciente. Consiguen crear extrañas y personales atmósferas que enganchan y desconciertan a la vez. Para sus actuaciones en directo se arman de dos laptops y un bajo asistido con Pd (Pure Data) y tocado con diferentes objetos y pedales de efectos, con los cuales desarrollan su música o no-música, experimental, tensa e hipnótica.

Dj bRUNA

Sala Wam (Hotel Los Lebreros), a las 00:00 h. Entrada libre.

Carles Guajardo, quien artísticamente se hace conocer como bRUNA, tiene por objetivo poner el acento feliz en sus sesiones de DJ. Esa habilidad ha sido demostrada de sobra en magníficas sesiones para salas como Club13, festivales como Sónar e incluso novedosas actividades “escolares” como la Red Bull Music Academy celebrada en Toronto en 2007. Y esa intención, también, es la misma que subyace en su disco de debut, el luminoso “And It Matters to Me to See You Smiling” (spa.RK, 2009). Es algo que queda claro desde el mismo título, que certifican el tono desenfadado y alegre de la mayoría de los temas y el infeccioso acento pop con el que compone sus melodías.

Sábado 7 de noviembre

Bedroom Community

Sala Pista Digital (C/ Madame Curie – Isla de la Cartuja), a las 21:00 hrs. Venta de entradas en el local a partir de las 19:00 h. Comunidad Universitaria de la Universidad de Sevilla 3€. Entrada general 6€

El sello islandés Bedroom Community es una plataforma que funciona en parte como comuna artística y en parte como refugio creativo. Como comuna artística, porque cada vez que producen un disco, los cuatro miembros de la comunidad (Nico Muhly, Ben Frost, Valgeir Sigurðsson y Sam Amidon) participan en el proceso de grabación, de manera que siempre existe un cierto tono de complicidad, un “sello” de calidad que los hace únicos. Y como refugio creativo, porque los cuatro músicos suelen trabajar en otros entornos, como músicos de sesión, arreglistas o productores para grandes estrellas del pop. El resultado de esta actitud es un puñado de discos tan inconformistas como delicados. Pequeñas piezas de orfebrería que mezclan pop, rock, ambient y música electrónica, y que gustan de adornarse con recursos de música contemporánea, arreglos medievalistas y detalles robados a la música de bandas sonoras.

A Electroshock US vendrán con su último proyecto “The Whale Watching Tour”, un espectáculo en el que los cuatro músicos, acompañados de violines, guitarras, percusiones, un piano de cola y todo tipo de cachivaches electrónicos, tocan un repertorio en el que se mezclan algunas piezas sacadas de sus distintos discos, otras hechas expresamente para la ocasión e incluso alguna versión. Todo ello acompañado por una espectacular puesta en escena, que incluye visuales.

Dj Undo

Sala Wam (Hotel Los Lebreros), a las 00:00 h. Entrada libre. 00:00 h. Entrada libre.

DJ, productor y propietario de un sello discográfico, Undo es un hombre de muchas caras. Muchas son las actividades que realiza este músico que tuvo una carrera sólida antes de convertirse en la revelación de la Barcelona de principios de milenio. Gabriel Berlanga ha sido compositor, vocalista, guitarrista y bajista en numerosas bandas de pop-rock desde muy pequeño. A mediados de los años noventa, descubrió el emergente mundo de la electrónica de baile, y se dejó fascinar por él. Gabriel empezó a coleccionar discos, pinchar y experimentar con los sonidos electrónicos: tocando viejos sintetizadores, loop-samplers y efectos de guitarra.

Recently, I ran into some problems with data dependencies and garbage collection in my bespoke model classes. Several classes in my model code register as observers of other model classes using either KVO or via NSNotificationCenter.

Although I’m using garbage collection, I was trying to be a good boy by implementing a dispose method on some of these model classes so that they could de-register as observers when they were no longer an active participant of the model.

The problem with this approach is that various Cocoa classes, such as NSUndoManager, don’t easily offer me the opportunity to invoke my dispose method (say for example when the redo queue is cleared by registering a new invocation). There are a few different solutions to the problem. In my case, registering the “activation” and “deactivation” of my model classes (i.e. the adding and removing of themselves as observers) with the NSUndoManager is the one I opted for.

In the course of implementing this code, I played around with using NSObject's finalize method as a way to de-register my observers, rather than inducing the undo manager to invoke my own dispose method. Generally speaking, I try to stay away from finalize methods in garbage collected languages, and Objective-C is no exception. Apple cautions against the madness of using finalize methods for performing any serious work.

All that said, it got me thinking about where exactly Apple expects objects to de-register their KVO and NSNotificationCenter observers in the general case. The problem with remove observers in finalize methods are several:

1. You are forced to introduce a finalize method where you otherwise wouldn’t have to. Not good for performance and can open up a Pandora’s box of non-determinism.
2. The finalizer’s of objects collected in the same cycle are not guaranteed to run in any particular order. So de-registering object A as an observer of object B in object A’s finalize method might happen after object B is already collected (i.e. when it’s invalid), leading to “Cannot remove an observer … for the key path … from … because it is not registered as an observer.”
3. The de-registration of observers happens at a non-deterministic time (i.e. whenever the garbage collector gets around to running).

As far as items #1 and #2 are concerned, there is a better way, which is (wait for it…) to do nothing.

From the docs on NSNotificationCenter's addObserver:

“As a convenience, when built with garbage collection, you do not need to remove any garbage collected observer as the system will do it implicitly.”

And as of the November seed of 10.6, this is also now true of KVO. The seed note “Automatic Removal of Finalized Key-Value Observers When Running Garbage-Collected (New since November seed)” describes the following:

“In Mac OS 10.6, explicit removal of observers when they’re finalized is now never necessary. KVO automatically removes observers as they’re collected. Actually, in Mac OS 10.6 all invocations of -[NSObject(NSKeyValueObserverRegistration) removeObserver:forKeyPath:] and -[NSArray(NSKeyValueObserverRegistration) removeObserver:fromObjectsAtIndexes:forKeyPath:] do virtually nothing when either the receiver or the observer is being finalized (so it’s not very bad for performance to leave them there in applications that still have to run on Mac OS 10.5).”

So at least in Snow Leopard after the November seed, you can just let it ride and the system will take care of cleaning up your KVO and NSNotificationCenter registrations.

As for item #3, well it’s either playing games with regularly invoking NSGarbageCollector's collectExhastively or implementing a dispose pattern.

Every time I tell students about the lab feature Undo Send within seconds they are giddy with excitement about how much this is going to save them. That’s right – going to. Inevitably their thoughts go back to an email they wish they could have unsent but the possibility of never having that worry again is mesmerizing.

At a student club leader presentation two weeks ago I reviewed a number of labs and explained Undo Send. Note – I had approximatley 5-10 minutes to review the entire Google Apps suite so I was going quickly. About 3 seconds after I explained Undo Send and had paused for effect one student literally gasped with jaw agape! You could see the “OMG HFCIT FTW” look across her face. She was elated.

Though not at profound a reaction, possibly because of the brain melt that has affected them, students also smile a the fact that they can change the undo time from 5 seconds to 10 seconds.

Tasks has graduated to become an official part of GMail, when will Undo Send.

Nobody has snubbed the lab feature. Yet. Will someone? I’d be amazed.

Read the GMail blog on Undo Send:
http://gmailblog.blogspot.com/2009/03/new-in-labs-undo-send.html

There is so much exciting stuff happening in my life right now, I can hardly keep up with it all even in my own mind! My high at the moment is a bit of serendipity that happened yesterday.

Last week, I “cheated” on the knitting I was supposed to be doing, and took the time to knit my first serious Fair Isle project. My only previous experience with Fair Isle had been a felted container, so I could get by with doing a lazy job. However, the moment I saw the new clock project from Knit Picks, I was enchanted with the concept of knitting myself a clock.

It was very disappointing that the only way to get the pattern was to buy the whole kit, and there was only one colorway. I find the choice of colors quite unappealing, and in my house, they would be downright appalling. However, I wanted to do this badly enough that I bought it anyway. The Caribbean corals, banana, and periwinkle shades can go into my stash and be used for doll knitting or other such things in the future. I added a heap of pinks, browns, and greens to my order, and when it all arrived, I knew I’d done the right thing.

I spent a lovely evening playing with the colors, using the black and white mode on my camera to compare the intensity of the colors. Fair Isle that doesn’t have gray scale contrast between colors used with each other appears muddy – a problem I noted in the kit colors, by the way.

I ended up with a selection of 10 colors that felt perfect to me, plus the bare, which is used for the ribbing that gathers behind the face to hold the knitting in place.

This is half again as many colors as is on the pattern, so I sat down with Knit Visualizer and redesigned the color layout. While I was at it, I just made a 12 repeat wide chart for myself so I didn’t have to risk going back and forth between the separate number charts and the main chart during the knitting.  I knew that was a recipe for trouble!

Once the planning was finished, the knitting seemed to go very smoothly, and it was terribly addictive!

I started in the wee hours of Sunday morning, and the actual knitting was done by Wednesday morning – just 3 days later!

I was so proud of how tidy my back looked, and my knitting is very smooth on the front – not lumpy in the least. I was amazed I’d managed so well, and had definitely not expected my first project to turn out so nicely.

A two hour marathon resulted in a couple million ends being sewn in (picture above showing only part of them), leaving me with nothing to do except be impatient to be able to have a finished  clock.

Here’s where things started getting a little bit more challenging, though… but I’ll get to that in a minute. First, a few comments about the pattern and instructions…

• For some really odd reason, the instructions say to use a provisional cast on. I can’t for anything figure out why. I opted for a long tail, since that is not bulky, and it is just fine. My completed clock face is gathered smoothly and easily to the back by running a gathering strand up and down through the ribbing, and there’s more support for the gathering, because it’s not just through a single loop of fingering weight yarn.
• I added several plain color rows between the ribbing and the beginning of the design, and I started knitting the design just a little lower on the chart. I wanted to have that band of little pink roses around the edge of my clock.
• The decreases worked really nicely until the very end. There the designer has 8 rows knit on the remaining stitches, and for me, that funneled. It’s just too many rows of the same at that small of a diameter. (Think about the Pi Shawl concept and that will make sense.) I’ve already gone back and picked out one row, which made a definite improvement. I might remove one more, but I’m waiting to see what happens when I assemble my clock before I commit.
• If I knit something like this again, I might try knitting from the center out instead of the outside in. I found it extremely difficult to work the last few rows. It was very tight quarters.
• Instructions say to just tie the ends together and cut them off. I experimented with that, but I found it left a jog in my Fair Isle design, so I did take the time to darn each end into the work, easing the design back toward looking more seamless. I think it was worth the effort. I don’t notice the seam unless I look for it.
• Instead of starting my rows at center top, I started somewhere less conspicuous, making the jog even less noticeable.
• There is an admonition in the instructions that totally confuses me. If I’d followed it the way it reads to me, I’d have had my numbers going the wrong direction around the dial. It says to be sure to put the numbers on in descending order. However, when you knit, you actually have to knit them in ascending order, or you will have a backwards clock. Just take some time to be sure you are going to have what you want when you are finished – like the carpenter measuring twice and cutting once, it is worth checking and double checking this before you knit very far.

Now, about the rest of this project… The finishing instructions say to wrap your hat around a paper plate, punch a hole in the middle for a craft store clockwork, and hang it on the wall. I’m really proud of my knitting, and I have a Victorian style home with antique clocks. The paper plate thing was going to look seriously tacky – or at least very out of place here, no two ways about it! I’ve probably spent more hours working on finding a way to finish this and have something that looked fantastic than I’ve spent on the knitting to this point. However, I’ve finally had a serendipity happening that has resolved the challenge. Yesterday I dropped into the clock shop while I was in the city to teach lace knitting classes.

While conducting my other business, I mentioned my knitted clock and my needs. It turned out that they happened to have a gutted case in the shop, and believe it or not, it was not only just the right size, but the style was appealing, and the case was from the 1980’s , so no guilt about messing up an antique. It’s an antique style case, but of modern manufacture, with solid, heavy wood. I don’t know wood well, but I think I’m guessing it is oak.

And the back is wide open, which is going to make it much easier for me to make any modifications I need to do. A closed back, antique case would have made it more challenging to use an electronic movement. This set up is perfect, as it’s designed to use exactly what I was hoping to install.

Best of all, they let me have it for just $25! There is no way I’d have been able to create any sort of a case for that price with my limited woodworking skills, let alone a fancy case like this one. Today I called Klockit for the umpteenth time, finally placing an order with them. All the inner workings are on the way, along with a glass bezel, arriving hopefully early next week. (I have to put in a gold star rating for this company, by the way. I’ve spoken and/or emailed multiple clock related companies in the past week, and the service I got from Klockit has been so far above and beyond anything I got elsewhere that I doubt I’ll look to the right or the left again. They are fantastic people, and so helpful that it’s a delight to work with them, even if you don’t quite know what you are doing.)

A little bit of Un-du (I love this stuff!) has already removed the presentation plaque from the front of the case, leaving not a trace of residue. So, now my only problem is to find something other than my dinner plate to use as a dial disk. It has to be thin enough for the clockwork shaft, strong enough to not buckle from the knitting being stretched around it, and I have to have a way to get it cut in a perfectly smooth, 10.25″ disk. I’ll be puzzling over that problem and Briwaxing my clock case while I wait with eager anticipation for my Klockit package to arrive.

I know… Patience is a virtue and all that… Besides, it’s not like I don’t have anything else to do here, right?

Abridged Version

Let Go is the stopping of all AY activities.  LG is no thought.  LG is no Feeling.  LG is mindlessness.  LG is a moment or a window that allows something to come through.  Typically LG allows insights or Ah-Ha’s to come to us.  LG can happen physically, psychologically or spiritually or a mix of both.  The ways we LG are as varied as each and every one of us is varied.  We can LG as individuals or LG in groups of any rank or size.  LG is hard for adults to do. 

Unabridged Version

LG is not giving up or quitting.  Quite the opposite, LG allows us to move forward and beyond where we are by letting go to the next thing.  LG can happen in the Head but not in the Heart or vice versa.  For example, I can lose weight and know intellectually that I’m 50- pounds lighter but still feel and believe that I am a fat person!.  In this scenario I have not let Go as a Whole. 

LG happens all the time but some people find it very difficult to do.  Others tend to be predominantly LG and need the rest of the LeToonz facets to be bring balance into their lives.  LG people often keep others from getting stuck on something. Let Go might seem like a 60’s kinda’ character but it’s not as simple as that. 

LG can happen in a split second.  LG may take no time at all to happen or may happen over a long period of time.  The time it takes to stop feeling the pain of losing someone special in our lives is an example of this.  We can LG slowly about something in our hearts while we LG about that same thing quickly in our Minds.  LG is not fully complete until the Head and Heart have LG together.  Most often LG happens so fast we can say it occurs as a moment in time. Like having just one, or a bunch, or a whole string of Ah-Ha’s while taking a shower, glancing out a window, or while taking a walk in the woods.  We LG many, many times without sensing the time it takes to LG one bit. And with that much LettingGo and Ah-Ha’s happening time just flies.  Interesting isn’t it.  Like AskYouself, LetGo or Letting Go, can happen in the Head or the Heart or both at Once.  We call the both at once event The Whole.  LG comes after AY and before Ah-Ha on Le Wave.  LG allows Ah-Ha or insight to happen.  Without LG we can’t learn or evolve into the 6W’s – The Who and What, When and Where and How and WHY of each and every one of us whether that US is ourselves, our families, friends, teams or group of any size. That size includes the world by the way.

Andrew Newnham

By Andrew Newnham (Fruition Data)

A very important question should be asked before installing any new piece of software. “Can I undo what I am about to do?”
Now before you say to me “Well yes, I simply click the uninstall button”, I realise that you can press the uninstall software button and the software will uninstall. But what about the changes which that software has done to your computer? These are changes such as modify your existing data files to suit its new format, uninstall other pieces of old or conflicting software, or worst of all, the software which never quite uninstalls properly, which leave bits of itself around to haunt you for months to come.

If you ever read a project plan written by a reputable IT company it’ll usually include a plan on how they can “roll back” any software change. The process for undoing what you have just done may be more complex than simply clicking uninstall.
So how does a company come up with these plans? Well it’s usually based on their consultants experience and knowledge of what the software does when it is working, and more importantly what the software does when it is not working. Often these plans have been generated after many hours of extensive testing and even then the choice to install it on a customer’s computer is not often taken lightly.

So before you next download that “free” piece of software from the web or purchase that “excellent” deal down at your local computer store, ask yourself “Can I undo what I am about to do?”

Photoshop can be a like a weight lifting freak on Asterix potion… this program can crunch amazingly big files it can bench presses 600mb files without popping a blood vessel…

But sometimes when you swap / close / copy / paste / create new files etc it forgets to clean up all the old junk laying around and can get a bit slow. Thats where the Purge menu rocks… When you feel photoshop getting slow and cranky (especially if you need to alternate between photoshop and say illustrator or indesign etc)… maybe you have just copy pasted a huge file?… Go click the Edit menu with your meaty digits and select Purge. You can choose between clearing just the stuff in the clipboard (your copy / cut memory), histories, undos or completely erase all junk (including undos BTW)… This is great at keeping your system stable after a few hours of work… Just remember that it will remove your undos on your file so far created (no really focus on this…don’t blame me!)

• Tata, reci mi, kako sam se rodio?
• Dobro sine, znao sam da ćeš me jednog dana to pitati.
Evo ovako…
Tata i mama su napravili jedan copy/paste na jednom chatu na MSN-u.
Tata je onda dao mami sastanak preko email-a u WC-u u jednom cybercafe-u.
Onda je mama napravila nekoliko download-a s tatinim memory stick-om.
Kad je tata bio spreman za upload, primjetili smo da nismo stavili firewall.
Kako je bilo kasno da se koristi undo, a ni delete više nije pomagao, 9 mjeseci kasnije nam je stigao za*ebani virus…