I was introduced to the bash builtin /dev/tcp by warg the other day on x-tab#chat. He explained a basic use of this device by demonstrating how to download wget’s compressed tarball. The download process itself can be done with pure bash, but some post-processing of the downloaded file must be done to remove HTTP headers. I document warg’s application of /dev/tcp here because I found the idea fascinating and want this documentation for myself .

Connecting and Downloading

To read about the /dev/tcp builtin for yourself, check out the following:

$ info '(bash) Redirections'

With the exec line we initiate the connection, allocating a file descriptor and storing the numeic file descriptor into the HTTP_FD variable. Then, with the echo line, we send an HTTP request through the descriptor to the server. After sending the request, we process the server’s response with the sed line which skips over the HTTP headers sent by the server and stows the results into wget-latest.tar.gz. Note that this last command will sit around for a while. It is with this command that the builk of the data transfer is performed. And, since you’re using shell redirections to download the file, you cannot see the download progress. Instead, wait for the command to complete. This also involves waiting for the server to time out your connection since it supports pipelining. After this process is completed, the wget-latest.tar.gz file is as your disposal.

$ WGET_HOSTNAME='ftp.gnu.org'
$ exec {HTTP_FD}<>/dev/tcp/${WGET_HOSTNAME}/80
$ echo -ne 'GET /gnu/wget/wget-latest.tar.gz HTTP/1.1\r\nHost: '\
    ${WGET_HOSTNAME}'\r\nUser-Agent: '\
    'bash/'${BASH_VERSION}'\r\n\r\n'  >&${HTTP_FD}
$ sed -e '1,/^.$/d' <&${HTTP_FD} >wget-latest.tar.gz

Now you have a wget source tarball on your machine. As long as you have tar and a compiler on the machine, you are well on your way to downloading stuff using a self-compiled wget. In the commands above, you may replace “gz” with “bz2″ or “lzma” for smaller downloads if the machine you’re using has bzip2 or xz-utils installed. And, of course, it should not be too hard to repurpose the above code to download a particular version of wget or even a completely unrelated software package.

Please feel free to point out problems with this approach or give pointers on porting this to other environments .

There are numerous guides about setting up Google Voice and an incoming sip number for free outgoing calling. Sadly, all of the guides I found were written for FreePBX or some other Asterisk bundle, and also used a shell script to do much of the work (scary!). I have compiled the minimal amount that you need to put in your asterisk conf files to make things work, GUI-free and variant-independent.

Prerequisites

First off, you need a sip number. I recommend sipgate or ipkall (I use sipgate, it’s much more user-friendly). If you google around, you’ll find out how to set up your sipgate/ipkall number as an incoming number in asterisk, I won’t waste time covering it here.

Secondly, you need a google voice number. Once you get said number, turn off call presentation. Also, assign the account a password that you don’t mind having plaintext in a conf file. In addition, you must add your incoming sip number as a phone in google voice. I’d recommend connecting a softphone to your sip number to set this up with google’s verification call, or redirect all incoming calls in Asterisk to your extension.

Thirdly, you need pygooglevoice. Download and install it, or use python’s easy_install command.

The outgoing rule

Now for the actual configuration. First you need to set up an outgoing call rule, so all calls to the outside world (in this case, 10-digit numbers preceded with a “9″) are directed though google voice.

[CallingRule_LocalCalls]
exten = _9XXXXXXXXXX,1,Goto(custom-gv,${EXTEN:-10},1)

Explanation: Any outgoing 10-digit number prefixed with a 9 will match this rule and go to the custom-gv section which we will set up later. The number that was dialed is passed (the “-10″ excludes the 9 prefix from this) at the first dialplan rule.

The GV dialer

Now we need to set up the custom-gv section:

[custom-gv]
exten => _X.,1,Verbose(0, Custom-GV Preparing to call and park call at number ${EXTEN})
exten => _X.,n,Wait(1)
exten => _X.,n,Playback(pls-wait-connect-call)
exten => _X.,n,System(gvoice -e me@me.com -p GVPassword call ${EXTEN} IncomingNum &)
exten => _X.,n,Set(PARKINGEXTEN=701)
exten => _X.,n,Park()

Explanation: After you dial an outgoing number, you’ll be dropped in here. The Verbose() function tosses some output in debug level 0 and up (see the console for this output). The System() command dials the number with google voice. Make sure you change the items in strikethrough to your own personal information. The call is then parked on extension 701 (70X extensions for parking are default. Switch to your parking extension range if you are using non-default options).

Routing GV callbacks

Now you need to set up an incoming call rule. Direct all incoming calls from your sip number at this rule.

[incoming-call-sifter]
exten = s,1,NoOp(CIDredirect)
exten = s,2,Verbose(0, Got incoming CID ${CALLERID(num)}, redirecting…)
exten = s,3,GotoIf($["${CALLERID(num)}" == "GVNumber"]?custom-park,s,1)
exten = s,4,Goto(section-to-route-normal-incoming-calls,s,1)

Explanation: If your google voice number rings your PBX, you know that it’s connecting you to the call you just dialed, so we need to reconnect it to the extension you dialed from. We’ll handle linking of the incoming GV call and your outgoing call (which is now parked) in the next section (custom-park).

