Claytronics, if smart robots are in O(scary), then this is in Omega(scary^{scary})

Picture this:
- Imagine a day when you can make your cell phone smaller to fit more comfortably in your pocket, then make it larger so you can text more easily.
- Imagine that you could make your cell phone take the shape of a headset when you want to talk on it or re-shape it like a bracelet so you can wear it while jogging
- Now imagine a robot that could take different shapes depending on a certain line in its code.
Well, imagining time is over because Intel and CMU are now working to create programmable matter. This is how it works, take millions of millimeter-sized robots and enable them, through software and electromagnetic forces, to take on various shapes and sizes. The programmable matter is called claytronics and the tiny robots are called catoms. Each catom will have its own processor. Think of each catom as a tiny robot or computer that has computational power, memory and the ability to store and share power. Then program millions of catoms to work together, much like a swarm of bees or a flock of birds (and this is not ant-colony algorithm btw). Developers are focused on creating software that will focus on a pattern or overall movement of the system of tiny robots. Then each robot will be smart enough to detect its own place in the pattern and respond accordingly. If, for instance, a catom, or robot, detects that it has only one other catom beside it, it will know that it's on an end and can act according to what the end piece should be doing.

And it gets even better, it also could mean that instead of looking at images on a screen, gamers could have animated figures running around their houses(right on the face of project Natal). And instead of calling your co-worker to discuss something, a 3D facsimile of him or her could sit in your office and discuss a new project or the next year's budget.

The challenges involved include creating new programming languages, algorithms and debugging tools to get these massive systems to work together any a host of other things. But this on one dimension of robotics bound to revolutionize life as we know it.



credits: computerworld and acm

Tired or 'Humankind' Olympix? How about 'Robotkind' Olympix?

Sounds like science fiction? Not really. China has announced plans to hold a robot Olympics in 2010, in which humanoid robots will compete in 16 different events ranging from athletics to machine-related tasks such as cleaning. The organizers expect more than 100 universities from around the world to participate in the competition, which they believe will drive innovation and lead to the development of robots that are more flexible and helpful. The event will take place at the Harbin Institute of Technology, home of a robot research group that has built a successful team of soccer-playing humanoids. However, a specific date for the robot Olympics has not been set, too bad (I want to book a ticket :P). China faces a crowded calendar for robot sports and other competitive events. The 2010 RoboGames are scheduled for April in California, and there is an annual competition for robots that can mix cocktails, light cigarettes, and chat with bar patrons called Roboexotica. The world cup for robots, which drew entries from 400 teams in 35 nations last year, will take place June 2010 in Singapore, and the Federation of International Robot-Soccer Associations runs a similar event.

PS: The games will be open to only Humanoid robots

What will "A Midsummer Night's Dream" be when done by Robotkind?

A production of William Shakespeare's "A Midsummer Night's Dream" at Texas A&M University will feature both human and robotic performers. An AirRobot helicopter and six toy radio helicopters will serve as the production's fairies. The robotic performances are being used by the Texas A&M's Department of Computer Science and Electrical Engineering and the Department of Electrical and Computer Engineering to learn more about how people react to the flying devices. "It's now possible for these unmanned aerial vehicles to be used for evacuation or for crowd control," says Texas A&M professor Robin Murphy. "But what's missing is understanding what makes a person trust or fear the robot." Over the course of the production's rehearsals and first performances, the researchers have documented several surprises, including that people thought the robots were smarter and tougher than they really are. Initially, people would handle the robots rather roughly, and launch them from different positions, resulting in damage. The actors also showed little fear of the robots, which Murphy says could cause people to become complacent and possible ignore a robot's instruction or walk into the rotor blades and be hurt. "The robots by themselves apparently aren't scary, so we need additional research to make them move like friendly hummingbirds or angry bees to get the desired effect," she says.

read more here

credits: acm

Robot Operating System, the next big thing

