So, the whole episode is about analyzing if is MPLS tunneling. Maybe somebody asked the question or maybe there is some disagreement in the industry.

I found it very interesting (and fun, as usual) but after listening to the show it got me thinking: it’s the wrong question. It’s not if MPLS is tunneling, but if MPLS *can be used for* tunneling.

So before going deeper I also have to say that I have never implemented MPLS; I have labbed it but that’s about it. I don’t consider myself to have enough foundations or experience as these guys. I hope not to shoot myself in the foot. With that said…

Tunneling is an application of encapsulation. Transport, multiplexing and delivery are other applications of encapsulation. Protocols encapsulate their payload. I see Ethernet as layer 2 “delivery”, IP as layer 3 “delivery” (or “transport” across multiple layer 2 domains), and 802.1Q as 1-factor multiplexing. I’m thinking TCP and UDP are 2-factor multiplexing.

I think we agree that IPv4 and IPv6 are network protocols, but you can create a tunnel with Hurricane Electric by setting the Protocol to 41 in IPv4, and without using GRE. The tunnel gets created by the way they are stacked and used.

So a valid question can be stated: am I setting up a tunnel when I start LDP and MPLS? So, from my point of view, the following are requirements for a tunnel to be made:

1. It is set up by or for a user outside of the domain of the transport network (even if the user is a network engineer in a data center). If I create a tunnel over the Internet, I’m the user outside of my ISP’s network. Note that I can tunnel over my own enterprise network; there is some interest in doing that and I’m the end user for that particular case. This takes away MPLS, but not MPLS VPN.

2. The tunnels created deliver the packet between two endpoints but neither of them are the final destination; or… well, technically yes, it can, but my point is that there is another endpoint higher in the OSI layers, even if it ends up being the same one. Once a packet gets delivered it gets decapsulated and further processed again for its delivery. Yes, Ethernet may fit here, but it doesn’t fit #1.

3. Two same or different delivery protocols with usually different address spaces are stacked onto each other. As such, there must be source and destination endpoint addresses endpoints in the encapsulated packet and in the lower-layer protocol. You may use the same address space, but most of the time it’s only a trick to get around some weird limitation. Oh, wait, just like tunnels! ;-)

So, by how it works, no protocol is a tunneling protocol (well, except maybe IPSec in tunnel mode). It’s only by what it was designed for that can be called a “tunneling protocol”.

Examples:
* ICMP is not a tunneling protocol but it can be used to create tunnels.
* Same for HTTP.
* It can be said that GRE is a tunneling protocol, but it doesn’t work by creating tunnels, but by encapsulating packets and making it easy to layer a protocol on top of another.

Was MPLS designed to do tunnels?

Best regards.

Ejemplo de uso:

$ ls -s1 | ./stats.gawk
cnt,min,max,sum,avg,stdev:	53	4	33064	78860	1487.92	6125.08

One of the reasons I do is because it allows me to pretty easily tweak my browsing safety.

There are several aspects to browsing safety. When working on your own computer the most important one after having an updated browser is JavaScript.

JavaScript is really useful, as it allows you to make websites interactive, but it can be easily misused to do all kinds of bad stuff, from personal tracking to attacking IRC networks, passing through personal information stealing, cross-site scripting, clickjacking, etc., even if you use Linux, Mac OS or any other non-Windows operating system. Although not strictly necessary, most of the new browser-related attack vectors require JavaScript to work or be useful.

People using Firefox rely on add-ons like NoScript to disable JavaScript, but Opera provides a surprisingly easy built-in interface to control JavaScript yourself.

Quick Preferences menu

What features of Opera do we need to use to make our browsing safer?

• We’ll use the easily-accessible global JavaScript toggle switch. You can see it by pressing F12.
• We’ll use the global JavaScript restrictions defaults.
• We’ll use the customizable per-domain “Site Preferences”, which include JavaScript toggling.
• We’ll use the easy access for the per-domain “Site preferences”. The dialog, although available through the Tools menu, is also just a right-click away, using the “Edit site preferences…” context menu entry.

What’s my way of using this?

Preferences dialog, Advanced tab, Content section

Navigate to Tools » Preferences…, and in the Advanced tab choose Content from the list on the left. Enable JavaScript using the checkbox just to let the JavaScript Options… button get enabled. Clicking it will get you to the dialog shown.

JavaScript options

This dialog lets you configure the global JavaScript defaults. I do not like websites raising or lowering any windows, and surely not allow changing the status bar, as I want to trust the links appearing on it before clicking on anything.

Likewise, I don’t want websites detecting context menu events, or at least not by default. Facebook is one site that detects right-clicking to prevent you from properly copying and pasting links. On the other hand, Google Maps extensively tweaks the context menu and gives you more options.

Also, I don’t like websites hiding the address bar, at least not by default, as I like to check the URL of each and every website that I browse to. This is helpful to prevent phishing attacks.

I disable pretty much everything by default. After setting it to your own liking click OK. Back in the Preferences window, uncheck Enable JavaScript to disable it back and finally click on OK.

You have just set the default JavaScript settings. You may feel this should be adjusted in the future, but let’s leave it like that for now.

Now, press F12. You will get a quick menu where you can globally enable or disable JavaScript quickly and easily, just in case you are in a hurry and can’t make it work for a specific website. It should be disabled because of what we just did. Leave it that way.

Context menu

Now, you should manually enable JavaScript to each site you actually trust. Let’s go to a site that uses JavaScript, say, Google. You will notice Google works a bit different now. Let’s say you trust Google and you want to let pages from www.google.com to be able to use JavaScript. Right click on any text or blank area of the website and choose “Edit site preferences…”. This will take you to the “Site Preferences” dialog.

In the “Site Preferences” dialog you’ll find a text box for the site (or domain) you want to tweak. You may want to use the current domain or tweak it to use a broader domain.

Site Preferences dialog, General tab

After choosing the domain, go to the Scripting tab. There you can “Enable JavaScript” only for that domain. When you enable JavaScript, the other 4 checkboxes default to the settings you chose in the JavaScript Options window, globally. You can change that too if you trust your site enough, or if the site requires it. I usually leave them unchecked.

Whenever you find a site that may not be working as expected, selectively enable JavaScript for that site only, but only if you trust it enough. “Enough” may have a different meaning for you or me. For some, it may be “enough” that the site doesn’t try to steal your information; others may want the site not to track them in any way (good luck with those, though).

Caveat