Bringing it all together

The custom-park section links a google voice incoming call (which is actually ringing the person you originally dialed) with your original outgoing call (which is parked).

[custom-park]
exten => s,1,Verbose(0, Got incoming GV Callback! Connecting to your original outgoing call…)
exten => s,2,ParkedCall(701)

Explanation: After you dialed your external number, your call was parked as google voice started dialing the other number. This section joins your outgoing call with google voice’s incoming call, so you are connected to the party you originally dialed.

You’re done!

Well that turned out to be a bit longer than I expected, but if you know what you’re doing, you can just ignore the italicized text.

It looks like getting free data access on iDen handsets is going to end, likely on or before 6/20/10 according to this Sprint document (credit Engadget). Coincidentally, this is the same day that the Motorola i1 is released, the first Android phone on the iDen network. With this phone, Sprint would needed to lock down iDen data access a bit harder than blocking the phone’s built-in browser (the status quo), so the change will affect all phones on the iDen network (Boost and Nextel).

This also means that getting mobile connectivity for your Arduino will no longer be free. Boost mobile’s data rates run at $.35/day.

Update: 6/20 has passed, and I still have data access.

Rubber rafts were used for tube maintenance and installation

The Super-Kamiokande consists of a 41m tall by 39m wide stainless-steel tank filled with purified water. The walls of the tank are lined with 13,000 photomultiplier tubes (think night vision goggles for cosmic rays). The photomultipliers amplify the cosmic rays and measure them, sending data back to a central computer system. Very accurate information regarding the ring direction and type of neutrino sensed can be derived from the time and magnitude measurements of the photomultiplier tube.

Worker with Photomultiplier Tube

In 2001, one of the photomultiplier tubes imploded, setting off a chain reaction of imploding tubes in the detector tank. The detector was restored by removing the damaged detectors and evenly distributing the remaining detectors. Full reconstruction did not take place until 2006, when over 6,000 detector tubes were replaced and covered with acrylic shields to prevent future implosion.

Installing the final PMT panel

Over many years, the Super-Kamiokande and predecessors have detected many solar phenomena, detected data from exploding stars, and could possibly help us understand more about the formation of matter in the future.

For more information about the Super-Kamiokande and for high-resolution photos (albeit a slow server), check out the official site. Wikipedia also has a concise article regarding the Super-Kamiokande and neutrino detectors in general.

Photos graciously provided by Kamioka Observatory at the University of Tokyo.

Popularized with the ever-present  iPhone and expanding into the tablet and desktop sector by companies such as Dell and HP, multitouch is becoming an interesting addition to today’s user interfaces. Overseas companies, such as Asus, are also taking advantage of the technology in new inexpensive tablets; even Gateway is offering a mulititouch tablet these days. Despite the popularity of multitouch, especially on the mobile platform, it seems like a technology with stunted growth and limited applications.

Key points (if you’re too lazy to read the article)

• Today’s interfaces are not designed for multitouch
• Multitouch would require redesigning and rethinking of most GUIs
  • Multitouch often wastes screen real estate
  • With multitouch, one often can’t see what’s under one’s finger
  • Multitouch requires larger on-screen items for finger interaction
• Do we need multitouch? What advantages does it pose?
  • Multitouch provides a more organic interface between human and computer
  • Multitouch allows simultaneous on-screen manipulation of multiple objects

No GUI Support

Most modern GUIs have little to no support for multi-touch technology. One prime example of this is Windows 7, which came with multitouch built-in, but the software updates have little impact on end-user experience. Multitouch is still limited to a specific audience in Windows 7, as navigating through the “All Programs” in the start menu, clicking on links in web pages, and using system tray icons are all quite challenging using one’s fingers. Also, multitouch gestures are not well-implemented into the operating system. To be extremely effective, Windows should have bindings for custom gestures, or at least include more default gestures for the base operating system itself.

Current applications are also severely limited with multitouch interactions, as most applications available today have small hard-to-tap virtual buttons. Including larger buttons wastes screen real-estate and can be a bit unsightly. Many applications also require keyboard input to accomplish a variety of functions. It would be extremely challenging to implement numerous keyboard-based functions into on-screen gestures and buttons. One other prominent issue with touchscreens in general is that one’s finger obscures the item that is being clicked, which makes clicking small objects extremely challenging.

No Need

Next comes the big question: do we really need multitouch? Many people have the opinion that navigation is much faster with a keyboard and mouse than a touchscreen. This is true for most applications, such as web browsing that involves a good deal of typing and link-clicking.

Advantages

Despite the downsides stated, multitouch does provide some advantages to human-computer interaction. For instance, multitouch allows manipulation of multiple objects, or multiple characteristics of objects, at the same time. One simple example of multi-object interaction would be a digital soundboard, where sliders and dials must often be adjusted simultaneously. This would be impossible using a single mouse pointer, and would not allow precise control of speed with a keyboard.

Multitouch also provides for more organic interaction with computers, allowing the manipulation of digital data in a more physical manner. This interaction could be flipping through photos, organizing files, or moving windows around the desktop.

Image courtesy of RobotSkirt