As majority of the World still graples with the possibility of having machines (robots) which are so close to human nature that we feel threatened, something new is rising in the field of robotics. The need for standardized software to drive these machines has been a craving of robotics researchers for quite some time now. While others are already embarking on creating laws to govern robots in the future, some of us have decided to focus our attention on this more pressing issue. Because after all, robotocs research won't go anywhwre without the support of known concepts like open source an software re-use. Which is why component based robotics is a thing of today, the challenge being, to be able to have a set of standard (a range would do) robotics components for various whatever applications and have standard software to manage these, just like we have computers all over the world. A number of efforts have been done in this direction, some of thee include general ones like Player (a framework for robotics, quite old and much closet to being accepted as standard, its open source too), ORCA (fully component based and also a great idea), and also specialized ones like Openrave (a planning architecture for mobile robotics developed by Diankov and CMU). But the one that has caught my interest alot is the ROS(Robot Operating System), initially started at Stanford for the STAIR project, but mostly built by Willow Garage. This is what I believe is a close to a full operating system for robotics in the present times. Computation is organized in terms of nodes and a publish/subscribe system in used for communication with support for a number of technologies including XML-RPC. Furthermore, it is compartible with would be competitors like Player and Openrave and a combination of the three (which is what I work with currenlty, gives you just what you need). As we continue to build more of these, it is noteworthy to realize just how this concept is important to robotics research. To find out more about these systems, 'google' them and visit respective pages. ;)

Moral Machines, a joke or just reality in the future

Apparently, this may real sometime soon. Scientists at the Universidade Nova De Lisboa, in Portugal, and the Universitas Indonesia, in Indonesia, are researching artificial intelligence and the application of computational logic to create machines capable of making decisions. The researchers are investigating prospective logic as a way to program morality into a computer. They say prospective logic can model a moral dilemma and determine the logical outcomes of all possible decisions, potentially allowing for machine ethics. Machine ethics would enable designers to develop fully autonomous machines that can be programmed to make judgments based on a human moral foundation. For example, the researchers say that machine ethics could help psychologists and cognitive scientists find a new way of understanding moral reasoning in people, or extract fundamental principles from complex situations to help people decide what is right and wrong. The researchers have developed a system capable of working through the "trolley problem," an ethical dilemma proposed by British philosopher Philippa Foot in the 1960s in which a runaway trolley is about to hit five people tied to the track, but the subject can hit a switch that will send the trolley onto another track where only one person is tied down. The prospective logic program can consider each possible outcome based on different scenarios and demonstrate logically what the consequences of its decisions might be. The next step would be to give each outcome a moral weight so a prototype might be developed to make the best judgment as to whether to flip the switch.

Read more here

Responsible Robots? How about responsible humans first?

They say charity begins at home, and indeed this should be the case in the world of robotics as well, at least according to these two Reseachers who envisions a new set of laws different from what Asimov gave us. Ohio State University professor David Woods and Texas A&M University professor Robin Murphy have drafted three laws of responsible robotics that they claim are more realistic and applicable to the future than science fiction writer Isaac Asimov's laws. Woods says he believes Asimov intended to use the laws as a literary device, and did not expect engineers to design robots to follow the laws to the letter. "We wanted to write three new laws to get people thinking about the human-robot relationship in more realistic, grounded ways," he says. Woods and Murphy's three laws place responsibility on the shoulders of human beings rather than robots, and target the human organizations that develop and deploy robots. The researchers sought ways to guarantee high safety standards. Woods and Murphy's first law decrees that humans may not implement robots without the human-robot work system being in compliance with the highest legal and professional standards of safety and ethics. The second law dictates that robots must respond to people as appropriate for their roles, while the third law requires robots to be imbued with enough situated autonomy to protect themselves as long as such protection enables the smooth transfer of control and does not clash with the other two laws. "You don't want a robot to drive off a ledge, for instance--unless a human needs the robot to drive off the ledge," Woods says. "When those situations happen, you need to have smooth transfer of control from the robot to the appropriate human."

Just to highlight this further, here are Asimov's laws:

A robot may not injure a human being, or through inaction, allow a human being to come to harm.

A robot must obey orders given to it by human beings, except where such orders would conflict with the First Law.

A robot must protect its own existence as long as such protection does not conflict with the First or Second Law.

For more info see this.

Robot with moods

A hyper-realistic Einstein robot at the University of California, San Diego has learned to smile and make facial expressions through a process of self-guided learning. The UC San Diego researchers used machine learning to “empower” their robot to learn to make realistic facial expressions.

“As far as we know, no other research group has used machine learning to teach a robot to make realistic facial expressions,” said Tingfan Wu, the computer science Ph.D. student from the UC San Diego Jacobs School of Engineering who presented this advance on June 6 at the IEEE International Conference on Development and Learning.

The faces of robots are increasingly realistic and the number of artificial muscles that controls them is rising. In light of this trend, UC San Diego researchers from the Machine Perception Laboratory are studying the face and head of their robotic Einstein in order to find ways to automate the process of teaching robots to make lifelike facial expressions.