Some sites hired too few programmers (or too many potatoes) to code their sites and they work in weird ways without the proper JavaScript in place and don’t offer any kind of graceful degradation. For example, the online banking site I use does multifactor authentication that doesn’t work without JavaScript, so I selectively enabled it for that subdomain (www.somebank.com). However, the final login step gets sent to a different domain (say, loggedin.somebank.com), which uses JavaScript to redirect you to the dashboard page. Because the second domain doesn’t have JavaScript enabled yet, I can’t access it. Since I can’t access it, I can’t drop the context menu down to Edit site preferences for the second domain. This leaves me locked out of my online banking.

However, since the two domains are part of somebank.com, you can easily work around this chicken-and-egg problem by tweaking the “Site” textbox to remove the “www.” part and leave JavaScript enabled for the whole somebank.com domain. Voila!

Con pocas modificaciones se puede hacer lo mismo para un archivo local.

Se puede colocar el comando en el arranque de sesión, pero se va a bloquear para pedir la contraseña. Se recomienda tener acceso al servidor remoto por medio de claves públicas para que el agente de SSH automáticamente pida la contrafrase en pantalla.

Puesto que tail -f nunca debería salirse, tal vez sería conveniente agregar una línea después del SSH que mande una alerta de que concluyó el tail -f o de que falló la conexión con el servidor. Tal vez se pueda hacer revisando el código de retorno, pero hay que ver qué ruido le provoca el tubo.

Se puede modificar para que también el icono y la severidad de la notificación sean distintas, pero en mi caso no es necesario.

El comando podría fallar si la cadena a mostrar contiene comillas.

#!/bin/bash

# stail-notify.bash
# Escrito por Octavio Alvarez.
# Licencia: WTFPL

[ $# -lt 3 ] && {
	echo "usage: "`basename $0`" <user@host> <file-to-tail> <alert-title>"
	exit
}

ssh $1 "tail -n 0 -f "$2 | while read M D T ELSE; do notify-send -t 5000 -i dialog-warning -u critical "$3" "$ELSE"; done

Para usarlo, lo ejecutan así:

stail-notify.bash alvarezp@192.168.2.100 /var/log/messages "Alerta de Syslog"

RAM is there to be used.

This phrase is true within a particular context. It is used to let the operating system cache as much disk as possible into RAM, as RAM is significantly faster than hard disks.

However, within the context of a user-space application it is actually a fallacy. Some users (and even some developers) don’t know much about the inner workings of their computers, and use this phrase outside of its proper context. What is worse, sometimes they don’t even care much about RAM consumption. They don’t care about memory leaks, or think that if memory leaking occurs only once, it’s fine. Or they think garbage-collected frameworks or languages will take care of everything by magic. Without knowing, they end up using the aforementioned phrase as the equivalent of:

RAM is there to be wasted.

There are some issues that may lead to actually feed this thought, leading them to think that an application actually should put as much information as needed in RAM, and that, sooner or later, “the OS will handle it efficiently”. Furthermore, that not doing this is just a performance sacrifice.

Consider the following (I’ll oversimplifying for the sake of easy explanation, but the model is true). On one hand:

• When an application requests for RAM and the OS allocates it, the memory is being reserved for its exclusive use until the application frees it. An application can not know (and should not know) if another application requires or requests RAM.
• If physical RAM gets topped and there is swap space available in the system, the OS will move out some of the least used RAM pages out to swap space, be it a partition or a file. When the paged-out RAM in swap space is needed, it gets swapped with other least-used physical RAM pages. Both operations require hard disk activity. That’s what makes swapping inherently slow.
• The operating system will always leave some (say, 50 MB) physical RAM unused, so it has RAM available to react to a system instability emergency.

On the other hand:

• Operating systems use free physical memory to cache disk reads and writes, so when a disk sector is read multiple times, subsequent reads are read from RAM, which is much faster.
• The OS will only cache disk reads/writes to free physical RAM, as it would be useless to “cache” disk to disk.
• When an application requests for RAM, the OS will free RAM used by disk cache before allocating it to the requesting application. This operation doesn’t require disk activity if freeing up RAM-cached reads or flushed disk writes; however, it does require disk writes if freeing up unflushed RAM-buffered disk writes. Usually, the OS flushes cached disk writes when system is idle, so you don’t really notice it, and when the time comes, everything is already flushed.

And last:

• Linux, report “resident RAM size” for a process as “physical RAM usage”. So if you measure your application RAM requirements, you should do it with your swap partitions disabled. Please enlighten me about how Windows reports RAM for a process.
• Disk writes are usually slower than disk reads.

The actual truth around this fallacy is “sure, the OS handles it, but you kill the disk cache and encourage memory swapping, slowing the whole system down, including your own application“. So yes, the system “takes care” of it, but it is actually recovering from the programmer’s mistake at the cost of overall, unnecessary, system slow down and potential instability.

So let’s analyze two scenarios taken out of my own experience. I repeat: I am oversimplifying. Use this as a model.

Case 1: A browser caches on disk instead of RAM.

You have a system with 2 GB of RAM, out of which you have 1 GB free (as in “maybe used by disk cache but surely available for applications”). You fire up a web browser that caches resources on disk (because it is faster than the Internet) and needs about 300 MB of RAM.

1000 – 300 – 50 = 650

You end up with about 650 MB of RAM for disk cache optimization and 50 MB of actual free physical RAM.

Whenever the browser needs a network resource it tries to load it up from disk. However, disk gets cached on RAM by the OS, so subsequent reads will be read out from RAM. Performance penalty it is barely noticeable.

If the browser wants to cache a newly-visited website, it will save it to disk. The OS will buffer the write to RAM so it will postpone it until the system is idle (when you are reading the website). Performance penalty it is barely noticeable.

Whenever another application reads from disk there is a high probability of hitting the cache because there is 650 MB of RAM available for this purpose. Even if missing the cache, whatever was read from disk will be cached in RAM for subsequent reading.

You, then, fire up a VM that requests 450 MB of RAM. The following occurs:

• The operating system frees up 450 MB of disk cache. Some of it requires writing, some not. This operation is only as slow as the disk-writes required for unflushed writes, so it’s not really that slow. Besides, the user somewhat expects it because he just commanded the PC to load up a VM.
• There is no swapping at all. There is no need.
• It finally allocates 450 MB to the VM.
• The VM writes to that physical RAM allocated for it.

There is still 200 MB available for disk caching, which the OS will try to efficiently use.

Now, the browser wants to load something from “disk cache”. There is some probability, higher than 0 of course, of hitting the cache and the OS serving the data directly from RAM. Let’s assume not: it was read from disk. The browser is still accelerating web surfing, as the local disk is still faster than the Internet. Furthermore, the OS will cache the object on RAM for subsequent access.

Of course, the VM continues running from RAM without ever needing of any kind of swapping or disk trashing. The system is fully responsive. The user knows (or should know) that if it wants to free up RAM it will close the VM or the browser.

Case 2: A browser uses more RAM than it should, for caching.

