Views on Life

There, after spending a while figuring out why
if ( something.indexOf(select_groups[i]) == -1 ) {
threw an error; I was finally able to restore IE support. (poor misguided souls needn’t miss out on the Javascript goodies)

Apparently (Try to wrap your brain around this) the javascript version in IE doesnt support Array.indexOf()! All other browsers do, just not The Internet Explorer! (You can explore, but dont go in too far.) And I’m talking about IE8 here, not IE6..

More on that topic on this blog post “JavaScript Support and Array.indexOf in IE” (2008-08-13 – yes, 2008 and still its an issue!) The post also goes into the history; turning Mind boggling “WTF??” into “oh, MS is just being lazy”..

Read the rest of this entry »

I wrote this Gnu Screen guide in December ‘08 with the previous incarnation of linux.com in mind. January 2009 however, linux.com started on its new and exciting path as a community site and the article just sat on my machine, waiting. So I decided to publish it on my blog in a four part series over the following month. Maybe someone can use it

Have you ever had to run a time consuming process (say mkfs or compiling something) over a shoddy ssh connection? Or cleanly run several commands in parallel without having several open connections to that server? Or maybe you were programming and wanted a mysql prompt, a bash prompt and several text editors open? How about that ssh tunnel you need open and dont want to close by accident? And did you ever need to perform the same task on several different machines? Or connect to a serial terminal? Or maybe you just want a log file of what you re doing..
These are day to day situations any linux user will run into, that can be quite frustrating. That is, before you discover Gnu screen!

“Screen is a full-screen window manager that multiplexes a physical terminal between several processes, typically interactive shells.” Or at least, thats what the site calls it. Sounds easy enough, but there are an amazing amount of different uses for this incredible piece of software. The above list is some of the uses I could readily think about – some of the ways I regularly use screen, but like any decent linux tool – the sky really is the limit! I’ll be looking into different issues, so lets jump into some of the practical solutions for those problems.

The Fun Stuff – Different regions
Sometimes, having several windows is not enough.. It can help to have several different windows visible in your terminal and screen is able to provide you with that. As before, we need to open a screen session and open several windows. You could actually also do this with one window, but there wouldnt really be much point to it with one window. Once the new windows are opened, you can split the screen with the following shortcut.

C-a S       (split)       Split the current region into two new ones.
C-a tab     (focus)       Switch the input focus to the next region.

With these commands, you can create several regions and switch between them. These regions contain the same regular windows we spoke about before and as such, all normal commands can be used to control their contents. You can choose any window to be shown inside these regions. To close and further controll these regions, you can use the following shortcuts.

C-a X       (remove)      Kill the current region.
C-a Q       (only)        Delete all regions but the current one.
C-a F       (fit)         Resize the window to the current region size.

These are the default defined shortcuts for the regions. There are however more commands to control your regions, they just are not bound to shortcuts. For a comprehensive list of these other options, I advise you to comb trough the screen man page and do a search for “region”. There is ,however, one interesting command I don’t want you to miss! (Small blatant man copying coming up)

resize
       Resize  the  current region. The space will be removed from or added to
       the region below or if there’s not enough space from the region  above.
              resize +N   increase current region height by N
              resize -N   decrease current region height by N
              resize  N   set current region height to N
              resize  =   make all windows equally high
              resize  max maximize current region height
              resize  min minimize current region height

You will probably not want these windows the same size, so the resize command is really indispensable. Just like before, to use this commands, you have to call up the command line mode and input these commands there.

The Fun Stuff – Logging
Screen provides a simple mechanism for logging a session. It suffices to enable the logging in any of the three ways described below. The Parameter

-L    turns output logging on for this window.

The shortcut

C-a H       (log)         Begins/ends logging of the current window to the file "screenlog.n".

Or the command.

log [on|off]

These commands enable logging to the standard “screenlog.%n” file, in the standard directory. Should this file already exist, screen will append the new data to the existing file.
To configure the logging in more detail, screen also accepts the following two commands.

logfile filename
logfile flush secs

These commands allow the user to configure what name the logfile should have and how many seconds screen should wait before flushing the the logfile buffer to the system.

• Or maybe you just want a log file of what you re doing..

And using the above command, keeping that logfile is as easy as adding a parameter or using a shortcut. In using this system, you will soon discover that the logging is a wonderful and valuable tool, but also that when it comes to color tags and advanced ascii based menus or effects, the logs might turn out less than optimal. I’m thinking about the SLES Yast tool or even the fancy scp or yum progress bar. These commands will “replay” trough the log files while you read them and this does not always look as nice as you d probably like it to. This is however unavoidable and as such quite normal.
You might also want to look into the hardcopy concept; a de facto text based screenshot.

The Fun Stuff – Screen Window Types

And just when we thought we ‘d seen it all, after the vast array of different options, all the possibilities of screen.. There is still one more special option to mention. Screen has three different window types.

The first window type is the normal window type we’ve been using all along. The regular window with a traditional shell inside.

The second window is initiated by starting screen with as a first parameter a tty (character special device) device name, like for example /dev/ttya. This command connects screen directly to the character device and allows interaction with for example a null modem serial connection trough screen. To accommodate this, screen takes baud and other relevant settings as parameters. The info command now returns some of the modem control lines in the status line and the break command now sends the standard break signal over the device.

The third type is a telnet window. This is started using //telnet as a first parameter, followed by the host name and optionally a port as the third parameter. Screen will then act as a telnet client and interface with a remote telnet server. As with the device type, the telnet window returns telnet specific information when using the “info” command. The break command sends the telnet break signal to the server. This option is only available if screen was compiled with the BUILTIN_TELNET option.

• Or connect to a serial terminal?

Its in the end as simple as ..

screen /dev/ttyS0 19200 1n8

This might not seem too spectacular as an option, but not needing an extra program and instead being able to use good ‘ol screen can be a good and quick solution for when you need this, instead of installing minicom or whatnot.
And remember .. “A weird imagination is most useful to gain full advantage of all the features.” (Listed as a bug under the screen man page.)

The articles in this series focus on the following topics..

• The Simple stuff
  • Slightly more advanced stuff
• The fun stuff
  • Command Parameter, Multi display mode, Copy Mode
  • Nethack, Different screen windows, Sending commands to all screen windows
  • Different regions, Logging, Screen Window Types
  • the .screenrc

Im happy to say we re having our Launch Party on 12/07/09 at the Oude Abdij in our home town of Kortenberg!

We spent an exciting period of setting up the tools and servers and are now Ready to come out and Party

• Open-Future Launch Party – Making Open Source work for You!
• Date: 7/12/2009
• Location: Oude Abdij, Kortenberg
• Timing: 4 to 6 PM
• Address: Abdijdreef 22, 3070 Kortenberg
• Subscribe at marketing@open-future.be
• Feel free to forward this invitation to anyone you feel might be interested!
• Sponsored by Redhat and Zarafa
• www.open-future.be

Meet the crew! Attend the party and have a drink Its on us..

I wrote this Gnu Screen guide in December ‘08 with the previous incarnation of linux.com in mind. January 2009 however, linux.com started on its new and exciting path as a community site and the article just sat on my machine, waiting. So I decided to publish it on my blog in a four part series over the following month. Maybe someone can use it

Have you ever had to run a time consuming process (say mkfs or compiling something) over a shoddy ssh connection? Or cleanly run several commands in parallel without having several open connections to that server? Or maybe you were programming and wanted a mysql prompt, a bash prompt and several text editors open? How about that ssh tunnel you need open and dont want to close by accident? And did you ever need to perform the same task on several different machines? Or connect to a serial terminal? Or maybe you just want a log file of what you re doing..
These are day to day situations any linux user will run into, that can be quite frustrating. That is, before you discover Gnu screen!

“Screen is a full-screen window manager that multiplexes a physical terminal between several processes, typically interactive shells.” Or at least, thats what the site calls it. Sounds easy enough, but there are an amazing amount of different uses for this incredible piece of software. The above list is some of the uses I could readily think about – some of the ways I regularly use screen, but like any decent linux tool – the sky really is the limit! I’ll be looking into different issues, so lets jump into some of the practical solutions for those problems.

The Fun Stuff – Nethack
Because linux is all about FUN (or at least written by fun loving people), screen has a cool option where all messages are given nethack style, instead of the standard bland wording. Screen has to be compiled using the Nethack option, but most linux distributions do.
The nethack option it toggled by the presence of the $NETHACKOPTIONS environment variable or a ~/.nethackrc file.

No other window.

becomes

You cannot escape from window 0!

or

Creating logfile "screenlog.0".

becomes

You add to your scroll of logging named "screenlog.0".

The nethack ones are actually More Fun, really!

The Fun Stuff – Different screen windows
Up till now, we covered using screen and the posibilities of several sessions. But because switching between sessions is not really what you d call user friendly or quick, screen has an interesting mechanism called windows. One screen session can contain several windows and switching between these is simple using a number of shortcuts. The existing screen terminal is always the first window. To create a new window, use the following shortcut.

C-a c
C-a C-c     (screen)      Create a new window with a shell and switch to that window.

This creates a new window & switches to that window. Now you have two (or more if you want) different windows in the same screen session. To switch between the different sessions, you can use the following shortcuts.

C-a space
C-a n
C-a C-n     (next)        Switch to the next window.

C-a backspace
C-a h
C-a p
C-a C-p     (prev)        Switch to the previous window.

This is a good way to switch between the windows, but it quickly grows old when you have a lot of open windows to switch between. To make things a bit more manageable; screen has several other shortcuts.

C-a ’       (select)      Prompt for a window name or number to switch to.C-a 0       (select 0)
  ...            ...
C-a 9       (select 9)
C-a -       (select -)    Switch to window number 0 - 9, or to the blank window.

These help, but there is still a better way.

C-a "       (windowlist -b)  Present a list of all windows for selection.

This shortcut gives the user an interface where he can select an open window.

Num Name                                                                                                        Flags
 0 bash                                                                                                            $
 1 bash                                                                                                            $
 2 bash                                                                                                            $

And to keep this heap of windows organised, there are yet 2 more shortcuts.

 C-a A       (title)       Allow the user to enter a name for the current window.
 C-a N       (number)      Show the number (and title) of the current window.

These are a lot of different shortcuts and mechanisms, but in the end – its all worth the effort! Lets take a look at the list of examples we made at the start of the article and solve another one!

• Or maybe you were programming and wanted a mysql prompt, a bash prompt and several text editors open?

I dont think the practical side of this example needs much more explaining. Opening the screen session, creating the different windows, renaming the windows and using them appropriately should be straightforward enough. Setting the whole thing up only needs to be done once, since you can simply detach the session, However if you need this setup on a regular basis, you can configure your “.screenrc” to load it at startup. More on the .screenrc later.

The Fun Stuff – Sending commands to all screen windows
Once you re used to the multiple windows, you might run into a situation where you want to send a same command to several of these open windows. Screen provides in the “at” command to do this. First you ll need to open command line mode.

C-a :       (colon)       Enter command line mode.

This way you can type a command once, but you ll still have to enter each separate window. But there is a better way. As an example we ‘ll send “ls -l” to all the windows.

at "#" stuff "ls -l^M"

This command is barely readable, so let’s pick it apart! The first part is ‘at [identifier][#|*|%] command’. The at command sends the text parameter to all the windows you specified in the identifier. You can match the criteria to either the window name or number with #, the user name with * or the displays, using %. The next part is the command you want to run in the selected windows. We’re using “stuff” to stuff the command we want to execute into the input buffer of the selected windows. Stuff is really straightforward. It simply stuffs the string you gave as a parameter. Next problem is the command. Or rather having it executed! To get screen to put an “enter” after the command, to execute the command, add “^M” at the end. You can do a lot more with this than just sending an ls to the input. Any screen command, like renaming, moving windows around, whatnot .. is available in combination with “at”.
This also applies to screen session using the -X parameter on the command line, for those special occasions where you just dont want to connect to the session or when you’re scripting something wholly exciting!
Special thanks go out to Guy Van Sanden, who helped me figure out this command.

• And did you ever need to perform the same task on several different machines?

The possibilities of this command are vast and this is only one of the many that come to mind. The first and most obvious is when you need to close a screen session with too much windows to close by hand. Stuffing an “exit^M” into the open windows until the screen sessions are alle effectively closed is quite usefull!
The real luxury however is when you need to install the same software on several different machines. You start by opening ssh connections to the boxes you want to administer. You might consider using the .screenrc to open the connections and ssh keys to facilitate the loging in. Once logged in, you can send the appropriate commands (for example “sudo yum install htop”) to the different screen sessions, effectively managing all those machines at the same time. This is ofcourse something to use with extreme caution – imagine deleting the wrong directory on one of those boxes – but a conscient administrator should be able to use this to his advantage!

The articles in this series focus on the following topics..

• The Simple stuff
  • Slightly more advanced stuff
• The fun stuff
  • Command Parameter, Multi display mode, Copy Mode
  • Nethack, Different screen windows, Sending commands to all screen windows
  • Different regions, Logging, Screen Window Types
  • the .screenrc

I wrote this Gnu Screen guide in December ‘08 with the previous incarnation of linux.com in mind. January 2009 however, linux.com started on its new and exciting path as a community site and the article just sat on my machine, waiting. So I decided to publish it on my blog in a four part series over the following month. Maybe someone can use it

Have you ever had to run a time consuming process (say mkfs or compiling something) over a shoddy ssh connection? Or cleanly run several commands in parallel without having several open connections to that server? Or maybe you were programming and wanted a mysql prompt, a bash prompt and several text editors open? How about that ssh tunnel you need open and dont want to close by accident? And did you ever need to perform the same task on several different machines? Or connect to a serial terminal? Or maybe you just want a log file of what you re doing..
These are day to day situations any linux user will run into, that can be quite frustrating. That is, before you discover Gnu screen!

“Screen is a full-screen window manager that multiplexes a physical terminal between several processes, typically interactive shells.” Or at least, thats what the site calls it. Sounds easy enough, but there are an amazing amount of different uses for this incredible piece of software. The above list is some of the uses I could readily think about – some of the ways I regularly use screen, but like any decent linux tool – the sky really is the limit! I’ll be looking into different issues, so lets jump into some of the practical solutions for those problems.

The fun stuff – Command Parameter
So far for the basics. We ve covered the strenght of being able to attach & detach a session, but screen has a wad of other options that prove fun toys.

Screen allows you to provide a command as a parameter.

screen <Screen Parameters> <command> <Command Parameters>

Screen executes the command given in the parameter. The parameters before the command are parsed by screen, the parameters after the command are passed on to the command. Without additional parameters, screen will open a session, execute the command and close afterwards. Screen cleans up after closing so any output to the terminal is erased afterwards.

$ screen ls

[screen is terminating]

While this might not seem too spectacular, this really opens a world of possibilities.
The first benefit is obviously when starting a remote command you don’t want interrupted by a failing connection. You could right as easily start a screen session and type the commands there, but in the end, you ‘ll notice that typing “screen” before the command is a tad quicker than doing it in the two passes. This is of course only the case if the command you need to run does not finish with any meaningfull output you need to study.. although if it does, you can always pipe it into a file. I frequently use this for moving files or even running a vi or emacs session

screen mv foo bar

The other and most important benefit is scripting. The option to run commands in a screen session out of a script allows for a broad spectrum of different possibilities. My favorite example is a screen – ssh wedding..

• How about that ssh tunnel you need open and dont want to close by accident?

One of my daily screen applications is an icon I have on my desktop. It opens an ssh tunnel to a designated server, authentication over ssh is handled by a public key and the screen options are as such that the session is either created or reattached. All my outgoing mail trafic is tunneled trough ssh to make sure that I dont have to change servers depending on what location I am working at.

#!/bin/bash

if [[ $( screen -ls | grep -c tunnel.Gen ) == 1 ]]

then

   gnome-terminal -e "screen -r tunnel.Gen" --hide-menubar -t "Gen"

else

  screen -d -m -S tunnel.Gen ssh user@host -L 25025:smtp.server.com:25

  gnome-terminal -e "screen -r tunnel.Gen" --hide-menubar -t "Gen"

fi

The workings of the script should be quite obvious, so I’ll skip that part and shed some light on the screen parameters. The “screen -r ..” part should be clear by now, this reattaches the screen session. The “-d -m” option tells screen to create a new session that is not attached to the terminal. And the “-S” option names the session, as we discussed before.
Thus effectively creating a tunnel window that can be automatically closed & opened at will, without losing the tunnel; and can effectively be terminated by exiting the ssh connection.

The Fun Stuff – Multi display mode
When we were talking about reattaching an attached session, we talked about another option instead of detaching the session.
Screen allows multi display mode. Before we get all excited, I want to point out a small detail in the setup. The users need to have access to the screen session. As we discussed before, this means they somehow both need the same user rights. This can be achieved by both logging in as the same user or by sudo or the likes. Two users on the same account does admittedly sound messy on a sysadmin level, but this might actually be worth while.

Multi Display Mode allows different users to connect to the same screen session together. This provides a powerfull tool for teaching someone terminal related knowledge in a shared environment or even have an attempt at solving an advanced problem together. To start such a session, both users should be able to access the same session (user). One of them starts the session as usual – preferably with an easy name.

screen -S Shared

And then have the other person connect to the session using the “-x” parameter.

screen -x Shared

& that will give you a nice shared session where you can have some fun together.

This is a trick that thoroughly helped me when simultaneously installing several servers with a colleague some years ago. This way we could continue each others work when necessary and avoided conflicting operations on the same machine.

This technique has been featured on Linux.com before though. Using screen for remote interaction by Philip J. Hollenback. The article goes in much more detail, although I have to admit the setuid aspect Really sets me off. The security consequences are just too big. But no comment on screen on that part. There is simply no way to do what needs to be done without the setuid flag. The other option would be to have the sessions available to all users and that would be an actual flaw, while the setuid flag is a potential flaw.

In the end, we can only conclude that this is a powerful option with lots of potential; but only under the right special circumstances.

The Fun Stuff – Copy Mode
After using screen for a while, one thing that will probably bother you is that the classic shift – pgup / pgdown doesnt work. Being unable to scroll back to earlier output or check command output beyond one page soon turns out to be quite the nuicance. To solve this, copy/scrollback mode – or vi command mode – can be used.

C-a esc     (copy)        Enter copy/scrollback mode.

This opens the buffer in a vi like mode where you can scroll back and forth in the buffer and use a whole set of different commands. Commands for scrolling around in the buffer, several ways of searching the text, several commands for selecting text in different patterns and yanking it for using elsewhere.
To make full use of the numerous keys in this mode, you should look up the “copy” chapter in the screen man page.

The articles in this series focus on the following topics..

• The Simple stuff
  • Slightly more advanced stuff
• The fun stuff
  • Command Parameter, Multi display mode, Copy Mode
  • Nethack, Different screen windows, Sending commands to all screen windows
  • Different regions, Logging, Screen Window Types
  • the .screenrc

We re trying a Picture of the Day effort with some of the Open-Future peeps..

Post one picture each day. Of Anything.

* Take a picture using your phone. (No recycling, a fresh picture each day!)
* Post it to twitter/Identica
* Mention the #PictureOfTheDay tag in the message.

Picture of the Day

Feel free to join in!

I wrote this Gnu Screen guide in December ‘08 with the previous incarnation of linux.com in mind. January 2009 however, linux.com started on its new and exciting path as a community site and the article just sat on my machine, waiting. So I decided to publish it on my blog in a five part series over the following month. Maybe someone can use it

Have you ever had to run a time consuming process (say mkfs or compiling something) over a shoddy ssh connection? Or cleanly run several commands in parallel without having several open connections to that server? Or maybe you were programming and wanted a mysql prompt, a bash prompt and several text editors open? How about that ssh tunnel you need open and dont want to close by accident? And did you ever need to perform the same task on several different machines? Or connect to a serial terminal? Or maybe you just want a log file of what you re doing..
These are day to day situations any linux user will run into, that can be quite frustrating. That is, before you discover Gnu screen!

“Screen is a full-screen window manager that multiplexes a physical terminal between several processes, typically interactive shells.” Or at least, thats what the site calls it. Sounds easy enough, but there are an amazing amount of different uses for this incredible piece of software. The above list is some of the uses I could readily think about – some of the ways I regularly use screen, but like any decent linux tool – the sky really is the limit! I’ll be looking into different issues, so lets jump into some of the practical solutions for those problems.

The Simple stuff
The simple way to use screen is to create a session, run a command in it, detatch the session and then, at some later time, reattach it again.

Creating a session is really simple.

 $ screen

Once the session is created, you ‘ll have a prompt where you can just run anything you need. Once you ‘ve started any program you d want to run, you can close the window you re running screen in or use the shortcut detach the screen session more elegantly. Each shortcut consists of a “Ctrl – a” followed by some other character.

C-a d
C-a C-d     (detach)      Detach screen from this terminal.

This is the notation used in the man pages. This combination detaches the screen session and leaves you on the terminal prompt where you started the session. The screen process continues in the background.
To take control of the session again, you can have screen reattach the running session.

 $ screen -R

This wil reattach the running screen session. There is a catch though, if there is more than one screen session active, this will not work. We will solve that in the slightly more advanced part.

Now lets take this dry manpage replication to the next level with some practical uses..

• Have you ever had to run a time consuming process (say mkfs or compiling something) over a shoddy ssh connection?

This solution is quite straight forward. Open the connection to the remote server & open a screen session there. Run any commands you need inside the screen session. Now if the connection fails or if you accidentally close the window; screen will detatch and will still be running on the server. Next time you log on to the server, the screen process will still be there, working as you left it and waiting for you to reattach it. (providing noone killed it or did a reboot)

• How about that ssh tunnel you need open and don’t want to close by accident?

About the same thing, with the difference that you ll want to create the screen session on your own machine. Open a screen session and start the ssh tunnel inside the screen session. Now you can close the term window or free up that terminal without closing your ssh connection & tunnel. You might consider scripting the process to open a gnome-terminal window with the new or reattached screen session. Next you could make life even simpler by adding the script to the desktop with a pretty icon. This is the trick I use to send mail over the internal office smtp servers. Thanks to this tunnel, I am sure I will always be able to mail out (providing ssh trafic is not being blocked..) even if the internal network wouldn’t normally allow it.

Slightly more advanced stuff
The slightly more advance stuff covers several screen sessions; naming your screen session; reattaching an attached screen session and more.. So lets dive in!

Lets say you’ve created a screen session, detatched it & created a second screen session. Now you have 2 screens running & the “-R” option wont choose for you which session to reattach. First we’ll need to check what screen sessions are running, using the “-ls” or “-list” option.

 $ screen -ls
There are screens on:
21251.pts-1.GenX	(Attached)
21229.pts-1.GenX	(Detached)
21211.pts-1.GenX	(Detached)

3 Sockets in /var/run/screen/S-gert.

In the above output, we can see my 2 detached screens & the one attached screen session. The command also shows the id, name and the server name in the following fashion “pid.tty.host” Reattaching one of these is fairly simple.

 $ screen -r pid

To reattach a screen session, you use the pid of that screen session you want to reattach as a parameter. If you want you can use the full “pid.tty.host” name, but this is not necessary. If you name your screen session you can also use the name to select the screen session you want to reattach. We ll talk about naming a session next.

When creating a screen session, the session gets a pid number and a name. When the user doesn’t choose a name, the system uses tty.host as standard name. You can name your screen session by adding “-S name” as a parameter.

 $ screen -S name

Now that we ve named our screen session, “-ls” gives the following output.

There is a screen on: 18665.Editor	(Detached)1 Socket in /var/run/screen/S-gert.

As you can see, the session is now named “pid.name” and can now be reattached with “screen -r Editor” as wel. The reason why to do this should be obvious as most people are better at remembering a chosen word instead of some random number.

Detaching and reattaching screen sessions creates the problem that a teminal may crash, leaving the screen session in an “attached” state, while for all practical purposes – its unattached. Trying to attach an attached screen session will trigger an error, telling you that there is no screen to be resumed and showing the session to be attached.

There is a screen on: 18665.Editor	(Attached)There is no screen to be resumed matching 18665.

To reattach that session, you will need to detach the session first. Detaching works exactly the same as attaching, using the “-d” option. Once the session is detached, you can reattach it again, as we described before.

screen -d Editor

The screen command is, as you might understand by now, quite extensive. Screen provides several options for this situation; combined lower and upper case “d” and “r” parameters for detaching or even forcing a session to be reattached. Anyone finding themselves in this situation should read the relevant man pages (”man screen”) to find the combination of parameters that best suits their specific needs. There is another option for dealing with an attached screen session and since its particularly interesting, we will go into more detail on that later.

These commands are all relative to the previous examples. Enabling you to enjoy different screen sessions and manipulate them with more ease. The logical next question here is what screen does in a multiuser environment. We all enjoy Linux’s strong user based approach and screen follows trough in this philosophy. Screen sessions belong to the user that started them and any user escalation that happens inside of the screen session (su, whatnot) remains within the session. Any security-conscientious user or administrator will make the obvious objections here (and should), but like other tools, screen is only as secure as the person using it.

The articles in this series focus on the following topics..

• The Simple stuff
  • Slightly more advanced stuff
• The fun stuff
  • Command Parameter, Multi display mode, Copy Mode
  • Nethack, Different screen windows, Sending commands to all screen windows
  • Different regions, Logging, Screen Window Types
  • the .screenrc

Mozilla Firefox has a Great plug-in (One amongst many) called Mobile Barcoder 0.2.0.

Its basically the solution for that moment when you find an article you want to read, but want to read it on your mobile instead of your laptop. But dont want to type that long URL. Simple solution.. Make a QR code out if it

Simple mouse over thingy, generates a QR on the go; scan it & walk away

Im looking to get some of that functionality on my blog, mouse over style. I might ‘ve found the right plugin, but have yet to test it..

Disclaimer: This is not a screenshot of my machine, screenshot courtesy of the plugin developer!

After a strenuous 9 weeks (check the earlier blog post for some frustrations) I am happy to announce that I will be working for Open Future as of tomorrow, Oct 8th, o9!

Open - Future

Who Where What?
Well, we re Belgiums new Open Source company, joining the ranks of the very few other open source oriented businesses with the plan to do it better; to Be The Best (Isnt that why everyone gets up in the morning? Hehe)
On this new adventure with my trusted colleagues, a group whose strengths and weaknesses are well known and balanced in a wonderful lil rope act of teamwork (am I going overboard with the imagery here??) Amongst who are Bert & Guy (as seen on planet.grep)
Asfor the rest of the questions; there s a site for all that! (Every site its purpose..)

lol, what a post so far And all I wanted to say was that I Really look forward to the new challenges my new & bright Open Future will bring

(The first of which being the cold turkey switch from an azerty to a qwerty laptop!! Took me Slightly longer to type this post)

After recently installing the Koala, moving my data over to the new install & installing the packages from the list I exported earlier, I noticed that totem had apparently switched to smurf mode. Smurf mode asin everything utterly blue. (Even Hellboy – bit hard not to notice, everyone & thing blue)

After some annoying moments, I finally checked the interwebs & found the following post “nvidia sets HUE to -1000” which explains that the totem needs to be told that we dont want a -1000 hue after all

The Solution:
Go into the totem edit > preferences dialog. Select the Display tab.
You ll see that the “Hue” slider is set entirely to the left. Put it back in the middle or use the “Reset to defaults” button to reset all Color Balance sliders to their default position.

The bug report suggests that this needs to be repeated with each new clip, but so far that doesnt appear to be the case.. And while we re talking totem, the new resume option is amazing!

Hooray for Red!