This Einstein robot head has about 30 facial muscles, each moved by a tiny servo motor connected to the muscle by a string. Today, a highly trained person must manually set up these kinds of realistic robots so that the servos pull in the right combinations to make specific face expressions. In order to begin to automate this process, the UCSD researchers looked to both developmental psychology and machine learning. Read more here.

Communications of ACM, July Edition is Out

Look Inside >>  July 2009

Simplify and beautify documentation using Doxygen

Doxygen is a tool that generates documentation for certain types of code in a number of languages such as C++, python, Java, C and Objective C, Fortran, PHP, VHDL etc. The documentation is written within code, and is thus relatively easy to keep up to date. Doxygen can cross reference documentation and code, so that the reader of a document can easily refer to the actual code. KDE uses Doxygen for parts of its documentation and KDevelop has built-in support for it. And as one would expect, its free and is released under GNU public licence, and is cross platform.

Here is a sneak preview of what doxygen can do;

1. It can generate an on-line documentation browser (in HTML) and/or an off-line reference manual (in ) from a set of documented source files. There is also support for generating output in RTF (MS-Word), PostScript, hyperlinked PDF, compressed HTML, and Unix man pages. The documentation is extracted directly from the sources, which makes it much easier to keep the documentation consistent with the source code.
2. You can configure doxygen to extract the code structure from undocumented source files. This is very useful to quickly find your way in large source distributions. You can also visualize the relations between the various elements by means of include dependency graphs, inheritance diagrams, and collaboration diagrams, which are all generated automatically.
3. You can even `abuse' doxygen for creating normal documentation (as I did for this manual).

For more info, look at doxygen

Integrating Qt apps on Gnome desktop

We all know that not all apps that you find on gnome may satisfy all your needs, a good example is Scribus. This app has no decent gnome equivalent, and hence a Qt integration will be quite useful. So I dug some stuff up and came up with a simple method for this integration;

install qt3-qtconfig using either yumex if on Fedora, or synaptic on Ubuntu

Then run qtconfig from the commandline.

Click the tune palette button, and make sure you adjust the Base, Background & Button colors to R: 237, G: 233, B: 227. Click OK, and do File, Save and close ‘qtconfig’. If you now restart Scribus you’ll notice it’s still not pretty, but it’s more tolerable now.

Qt4 will incoporate the cleanlooks theme, which make things better.

Read Mail while programming on emacs

With emacs vm, and emacs zerinc modes, programming can get anymore fun than it is already. Just in case you are wodering how, here is a quick setup for the emans vm mail. Edit your .emacs file with the following, note that that you have to enter user specific details like username and server address.

;; Some file locations are relative to my HOME or BIN directories
(defvar home-dir)
(setq home-dir (concat (expand-file-name "~") "/"))
(defvar bin-dir (concat home-dir "bin/"))

;; Basic VM setup
(push (concat bin-dir "emacs/site-lisp/vm") load-path)
(autoload 'vm "vm" "Start VM on your primary inbox." t)
(autoload 'vm-other-frame "vm" "Like `vm' but starts in another frame." t)
(autoload 'vm-visit-folder "vm" "Start VM on an arbitrary folder." t)
(autoload 'vm-visit-virtual-folder "vm" "Visit a VM virtual folder." t)
(autoload 'vm-mode "vm" "Run VM major mode on a buffer" t)
(autoload 'vm-mail "vm" "Send a mail message using VM." t)
(autoload 'vm-submit-bug-report "vm" "Send a bug report about VM." t)
(setq vm-toolbar-pixmap-directory (concat (expand-file-name "~") "/bin/
emacs/site-lisp/vm/pixmaps"))
(setq vm-image-directory (concat (expand-file-name "~") "/bin/emacs/
site-lisp/vm/pixmaps"))
(setenv "PATH" (concat (concat (expand-file-name "~") "/bin/emacs/
site-lisp/vm/bin") ":"
(getenv "PATH")))
(setq send-mail-function 'sendmail-send-it)
(setq user-full-name "User Name")
(setq user-mail-address "username@email.com")
(setq mail-archive-file-name "~/Mail/SENT")

;; Configure inbound mail (POP)
;; edit this details
(setq vm-spool-files
 '(("~/INBOX" "pop-ssl:pop.mailserver.com:995:pass:username:*" "
~/INBOX.CRASH")))

;; Use W3M to read HTML email
(require 'w3m-load)
(setq vm-mime-use-w3-for-text/html nil)
(setq vm-url-browser 'w3m)
(load "vm-w3m")
(setq w3m-input-coding-system 'utf-8
 w3m-output-coding-system 'utf-8)

;; Configure outbound mail (SMTP)
(setq smtpmail-starttls-credentials '(("smtp.mailhost.com" 587 nil nil))
 smtpmail-smtp-server "smtp.mailhost.com"
 smtpmail-default-smtp-server "smtp.mailhost.com"
 send-mail-function 'smtpmail-send-it
 message-send-mail-function 'smtpmail-send-it
 smtpmail-smtp-service 587
 smtpmail-auth-credentials '(("smtp.mailhost.com"
   587
   "username@mailhost.com"
   nil)))

Have fun coding while updated with your emails.

OpenUsability

Wednesday, April 29, 2009 at 10:13 AM

Inspired by Google Summer of Code™, the OpenUsability Season of Usability is a series of sponsored student projects to encourage students of usability, user-interface design, and interaction design to get involved with Free/Libre/Open Source Software (FLOSS) projects. Students experience the interdisciplinary and collaborative development of user interface solutions in international software projects while getting into FLOSS development.

If you are a student of design, usability, human factors, or other HCI-related field and you are interested in working on an open source project, you could work with an experienced usability mentor on a fun and interesting design project! As a bonus for working 10-15 hours a week between June 1 and August 31, there is a $1000 USD internship stipend at the end of the project.

The OpenUsability Season of Usability will be supporting 10 students to work on 10 open source projects during the June 1 - August 31 2009 season.

* Amarok
* Drupal
* Gallery
* GeneMANIA
* GNOME
* Kadu
* KOrganizer
* OLM
* SemNotes
* Ubuntu

Student applications are due May 20 2009. See http://season.openusability.org/index.php/projects for more information on the projects, student requirements, and how to apply. Questions about the projects or application process may be directed to students@openusability.org.

Openmoko

Openmoko™ is a project dedicated to delivering mobile phones with an open source software stack. Openmoko is currently selling the Neo FreeRunner phone to advanced users and will start selling it to the general public as soon as the software is more developed.

Writting apps for openomoko is greatly simplified by use of python and GTk, an example script would be;

import gtk

#create a (nonvisible) window
w = gtk.Window()

#create a button (not yet on any window)
b = gtk.Button('Hello')

#put the button on the window
w.add(b)

#create a silly callback function
def hello(target):
print 'Hello world'
exit()

#make the button call the callback when pressed
b.connect('clicked', hello)

#make the window display
w.show_all()

#start processing screen events
gtk.main()

Openmoko is a project which encompasses two related sub-projects, with the combined aim of creating a family of open source mobile phones.^[1] The project was founded by FIC.

The first sub-project is Openmoko Linux, a Linux-based operating system designed for mobile phones, built using free software.

The second sub-project is the development of hardware devices on which Openmoko Linux runs. The first device released was the Neo 1973,which was followed up by the Neo FreeRunner on 25 June 2008. Unlike most other mobile phone platforms, these phones are designed to provide end users with the ability to modify the operating system and software stack. Other Openmoko-supported phones are also available.

On 2009-04-02 Openmoko canceled planned phones and will probably concentrate on other kinds of hardware,but will still support and sell the current Neo FreeRunner.

More info can be found at http://wiki.openmoko.org/wiki/Main_Page

Openchange

OpenChange aims to provide a portable Open Source implementation of Microsoft Exchange Server and Exchange protocols.

Exchange is a groupware server designed to work with Microsoft Outlook, and providing features such as a messaging server, shared calendars, contact databases, public folders, notes and tasks.

Two main aspects are;

• Provide interoperability with Exchange protocols.
  

  ---

  
  This is the MAPI library development purpose (libmapi). MAPI stands for Messaging Application Programming Interface and is used within Microsoft Exchange. The OpenChange implementation provides a client-side library which can be used in existing messaging clients and offer native compatibility first with Exchange server; and in a near future with OpenChange server. Novell Gnome Evolution and KDE Akonadi (KMail, Mailody) are using the OpenChange MAPI library to access Microsoft Exchange servers natively.



• Provide a transparent replacement to Microsoft Exchange Server with native Exchange protocols support and direct communication with Microsoft Outlook.

  ---

  
  This basically means that OpenChange server won't need any plugin installation in Outlook. The server is tighly linked to Samba4 since it is developed as an endpoint module for smbd (the samba server daemon) and is part of the mapiproxy project, an Exchange proxy which can act as a transparent gateway and/or progressively and seamlessly replace an Exchange server with openchange.

The Openchange project was founded in 2003 at EPITECH by Julien Kerihuel in the context of his Epitech Innovative Project. Julien is the project manager, lead developer. The OpenChange team is now made up Samba, KDE developers and Epitech students.

During this years Gsoc 2009, Three students

Student	Project	Mentor	Status
Ryan Lepinski	Exchange2Ical tool	Brad Hards	accepted
andrey yakubovich	Thunderbird Integration with OpenChange	jelmer vernooij	accepted
billy okal	GRAPHICAL FRONT END FOR OPENCHANGE	julien kerihuel	accepted

will be working on different projects for Openchange in the above projects over the summer.

GSOC 2009: Results are out, its time for community bonding

So what is this community bonding all about?

One of the biggest changes to the program this year is the inclusion of nearly two extra months in the program timeline. "We got some great feedback from our students and mentors last year that three months is often too little time to read necessary documentation, write code and participate in the organization's community in-depth. Since our not so secret desire is for our students to stick around and keep contributing to their organization's code base long after the program ends, we figured we'd give you some extra time to get up to speed on the community side." Says Leslie Hawthorn.

In practice, the community bonding period is all about, well, community bonding. Rather than jumping straight into coding, you've got some time to learn about your organization's processes - release and otherwise - developer interactions, codes of conduct, etc. We also figured it would be easier to socially engage with your fellow developers when the pressure to ship isn't looming in your vision. I know few folks who didn't lurk in a project's IRC channel for weeks or even months before submitting their first patch, let alone saying hello and getting to know the other folks in the channel.

If you've already worked with with your organization's code base and developers, great! Take this time to help out your fellow students who haven't. There's a great deal of undocumented lore in every community, and your previous experience can be invaluable to them as they get started.

And why aren't you mentoring already? ;)

Intelligent Data Interpreter

For the retrieval and analysis of especially large amounts of geo-spatial data the international standardization committee Open GeoSpatial Consortium (OGC) now published the "Web Coverage Processing Service" (WCPS) as a worldwide standard. WCPS defines a computer language, which for the first time ever can retrieve sensor, image, and statistics raster data from remote geo data servers, independently of data format and server programming. In addition, WCPS allows the selection, linkage and analysis of the data directly with each inquiry. Developer of the intelligent geo data retrieval service is Peter Baumann, Professor of Computer Science at Jacobs University.

I currently work on this project as assistant Programmer in C++, and this is really good news for us in the team.

Google Summer of Code

Once again it is that time of the year when coding invades the lives of computer scientists aroud the World. Applications for student participation in this years Google Summer of code 2009 aka gsoc started this monday 23rd and is set to end on April 4th. Enthusiasm is high, judging by the number of mentoring organizations entered as well number of project ideas posted so far. Fedora Project for instance together with JBOSS will be spomsoring as usuall a number of interesting projects. Make sure you are not left out by deadline issues. Get your gears ready and let the summer be even more fun coding.

Shuffle Algorithms

Ever wondered why when you select the Shuffle option in your Ipod, MP3 or whatever gadget that you are using to play your music, there is something peculiar with the randomness of teh choice of songs. Somehow some tracks just get repeated too often, especially when your collection is limited alot. Well, I recently took time to explore what goes on behind the 'scenes' and discovered something puzzling. There is a problem with the shuffling, that is, it is random. I know this sounds like am kidding but I am not, be assured. A simple random function implementation in Python for example generates the following:

AACBBCBACABBCCACCCCABBACBACABABB 

And I am pretty sure implementation in other languages will generate something of similar manner. Now, it does not take much effort to see that the randomness of the above output is not what we desire. Assuming that A, B, and C are tracks, one can easily notice the biasness to C in the middle of the shuffle. Also there are very few instances of B. This is not what is intuitively believed to be shuffling. Because we want shuffle to give equal chance to every track in the playlist and do so in a random manner, but what do we get; a 'randomness that is random'. To explain the intuitive understanding of shuffle, this is what we expect with shuffle 'on'.

ABCBCABACBACBCABCACBABCACBACBCAB

But, this is where the problem comes, how do we develop a shuffle algorithm that is efficient enough to generate something like the one shown above from the playlist. I will discuss a possible algorithm that solves this problem next time. Till then, have fun pondering over the problem.