You have a system with 2 GB of RAM, out of which you have 1 GB free (as in “maybe used by disk cache but surely available for applications”). You fire up a web browser that could work really nice with 300 MB of RAM but instead caches everything up for the sake of speed and ends up using 600 MB of RAM.

1000 – 600 – 50 = 350

You end up with about 350 MB of RAM for disk cache optimization and 50 MB of actual free physical RAM.

Whenever the browser needs a network resource it loads it up from its own RAM allocation, so it is really fast. (It still has to load it first from disk if not previously available on RAM).

Whenever any other application reads from disk there is a lower probability of hitting the cache. In any case, the overall probability of the other applications of hitting the cache is lower, as memory is exclusively allocated for the web browser. This significantly increases the probability of accessing disk, which may lead to slow the whole system down.

Minimizing the browser does not free memory for other applications. Memory is still being allocated for exclusive use by it.

You, then, fire up a VM that requests for 450 MB of RAM. The following occurs:

• The operating system frees up 350 MB of disk cache. Some of it requires writing, some not. This operation is only as slow as the disk-writes required, so it’s not really that slow.
• It determines the least used 100 MB of physical RAM and moves it out to swap space. This operation is slow, as it involves a lot of unavoidable on-the-fly disk writes.
• It finally allocates 450 MB to the VM application.
• The VM writes to that physical RAM allocated for it.

The system has no memory for disk cache anymore. Whenever other applications need to read from disk, they will miss the cache and the OS will have to physically access the disk to serve the request. This is slow. What is worse, the disk access will not be cached for subsequent reading.

Now, the browser wants to load something from its own “RAM cache” (which, by the way, may probably be out in swap space, now). It may happen one of two things:

If the RAM cache resource is on swap space, the OS will need to read it back. Since that data will be now a “more recently used” memory page, the OS might swap RAM and disk with some contents of the VM or another least-used application. This operation is slow because it requires another lot of unavoidable on-the-fly disk writes. Or:

If the resource is still in the application own “RAM cache”, it will be retrieved flash-fast from RAM. However, the VM still needs its own RAM to continue, and so do all other applications. This forces the operating system to swap memory again. Also, there is no RAM available for disk cache, and other applications disk requests will still served continuously from disk without the possibility of RAM caching for subsequent access. This generates constant disk activity, slowing all the system, including the browser. The browser “extra RAM cache” did no good at all.

Of course, the VM continues running and its RAM will continuously be needed back, so disk writing becomes a constant. The whole system slows down by what is called disk trashing. In really bad cases, the system may become unresponsive, restricting the user from even being able to close one of the two applications to recover the system back.

Conclusions

Yes, RAM is there to be used when it is needed, not wasted. RAM is a limited resource. There are ways to use RAM efficiently. For instance, loading the indexes of a mailbox in RAM (but not the whole mailbox content), if done correctly, may significantly speed up mail searching.

However, caching disk to RAM might not be a good idea. The caching is already done by the OS, so it is just discarding an efficient OS function by an application. Sometimes it may be a good idea but most probably, particularly in desktop applications, it is not.

Superkb v0.10 screenshot.

So, Superkb 0.22 was released a couple of weeks ago. It featured a gradient-based rendering of the keys. This, in addition to the multiple key-rendering modes introduced in 0.15 (Feb 2008) and the use of the Cairo library in 0.20 (Nov 2009), have drastically changed the overall appearance. Yesterday I fixed the display of UTF-8 characters, which have allowed me to use arrows for the cursor keys and others. This is the result:

Superkb with the most recent change for version 0.23.

This is also a thank you note to the users that have provided me with their useful feedback.

Superkb is a shortcut-based launcher with on-screen graphical hints. It is written in C using Xlib, with the help of Cairo graphics, Pango, Imlib2, Xinerama, etc. and the source code is managed using Git.

Your keyboard shortcuts painted by Superkb 0.22

Some of Superkb features:

• Easy to use. You select a hotkey (Super keys by default) as the base for your launchers and just hit Super+Key to execute whatever command you configured or launch whatever application you chose.
• Non-obstructive. Being shortcut based, you don’t need anything on your screen. Holding the hotkey down will invoke the on-screen hints and releasing it will dismiss them.
• Support for different keyboard geometries as provided by the underlying X server.
• It provides on-screen feedback for whatever action you have launched.
• Configuration is written on a file. You take the configuration with you to install it on your other computer as simple as copying a file.
• The hotkey isn’t wasted. You can choose F8 (or any other) as your hotkey if you please and hitting it will still send it to the currently focused window. I use this for the Thinkpad T42 that has no Super keys.

Thanks to bldewolf. / Gracias a bldewolf.

At the same time, Alfredo started too. So him and I took the 50-mile challenge that is biking from Rosarito to Ensenada, Baja California.

I knew it was difficult, but not that much. The Sun was really tough. I heard other cyclists talking about how hot the day was. Uphill most people were walking. “Casual riders complete the trip in 4 hours” says the website. I did 7:15, and there were still people behind me.

It was a real challenge, but actually fun. I found out what I am capable of doing.

Lessons learned:

• I need to train.
• I need to learn to administer my water and food supplies better during the ride.
• I need to lighten in my backpack (and my frontpack too)
• I need to find the optimal way to use my energy on level ground and better hill management.
• I probably need to find a more optimal way to use my bike: gears, posture and technique.
• I might need to tune up the bike or have a better one.
• I need to train.
• Not to forget to empty the GNOME trash before placing the flash memory back in the camera. Sorry for the lack of pictures.
• … and I’m sure I’m missing something else.

I’m so glad today. Some of you may have heard of Diaspora, the project aimed to be a social network like Facebook but open source and distributed.

Why? Because I don’t trust Facebook. I don’t know the exact instructions in the software that governs the service. Being distributed and open source, I trust that thousands of users and developers will be able to view and analyze the code, myself included. I will be able to know exactly what the code says if so I wish. Furthermore, I will be able to post my personal information on my own server instead of a centralized, untrusted one. It also means that people that trust me more than Facebook would have an alternative (and a system administrator that actually cares).

(Oh, and personally, I consider the current lack of any similar-to-Farmville application to be a feature.)

We are still talking about posting information to the Internet, though, so it must not be taken any lighter than publishing any personal information daily on the newspaper or the TV. If I publish a picture, I can take it down from my server, but I may not be able to take it away from other servers into where it may have already been replicated.

Since the moment I heard of the project I’ve been waiting to get my hands on it and try it myself. That day finally arrived. On September 15th, 2010, the development team released the code to the public in their Git repository hosted on Github.

I found some instructions on installing Diaspora on Debian and so I decided to try them on my Sid box. It looks those are not complete anymore (the code is rapidly changing as development continues). I had some initial problems, but at the end, with some help from the people at #diaspora, it worked good enough to make this blog post.

I eventually got to this login screen:

The user identification takes the form user@domain.com. As you can see on the browser address bar, I’m accessing my own PC, not some server on the Internet.

After some more tweaking I managed to exchange “friend” requests with another person. We exchanged messages bidirectionally:

Diaspora has these things called “aspects” which I understand as “aspect of your life”. The two available by default as of now are “work” and “family”. When you add a friend, you add them under one (maybe more?) of these aspects.

Message exchange was done in real time. As soon as I published a message, it got sent to my new friend in a third-party server and he got the message shown in his browser without reloading. Same way back: he added a message and I saw it.

The message went encrypted over the wire (which is very good). After some decoding, this is what I got:

{"aes_key":"Cl2Xtq/VO [... lots of characters ...] A9lSnqEYk=",
"ciphertext":"YT47xNE [... lots of characters ...] KbqlQNx+Y="}

In my tests I was not able to upload images; they failed for some reason. Screenshots from the developers show pictures already working, though. Maybe they got broken sometime in the last couple of days.

Basically, in addition to what the instructions said, I had to open the ports on my firewall to make it work. You must start the server from the ./script/server script provided.

Also, the instructions suggest you directly call build but this will not load the websocket at port 8080. I had to artifically do a PATH=$PATH:/var/lib/gems/1.8/bin to include that directory in the search path, so ./script/server could call build.

VERY IMPORTANT: This version is in development quality (which basically translates to “best effort”), or as they say in the Git repo, “pre-alpha” quality. It is still a long way from being suitable for popular use. It has known security problems (your diaspora account can be remotely hijacked); it has bugs (image uploads are broken in some setups); and it you may lose diaspora data out of nothing (as with any development release), particularly if some upgrade goes wrong. The actual recommendation is DON’T POST YOUR IMPORTANT INFORMATION yet. I repeat: it is a development release; it is a preview. It is still in a very early development stage. Call it a prototype if you want, but be sure to accept the existing risks as of today.

If you want to try it yourself, check the Diaspora Wiki out. It includes information about public servers, installation, some terminology that I did not read and so I made some guys at #diaspora lose some of their valuable time. Now is a good moment to thank them for helping me out.

Diaspora team: great work!

Unlike regular VNC connections, in which you connect to the controllable PC, in a Reverse VNC connection the controllable PC will connect to you. The control is in the same direction, but the connection is reversed.

What’s the benefit? Not having to worry about the network status and addresses of the remote PC. It is usually easier to initiate connections than to receive. This lets the guy with better network understanding to be the listener and the poor soul to be the initiator. This will put the network worries near to the tech support guy, where it should be for this particular scenario. Also, as with the current state of IPv4, full of the evil but necessary NAT, you will not have to worry about router NAT / port forwarding configuration in the remote router.

Test setup

The test setup consisted on my desktop workstation running Ubuntu and my laptop running Windows, both on the same Ethernet broadcast domain. No gateway was involved in the test.

The desktop workstation had the following characteristics:

• Operating System: Ubuntu Lucid Lynx (10.04).
• VNC package: xvnc4viewer 4.1.1+xorg4.3.0-37ubuntu2.
• Role: Controlling computer (VNC client). In real life here is where I would sit and control other computers.
• IP address: 192.0.2.10 (this is a fake, RFC 5735 documentation address).

The laptop had the following characteristics:

• Operating System: Microsoft Windows XP SP3.
• VNC package: TightVNC 1.3.10, installed from the OpenDisc software collection.
• Role: Controlled computer (VNC server). In real life this would be the PC receiving remote tech support from me.
• IP address: 192.0.2.20 (this is a fake, RFC 5735 documentation address).

Steps performed to establish the connection

On the desktop workstation (the VNC client, controlling computer):

• Opened a terminal
• Ran vncviewer -listen
• You should get a message like “main: Listening on port 5500″

On the laptop (the VNC server, controlled computer):

• Went to Start » All Programs » TightVNC and ran Launch TightVNC Server
• If the Properties window pops up, disable “Accept socket connections” and click OK (just for security reasons).
• Right click on the system tray TightVNC Server icon and choose Add New Client…
• Enter the IP address of the desktop workstation, in this example, 192.0.2.10 and click OK or hit Enter.

Sidenotes

• The test was done with the Windows Firewall enabled. You might get a message like To help protect your computer, Windows Firewall blocked some of this program features. | The computer administrator may unblock this program for: TightVNC Win32 Server when running the Tight VNC Server. You may safely click “OK” because you will initiate connections and not listen for a connection. This message gets inhibited by disabling Accept socket connections in the Properties window.
• The test was repeated using a restricted Windows account, with a successful result. This gives you a lot of flexibility. You might even try making a portable TightVNC server by following the Step 2 from the instructions on this VNC document from the TinyApps.Org blog
• Depending on the available bandwidth and latency, it might be necessary to tweak the server on the Properties window.
• I noticed a somewhat long delay on the first connection attempt, in one case even leading to a connection failing. On the second try it worked fine. I would guess this has to do with DNS resolving delays and caching, but it’s just speculation.

Comments welcome. If you have instructions for the same scenario on different platforms, post it on your blog and link it from a comment, or write it directly on a comment.

What a coincidence. I recently said the following over Tweeter (translated from Spanish):

To debate if “God” exists or not is like arguing if 0 is positive or negative. The thruth is both are the same number.

For me, +0 == -0 and I like the analogy. And yes, I have already been criticized… but, oh well.

In code I think it could be like this:

function dios_existe() {
	if (sign(0) == 1) return True;
	if (sign(0) == -1) return False;
	return dios_existe() /* haha, because that's just what happens with human beings */
}

Please let me introduce it for those that don’t know the project yet.

Superkb is a shortcut-based launcher with on-screen graphical hints. It is written in C using Xlib, with the help of Cairo graphics, Pango, Imlib2, Xinerama, etc. and the source code is managed using Git.

Teclado Microsoft Natural, pintado por Superkb (Cairo, flat_key)

Some of Superkb features:

• Easy to use. You select a hotkey (Super keys by default) as the base for your launchers and just hit Super+Key to execute whatever command you configured or launch whatever application you chose.
• Non-obstructive. Being shortcut based, you don’t need anything on your screen. Holding the hotkey down will invoke the on-screen hints and releasing it will dismiss them.
• Support for different keyboard geometries as provided by the underlying X server.
• It provides on-screen feedback for whatever action you have launched.
• Configuration is written on a file. You take the configuration with you to install it on your other computer as simple as copying a file.
• The hotkey isn’t wasted. You can choose F8 as your hotkey if you please and hitting it will still send it to the currently focused window. I use this for the Thinkpad T42.

Here are some screenshots about how Superkb looks like when the on-screen hints are triggered.

For this version, Superkb has continued walking on the stabilizing road. Since version 0.20 a lot of effort has been put in correcting unfriendliness and unexpected behaviors. This is a release I’m very happy about. I can say it is no longer in an ancient ‘works for me’ state. It has been throughly tested with the invaluable help of the Tijuana Linux User Group, particularly in this last version.

So what’s particular for this version? Well, as a project:

• We have started a Wiki with a lot of better documentation.
• We created the superkb-devel at lists.sourceforge.net mailing list with its archive.
• We had our first bug-hunting day in Tijuana.

In the software:

• Stability and friendlyness is drastically increased.
• Feedback strings don’t need to be requoted anymore (via the new
  FEEDBACK_STRINGS_AUTOQUOTE option).
• Initial support for keyboard states (like Super+Shift+N versus plain Super+N).
• Lots of bugs have been fixed.

And yet, the project has a lot of space for improvement. Particularly:

• Packaging. It needs to be prepared for the different versions of Debian, Fedora, openSUSE, Ubuntu, Arch Linux, Slackware, etc.
• Distribution inclusion. There is no better way to install any program than simply doing something like apt-get install <pkgname>. Superkb could really use that.
• A better website. Though the current website is a lot better than the original, keeping it up to date is difficult. Documentation has therefore moved to the Wiki and I’m looking forward to changing the website to be more static.
• Translations. There is no code for string translation yet in Superkb. Even though all non-stdout messages are translatable through configuration, console messages should be internationalized.
• Portability testing. The project has proven to work on Debian, Fedora and Slackware-based Linux distributions in 32 and 64-bit versions. However, it has not been tested on non-Linux platforms like openSolaris, *BSD, etc, or non-PC architectures.

Room for improvement for Superkb:

• A configuration GUI. So far, Superkb must be configured by editing a file but this is far from the actual vision of using the software. Superkb actually has a placeholder to do whatever thing when a key is held down for 3 seconds. This is intended to be the configuration interface.
• Xrandr support. It currently detects screens using Xinerama at startup, but it cannot detect changes to the screen layout without being restarted.
• Much more.

To directly quote from Felipec’s post in his blog:

After a bit more than two years of development we are proud to announce the first stable release of msn-pecan. The project started as a “fork” of libpurple’s msn protocol (read below why it’s not really a fork), but it has grown and soon will become a standalone library with support for Telepathy too.

Even though I have only 3 of the 1009 patches and although I don’t understand any of the code itself, I gotta admit I really feel like I’m part of the project.

7 years ago I started a project to write a text mode, ncurses-based MSN client for Linux. The project is still registered on Sourceforge as msnclient. It was my first attempt at writing free software. However, the challenge was too much for me and the project quickly died. I never got further than logging in and sending a single-worded message to another contact.

I eventually started to learn how to use Pidgin and got my self good hardware and my need of a personalized MSN client was no more. I still think, however, that msnclient is a good concept to try to bring to life. Maybe some day it will be an interface based on the msn-pecan functions.

That said, in mid 2009, when I started learning Git, felipec provided me a branch from his repository to test the direct connection feature (better known as “fast file transfers” or “p2p file transfers”). It didn’t work that time.

6 months went by and lot of commits over his master branch were too. 0.1.0-rc1 came out and directconn was still not working but the dc-test branch was relly old now. I had learned enough about Git and I though that I was better enough to try fixing the DC code. However I really knew nothing about the MSN functionality and I really didn’t understand the code. Well, at least I knew what the first step was: I had to rebase it anyway. So I tried to bring that old branch to the new code base so it could be (at least) useful to the developers. So war was lost for me, but perhaps felipec would get encouraged enough to restart working over this part of msn-pecan (but you’re not supposed to say that, right?). That’s how I saw it and how I got my motivation to do it; also, I would be my first actual real-world git rebase.

The main problem was that felipec had done a lot of relevant code reorganization, renaming and splitting in July (some done good, some done badly). Using some C experience I managed to rebase it and sent it in as a couple of patches.

Suddenly, felipec continued work on directconn. I don’t know if it was because of the patches or not; that doesn’t matter. The important thing is that in msn-pecan 0.1.0, direct connections now work and are stable. Even if not in all cases, it is a great step.

Now I think it went beyond learning how to rebase: I actually learned how to contribute using Git, just like the big boys do in the Linux Kernel project. I still don’t understand the code and the inner workings of the project but those two patches allowed me to learn a lot about software collaboration and review. This was particularly helpful for Superkb which is also written in C and its source code managed in Git.

So, thanks again felipec, congratulations and we all should have a drink for the project, even if on different parts of the world! Let’s party and spread the word.

Es un video con los experimentos realizados por el Dr. Donald Pettit, astronauta, Ingeniero de Vuelo y Oficial de Ciencias de la expedición 6 a bordo de la Estación Espacial Internacional.

Según la página de Saturday Morning Science, “hasta en su tiempo libre, los astronautas a bordo de la ISS están descubriendo cosas nuevas y sorprendentes sobre la naturaleza”. Según Don Pettit, estos experimentos no se tenían programados como parte de la misión; no eran ciencia “programada” sino ciencia “de oportunidad”.

Este video es un video crudo y directo al grano; tal vez sea una versión compilada; pero hay otras versiones en YouTube y la galería de videos de la expedición donde están editadas a modo de entrevista con un poco más de explicación.

Espero que los disfruten tanto como yo y se sorprendan tanto como los astronautas.

Thanks to SourceForge and its MediaWiki implementation, the Superkb project now has its own Wiki.

For now, it is only in English. I’m really looking forward to adding a full Spanish equivalent.

I think this will make it a lot easier to keep the documentation up to date.

The SourceForge Wiki doesn’t allow anonymous contributions, so an SF account is needed to include the people in the editors group.

Suggestions and contributions are welcome.

auto br0
iface br0 net dhcp
   bridge_ports eth0 eth1
   bridge_stp off
   bridge_fd 3

I have always felt the EIGRP metric as being really overwhelming. I see values like “2820096″ and instead of understanding it, I always end up asking what the hell does that number mean.

For example, in RIP:

R    192.168.0.0/24 [120/3] via 172.16.1.1, 00:00:15, FastEthernet0/0

Just by looking at the metric of “3″ I immediately know what is means: there are three steps between the announced network and the router receiving the advertisement. Easy, right? “Understanding the number” makes it easy for me to manage and diagnose it.

In OSPF, the metric (cost) is still not as cumbersome as EIGRP’s. However, in the following example, can you identify what does “66″ mean? For you, is it “just a number” that won over another because of its numerical value being lower? How do you know if the number is right or not?

O   192.168.0.0/24 [110/66] via 172.16.1.1, 00:00:82, FastEthernet0/0

The EIGRP metric formula is better, functionally speaking. It is calculated from various components. As a result, it is more complex. Furthermore, the resulting value is bigger. When you try to read the number in the route table, it is no longer obvious.

D   192.168.0.0/24 [90/2820096] via 172.16.1.1, 00:00:12, FastEthernet0/0

So, what does “2820096″ mean? Well, it’s pretty simple. Take 2820096 and divide it by / 25600 and you get the estimated travel time in milliseconds: .

The EIGRP metric is an approach to calculating the total travel time. By default, EIGRP calculates the packet travel time like is: take the transmission delay in all hops in the path (the famous “delay” part) and —instead of adding all of the serialization delays— add only that of the bottleneck bandwidth for a 100 Kilobit sample.

The goal of this article is to show you how to mathematically get to that conclusion in the particular case of the default K values. This will allow the article to be much shorter and understandable, because the rest of the terms that compose the complete EIGRP metric are more complex and there is less on-line documentation reference for those. Also, Cisco doesn’t recommend changing the K values by default unless you REALLY know what you are doing.

Besides, we can get our engines started and warmed up for a later article with an analysis for the whole formula, don’t we?

Step 0: Starting to think

To put a “meaning” to this number, I will first ask you: if you designed your own “perfect” routing protocol, what would you use as a metric? What formula do you think would provide the routers with the best and closest to reality information in order to always take the most optimal routing decisions, at all times, and whatever the network circumstance is? It is not an easy question, though it is one that any protocol designer will never be able to escape. Think about this for a moment.

When I asked myself this question, my answer was: I think everybody wants the packets to get to its destination (unmodified, of course) as quickly as possible. I would like all participating routers to know the exact time it will take a packet to get to router B. Travel time should be used as *the* metric. In my “perfect” routing protocol, the metric would be measured in some submultiple of seconds. Even the Internet would be better if this were true, except that it’s way too expensive, complex, and difficult to manually control if done this way (that’s were BGP jumps in).

The EIGRP protocol gives it a shot at this approach.

Quoting complete the EIGRP metric formula, by Cisco

To analyze the default metric behavior I will start by quoting the complete EIGRP metric formula specified by Cisco¹:

where:

• 
  • where is the least bandwidth of all outgoing interfaces on the route to the destination network represented in kilobits.
• 
  • where is the sum of the delays configured on the interfaces, on the route to the destination network, in tens of microseconds. The delay as shown in the show ip eigrp topology or show interface commands is in microseconds, so you must divide by 10 before you use it in this formula. Throughout this paper, we use delay as it is configured and shown on the interface.
• If , the formula reduces to .
• Cisco routers do not perform floating point math, so at each stage in the calculation, you need to round down to the nearest integer to properly calculate the metrics.
• The default values for K are:
  • 
  • 
  • 
  • 
  • 

For default behavior, you can simplify the formula as follows:

I found out that sentence to be a source of confusion for myself. Even the simplified, default-behavior metric formula is expressed in a way that assumes we can add apples and oranges, though this is impossible. Cisco wants us to add “bandwidth” with “delay”. So, how do they actually do it? How much is “10 bps + 10 s”?

Step 1: Arranging the mathematical expression in its default K values

Let’s try to state the formula in its default behavior. I will use the following symbols:

• : metric.
• : resulting scaled bandwidth.[/pmath]
• : bandwidth(i), the least bandwidth of all outgoing interfaces on the route to the destination network represented in kilobits.
• : resulting scaled delay.[/pmath]
• : delay(i), the sum of the delays configured on the interfaces, on the route to the destination network, in tens of microseconds.
• : 1000000 (as in 10 Mega-something).

Let’s arrange the formula in a way it really looks like a mathematical equation:

where:

Step 2: moving the “256″ out of the way and getting to the original IGRP metric formula

EIGRP metric is 256 times that of IGRP². This is easily provable: as both, B and D are a multiple of 256, we can divide by it. The result is the exact original IGRP formula3. (Though this is also true in the complete formula, please remember we are only working with the particular case of the default metric behavior.)

This means that the EIGRP metric will be always inflated and will be a multiple of 256.

Let’s do the procedure. First, lets get all into one big formula. Let’s replace B and D for their corresponding formulas:

There we can see how the 256 factor is present in the two terms. We could factor it out but for convenience I will divide everything by 256.

The right side is the default metric for IGRP.

Step 3: Unit analysis and T₃

Or put another way: what is the resulting value measured in, is it Kilobits, seconds, hops, packets…?

The last formula from step 2 has the following form:

where:

• (metric)
• 
• 

The terms and must have the same units. Otherwise, addition couldn’t be possible.

The easiest term to analyze is . According to Cisco must be in tens of microsegundos. Therefore:

And thus, units (and therefore the whole M units) must be tens of microseconds, also.

So:

• (time)
• (time)
• (time)

So, given is a delay, the other term and the total metric must be a delay too in the same scale. Remember what I said at the beginning about using travel time as my “perfect” metric for a routing protocol? EIGRP is actually giving it a shot.

Step 4: Analyzing T₁

In step 3 we let be defined as:

And also that must be in tens of microseconds.

We know the units for and , but what are the units for ?

: tens of millibit

How many bits are ?

So finally, is like this:

Just like , also , so means “serialization delay for 100 Kbits under that bandwidth B_min“.

Conclusion and interpretation

D   192.168.0.0/24 [90/2820096] via 172.16.1.1, 00:00:12, FastEthernet1/1

We know that 2820096 is given in and multiplied by 256.

So we take 2820096 / 256 = 11016.

To convert it to instead, divide the metric / 25.6:

Or to milliseconds, divide it by / 25600:

As I said, the EIGRP default metric is an approach to calculating the total travel time. By default, EIGRP calculates the packet travel time like is: take the transmission delay in all hops in the path (the famous “delay” part) and —instead of adding all of the serialization delays— add only that of the bottleneck bandwidth for a 100 Kilobit sample.

References

¹ Cisco Document ID 16406, actualizado: Sep 09, 2005. Enhanced Interior Gateway Routing Protocol: http://www.cisco.com/en/US/tech/tk365/technologies_white_paper09186a0080094cb7.shtml

² IP Routing, by Ravi Malhotra, January 2002. Chapter 4: Enhanced Interior Gateway Routing Protocol (EIGRP) http://oreilly.com/catalog/iprouting/chapter/ch04.html#45434

³ Cisco Document ID 13678, actualizado: Aug 10, 2005. IGRP Metric [IP Routing], http://www.cisco.com/en/US/tech/tk365/technologies_tech_note09186a008009405c.shtml

Introduction

The most ignored Internet Etiquette rule is that of the posting style when replying to an e-mail message.

By “quoting” I mean the inclusion of a previous message in a new one (for example, a reply) with the intent of stating the relevance of the answer itself in the original context. I would say “Dan, I don’t know what are you talking about. Please quote the original e-mail in your reply next time in order to know what were you replying to.”

Almost every e-mail client do quote the original message in the reply, at least by default. That is good, and it contributes to the “netiquette”, but its abuse has made it completely useless.

By saying that the rule is “ignored”, I mean that the common user doesn’t edit the text put by the e-mail client as the quote. It leaves the quoted message as is, simply ignoring the resulting text. After three iterations of the answer, the “original message” carries more garbage than relevant content.

Common e-mail clients —like Outlook y Thunderbird— don’t help either; those are pretty stupid. They quote whatever they find. Even when the original goal is to place the original message in the editor ready for its editing while replying, it is also true that signatures and those hideous legal disclaimers are stupidly included also.

Ok. Beyond the rant, the main purpose of this article is to show the current quoting and reply techniques, but more important, to yearn for a style / technique used more than 15 years ago, even before Internet started to be popular in the city where I live.

A correctly applied etiquette to an e-mail reply allows a well-organized message. This etiquette is mainly formed by two elements: (a) the correct placement of the answer in relation to the quoted message and (b) the correct editing of the quoted message.

Reply text placement against the quoted text

The best way to explain this is to mention the three different styles and the difference between them: top-posting, bottom-posting and interposting (or in-line posting). It refers to the placement of the answer before, after or inserted into the original text.

Example A: top-posting

Yes, and I'm going to do it.

On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi <hitsuo.tikashi@sistint.com.mx> said:
> Octavio:
>
> Is the maintenance window on next Thursday?
>
> Who's going to execute the changes?
>
> Regards.
>
> ---
> Hitsuo Tikashi.
> Infrastructure Services Manager.
> Integrated Systems, Inc.
> T. +1 (619) 555-1234
> E. hitsuo.tikashi@sistint.com.mx

Example B: bottom-posting

On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi <hitsuo.tikashi@sistint.com.mx> said:
> Octavio:
>
> Is the maintenance window on next Thursday?
>
> Who's going to execute the changes?
>
> Regards.
>
> ---
> Hitsuo Tikashi.
> Infrastructure Services Manager.
> Integrated Systems, Inc.
> T. +1 (619) 555-1234
> E. hitsuo.tikashi@sistint.com.mx

Yes, and I'm going to do it.

Example C: interposting (or inline-posting)

On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi <hitsuo.tikashi@sistint.com.mx> said:
> Octavio:
>
> Is the maintenance window on next Thursday?

Yes.

>
> Who's going to execute the changes?

I am.

> Regards.
>
> ---
> Hitsuo Tikashi.
> Infrastructure Services Manager.
> Integrated Systems, Inc.
> T. +1 (619) 555-1234
> E. hitsuo.tikashi@sistint.com.mx

Which one do you think is the best? All of them has pros and cons, so the answer may be different in each environment. What do you think are the pros and cons of each?

For instance, In some mailing lists, top-posting is more than prohibited. Either you do bottom-posting or, better yet, interposting. This has been used since before the existence of e-mail as is known today.

However, in businesses and common use, the most popular style is top-posting, due to the easiness of just “writing and sending” without worrying for anything else; this has moved the MUAs (e-mail clients) to be configured for top-posting out of the box. This, in turn, makes it even more popular.

Proper editing of the quoted text

The last example of interposting made it easy to show how a great part of the reply text is just useless. It is considered that the quoted text is part of the reply, as it occupies disk space as part of the reply.

I’ll use that interposting example as the case to analyze, but the following applies to either of the three quoting styles.

From the word “regards” on, the text is irrelevant, and thus, useless. Maybe we could say that the line “Octavio:” is also irrelevant, but let us not be so picky at the moment. In numbers, 8 out of 21 lines (38%) are useless; so are 25 of the 59 words (42%); and so are 161 of the 373 characters (43%). We still have to take into account that mi reply signature is not there, so that will slightly lower those ratios.

Example D: Proper quoting in top-posting

Yes, and I'm going to do it.

On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi <hitsuo.tikashi@sistint.com.mx> said:
> Octavio:
>
> Is the maintenance window on next Thursday?
>
> Who's going to execute the changes?
>

Example E: Proper quoting in bottom-posting

On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi <hitsuo.tikashi@sistint.com.mx> said:
> Octavio:
>
> Is the maintenance window on next Thursday?
>
> Who's going to execute the changes?
>

Yes, and I'm going to do it.

Example F: Proper quoting in interposting (or in-line posting)

On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi <hitsuo.tikashi@sistint.com.mx> said:
> Octavio:
>
> Is the maintenance window on next Thursday?

Yes.

> Who's going to execute the changes?

I am.

The main argument for not editing the quoted text would be that it takes a long time to do it and it is done inefficiently. At home, this is called “lazyness”.

This will be the argument for those that don’t know the keyboard shortcuts for text editing, in particular the use of the Shift key as a non-written standard to select text. Using Shift and the arrow keys, followed by “Delete”, is extremely easy to select and erase useless text.

Yearning for Blue Wave and FidoNet

Before going into user interfaces and mobile devices, I’d like to take a momento to show my yearning feeling for the times where I wrote in FidoNet, even before the Internet started to be popular in Tijuana (1994 to 1996).

In FidoNet, it was common to do this a little different. I used a popular shareware named Blue Wave Offline Reader. Many of us used Blue Wave, which had a particular way of preparing the quoted text before putting it into the editor:

On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi said:
 HT> Octavio:
 HT>
 HT> Is the maintenance window on next Thursday?
 HT>
 HT> Who's going to execute the changes?
 HT>
 HT> Regards.
 HT>
 HT> ---
 HT> Hitsuo Tikashi.
 HT> Infrastructure Services Manager.
 HT> Integrated Systems, Inc.
 HT> T. +1 (619) 555-1234
 HT> E. hitsuo.tikashi@sistint.com.mx

The interesting thing is not in the inline replying. Same as today, a couple of Enters in the right place allowed me to reply in-line.

To erase from “Regards” on, still same as today: I place the cursor in the “R” from “Regards” and Shift+Ctrl+End, Delete and voilà: message is clean.

And so was my answer:

On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi said:
 HT> Octavio:
 HT>
 HT> Is the maintenance window on next Thursday?

 Yes. Even thought the changes are not considered to be critical, in case
 of a possible failure we will affect our service level agreements,
 because less than 30 days ago our carriers suffered an outage.

 HT> Who's going to execute the changes?

 I am.

What is really interesting is that when the original sender tried to reply me back, the text would be automatically adjusted to the line length (properly word wrapped) and quoted in the following way:

On Fri, Jun 26 2009 17:42:34 -0700, Octavio Alvarez said:
 HT> Octavio:
 HT>
 HT> Is the maintenance window on next Thursday?
 OA>
 OA> Yes. Even thought the changes are not considered to be critial, in
 OA> case of a possible failure we will affect our service level
 OA> agreements, because less than 30 days ago our carriers suffered an
 OA> outage.

 Acknowledged. I leave it in your hands and keep me informed.

 HT> Who's going to execute the changes?
 OA>
 OA> I am.

 BTW, who will monitor and operate the services the next day?

In the example, the user interleaved its answers to me.

Notice how the quoted lines don’t exactly match the original lines. those were modified intelligently, being considered as a paragraph and adjusted to keep a solid and consistent text block.

Also, notice how the text is clear enough and easy to follow; even more if the reader and editor software puts the different authors in different colors.

This style, beyond organized is scalable. After multiple iterations, the format and the text are kept organized.

On Fri, Jun 26 2009 17:42:34 -0700, Octavio Alvarez said:
 HT> Octavio:
 HT>
 HT> Is the maintenance window on next Thursday?
 OA>
 OA> Yes. Even thought the changes are not considered to be critial, in
 OA> case of a possible failure we will affect our service level
 OA> agreements, because less than 30 days ago our carriers suffered an
 OA> outage.
 HT>
 HT> Acknowledged. I leave it in your hands and keep me informed.
 OA>
 OA> Ok, I'll send you an SMS, according to the procedure.

 And please send it to me via e-mail, also.

 HT> Who's going to execute the changes?
 OA>
 OA> I am.
 HT>
 HT> BTW, who will monitor and operate the services the next day?
 OA>
 OA> It would be the new team member, but we have already asked everyone
 OA> else to be alert and ready in case of any eventuality.

 Have you exchanged phone numbers yet?

From my point of view, this is much more intelligent than its popular counterpart:

On Mon, Jun 29 2009 17:42:34 -0700, Octavio Alvarez <alvarezp@alvarezp.ods.org> said:
> On Sun, Jun 28 2009 17:42:34 -0700, Hitsuo Tikashi <hitsuo.tikashi@sistint.com.mx> said:
> > On Sat, Jun 27 2009 17:42:34 -0700, Octavio Alvarez <alvarezp@alvarezp.ods.org> said:
> > > On Fri, Jun 26 2009 17:42:34 -0700, Hitsuo Tikashi <hitsuo.tikashi@sistint.com.mx> said:
> > > > Octavio:
> > > >
> > > > Is the maintenance window on next Thursday?
> > >
> > > Yes. Even thought the changes are not considered to be critial, in
> > > case of a possible failure we will affect our service level
> > > agreements, because less than 30 days ago our carriers suffered an
> > > outage.
> >
> > Acknowledged. I leave it in your hands and keep me informed.
>
> Ok, I'll send you an SMS, according to the procedure.

And please send it to me via e-mail, also.

> > > > Who's going to execute the changes?
> > >
> > > I am.
> >
> > BTW, who will monitor and operate the services the next day?
>
> It would be the new team member, but we have already asked everyone else
> to be alert and ready in case of any eventuality.

Have you exchanged phone numbers yet?

This is the best the current e-mail practices can get us. It is not bad, but only if the authors and client software follow the etiquette.

If not, we get:

• Badly nested quoting prefixes like: > >> > >>> >
• Badly split lines for exceeding a line length.
• Fully quoted messages, including irrelevant paragraphs.
• HTML garbage from improper tag handling.
• Messages full of signatures and legal texts (sometimes in more than one language per message).

Even though a message from an author that followed the etiquette is a lot better than what we see in a day-to-day basis, i feel it far from the comfort of working in the Blue Wave / FidoNet style.

About user interfaces

E-mail clients fail in promoting the etiquette culture in e-mail messaging.

I think there could be a signature detection mechanism and automatically exclude it from the quoted text. This would save us from getting three copies of the same bulk after three replies:

> ---
> Hitsuo Tikashi.
> Infrastructure Services Manager.
> Integrated Systems, Inc.
> T. +1 (619) 555-1234
> E. hitsuo.tikashi@sistint.com.mx
>
> The content of this e-mail message and its attachments is confidential
> and may be protected by Copyright law. It is intended exclusively to the
> addressees and them only. If you have received it by mistake, you must
> eliminate it from your system. In this case you are not allowed to copy,
> print or distribute this e-mail or its attachments nor use them for any
> purpose of allowing its contents to be known by any person. The here
> included information is not necesarily backed up by [CORPORATION NAME]
> or any of its subsidiaries or strategic alliances.
>
> Please consider the environment before printing this message.

Note: I’ve seen that last line in some messages. I included it because I just couldn’t help myself from using my poor sarcasm after seeing that call for the ecology right after that waste of electricity and disk space (that is usually in HTML format).

Mobile devices

In a 160×320 screen and an itsy bitsy teenie weenie keyboard one could argue that is difficult to do all of this editing in a practical way. However, in the same way new mobile devices present the user an appropriate interface to do other common tasks in a different way, it is the UI that holds how easy or impossible the editing would be.

If in-line posting were popular, a mobile device would have a function or command to “answer below this paragraph” or “navigate by paragraph” and choose “reply, leave or snip” each of them and maybe even an option to “erase the rest of the text”.

If the UI doesn’t have it, it is because in-line posting has not been that popular and not requested enough. It is still a deficiency, though.

Conclusions

I’ve tried to show show the style in example F is the most organized and scalable among all possible, based on previous experience from Blue Wave and FidoNet.

Personally, I try to go with the same style that most of the people use in the same context. It’s the best. A people replying with interposting in a mailing list where everybody top-post (for example, at work) will only confuse for everybody.

I have nothing else to say than to throw a call to those that participate in discussion groups, mailing lists (and, in particular those in technical areas) that at least we observe this etiquette guides among ourselves:

• Reply in line to the topics in the original answer.
• Eliminate irrelevant parts of the quoted message. Signatures and legal texts in particular.
• Rearrange illegible paragraphs (word wrapping, for example).
• Use correct spelling and grammar.
• Back our text up with emoticons if confusion might arise.

Thank for the patience to read all the way to here.

gawk '{print "\007" $0 }'

This will effectively “prepend” a bell to each line.

You can convert this into an alias or a command (say /usr/local/bin/line-beep.gawk):

#!/usr/bin/gawk -f

{ print "\007" $0; }

So it can be used in a code like the following:

tail -f /var/log/messages | grep --line-buffered dhcpd | line-beep.bash