A team of our students is competing for the 2014 edition of the Eurobot contest (french chapter). Their PhaROS-based robot came to life. You can see it in action in the videos below.
Category Archives: Pharo
PhaROS @ FOSDEM 2014 – Video Presentation
As i already shout in the FOSDEM 2014 slides post, i have presented PhaROS in the last edition of FOSDEM, under the title of PhaROS: Towards Live Environments in Robotics.
I bring now to you this video taken during the presentation. I wish you to enjoy it!
Sorry if my hair is disheveled :), i am not very photogenic.
http://mirror.as35701.net/video.fosdem.org/2014/K4401/Saturday/PhaROS.webm
Enjoy it!
TaskIt: a Framework for Concurrency
As part of the PhaROS and related projects, Santiago Bragagnolo had developed TaksIt a framework for to ease handling concurrency. Expressing and managing concurrent computations is indeed a concern of importance to develop applications that scale. A robotic application often have different processes dealing with different activities (e.g. preception, planning, …).
TaskIT provides abstractions to schedule and/or parallelize of the execution of pieces of code. They will be described in the forthcoming chapter of the Pharo for the Entreprise book. First content is already available online. You can also get the code by evaluating the following expression in a Pharo workspace:
Gofer it
smalltalkhubUser: 'sbragagnolo' project: 'TaskIT';
configurationOf: 'TaskIT';
loadVersion: #bleedingEdge
PhaROS – FOSDEM 2014 – Slides
PhaROS has being in this last edition of FOSDEM (2014) we are proud to share our time and space with a lot of open source projects. Thank you very much for good feelings, feedback and sharing this amazing time.
Video and photos from this great event will be soon available here. Meanwhile, here are the slides
Keep tuned!
Using PhaROS tool
PhaROS tool has the mission of installing and creating packages into a ROS installation.
For doing this we have several commands, from installing and creating to administrating repositories, so you can manage your own packages and creating templates without major problems.
Install PhaROS tool
We are working for having this package in Ubuntu and ROS repositories, but meanwhile you can download it from here: pharos-deb
Once downloaded just execute
sudo dpkg -i pharos.deb
pharos –help
Install PhaROS based Package
pharos install PACKAGE [OPTIONS]
Example
pharos install esug –location=/home/user/ros/workspace –version=2.0
Help
pharos install –help
Create PhaROS based Package
pharos create PACKAGE [OPTIONS]
Example
pharos create –location=/home/user/ros/workspace –version=2.0 –author=YourName –author-email=YourEmail
Tip: Be sure the email is a correct one. If is not a correctly spelled one you will notice during last step.
Help
pharos create –help
Register Repository of packages
pharos register-repository –url=anUrl –package=aPackage [ OPTIONS ]
Example
pharos register-repository –url=http://smalltalkhub.com/mc/user/YourProject/main –package=YourProjectDirectory –directory=YourProjectDirectory
Tip: If your repository requires user/password for reading add –user=User –password=Password to the example.
Disclaimer: User/Password will be stored in a text file without any security.
Help
pharos register-repository –help
Listing registered repositories
pharos list-repositories
Creating a directory for your own project repository
pharos create-repository PACKAGENAME [ OPTIONS ]
Example
pharos create-repository example –user=UserName > directory.st
pharos create-repository example –user=UserName –output= directory.st
Help
pharos create-repository –help
Pharos — Command line for infrastructure
We are now really glad to present an enhanced way to deal with PhaROS.
Since we want to keep with the ROS community spirit of collaborative development for robotics, we introduce now our own command for managing packages made in PhaROS.
This command is mean to install existing packages and create new packages with cool snippets and examples for going faster through the learning time.
PhaROS tool is made completely in Pharo smalltalk and it allows to deploy an existent package into a pharo 1.4/2.0/3.0 in any distribution of ROS that uses catkin package. It automatize the generation xml, makefiles, type and scripts creation, going on the direction of letting the pharo programmer to focus just in programming and not in infrastructure stuff.
For Installing and Using please check this post: using-pharos-tool
PhD Defense of Nick Papoulias on 19th December 2013
After 3 years of work, Nick is about to finish his PhD. His defense is planned on the 19th of December 2013 at 10:00. It will be held at Ecole des Mines de Douai. You’ll find below the abstract and the keywords that describe his work entitled: “Remote debugging and reflection in resource constrained devices”. The committee gathers the following people:
Reviewers:
- Marianne Huchard, Professor at University of Montpellier, LIRMM Laboratory, France
- Alain Plantec, Associate Professor at University of Brest, Lab-STICC Laboratory, France
Members:
- Roel Wuyts, Professor at K University of Leuven, Belgium
- Serge Stinckwich, Associate Professor at University of Brest, and member of the IRD research Institute, Bondy, France
Advisor: Stéphane DUCASSE, Research Director at INRIA, Scientific Director of INRIA Lille, Head of the RMoD Team, France
Co-Advisors:
- Luc Fabresse, Associate Professor at Ecole des Mines of Douai, France
- Marcus Denker, Researcher at INRIA Lille, RMoD Team, France
- Noury Bouraqadi, Associate Professor at Ecole des Mines de Douai, France
Summary of the PhD
Building software for devices that cannot locally support development tools can be challenging. These devices have either limited computing power to run an IDE (e.g smartphones), lack appropriate input/output interfaces (display, keyboard, mouse) for programming (e.g mobile robots) or are simply unreachable for local development (e.g cloud servers). In these situations developers need appropriate infrastructure to remotely develop and debug applications.
Yet remote debugging solutions can prove awkward to use due to their distributed nature. Empirical studies show us that on average 10.5 minutes per coding hour (over five 40-hour work weeks per year) are spend for re-deploying applications while fixing bugs or improving functionality. Moreover current solutions lack facilities that would otherwise be available in a local setting because its difficult to reproduce them remotely (e.g., object-centric debugging). This fact can impact the amount of experimentation during a remote debugging session – compared to a local setting.
In this dissertation in order to overcome these issues we first identify four desirable properties that an ideal solution for remote debugging should exhibit, namely: interactiveness, instrumentation, distribution and security. Interactiveness is the ability of a remote debugging solution to incrementally update all parts of a remote application without losing the running context (i.e without stopping the application). Instrumentation is the ability of a debugging solution to alter the semantics of a running process in order to assist debugging. Distribution is the ability of a debugging solution to adapt its framework while debugging a remote target. Finally security refers to the availability of prerequisites for authentication and access restriction.
Given these properties we propose Mercury, a remote debugging model and architecture for reflective OO languages. Mercury supports interactiveness through a mirror-based remote meta-level that is causally connected to its target, instrumentation through reflective intercession by reifying the underlying execution environment, distribution through an adaptable middleware and security by decomposing and authenticating access to reflective facilities. We validate our proposal through a prototype implementation in the Pharo programming language using a diverse experimental setting of multiple constraint devices. We exemplify remote debugging techniques supported by Mercury’s properties, such as remote agile debugging and remote object instrumentation and show how these can solve in practice the problems we have identified.
Keywords: Remote Debugging, Reflection, Mirrors, Interactiveness, Instrumentation, Distribution, Security, Agile Development
Our Robots Can Help You Shopping
In a recent experiment we demoed a scenario of how a robot can be used to help shoppers (see Video below). The robot computes the optimal path for picking items of an arbitrary shopping list. It carries the bag and guides the shopper to items locations. As we explain in the slideshow (below the video), there are other possible applications of mobile robots in a shopping. We also give a quick overview of hardware and software. We reused some existing ROS packages that we combined with our own software built using the PhaROS client based on Pharo a Smalltalk inspired OO dynamic language.
Video: A Robot Made to Help Shoppers
Slideshow about the RoboShop project
Parametrized Tests
Being a TDD fan, I’m writing tests all the time. And I sometimes ended up having groups of nearly identical tests:
- they use exactly the same objects, send the same messages,
- but they differ only by values.
In a discussion on the Pharo-dev mailing list, Laurent Laffont pointed what is done in PhpUnit and suggested to have something similar in Pharo. After a few hours hacking I’ve my parametrized tests working and integrated with the test runner to ease debugging.
I’ve introduced a ParameterizedTestCase which supports both “plain” tests as well as parametrized tests. This class should be subclassed as in the following example:
ParameterizedTestCase subclass: #ExampleOfParameterizedTestCase
instanceVariableNames: ”
classVariableNames: ”
poolDictionaries: ”
category: ‘ParameterizedTests’
A test method is any method that is marked with the pragma testParametersSelector: as in the following example:
ExampleOfParameterizedTestCase>>#should: value1 plus: value2 equals: expectedSum
<testParametersSelector: #givenValuesAndTheirExpectSum>
self assert: value1 + value2 equals: expectedSum
The argument of the pragma testParametersSelector: is the selector of a method that provides a collection of arrays. Each array gathers parameters for a different test case. In our example the method givenValuesAndTheirExpectSum is defined as following:
ExampleOfParameterizedTestCase>>#givenValuesAndTheirExpectSum
^{{1. 2. 3}.
{10. 20. 30}.
{100. 200. 300}}
Since we have three arrays of parameters, we will have 3 different test cases all three with the same test selector, but each with a different parameters array. This is displayed by the test runner as shown in picture 1.
Picture 1: Passing Parametrized Test
If any of the parameters arrays leads to a test failure, the Test Runner will display the failing test selector as well as the parameters that lead to the defect. For demo purpose, let’s introduce some invalid parameters and change the previous givenValuesAndTheirExpectSum method as following:
ExampleOfParameterizedTestCase>>#givenValuesAndTheirExpectSum
^{{1. 2. 3}.
{10. 2. 30}.
{100. 200. 0}}
I have changed the second and the third parameter arrays. The Test Runner detects indeed 2 failing tests out of 3 runs as shown in picture 2. As you can see the parameters that lead to the defect are displayed so, one can identify the origin of the defect.
Picture 2: Failing Parametrized Test
I have developed and tested parametrized tests under Pharo 2.0. If you want to try it, you can install it by evaluating the following expression in a workspace.
Gofer it
url: ‘http://car.mines-douai.fr/squeaksource/BoTest’;
package: ‘ParameterizedTests’;
load.
It is worth noting that although in the examples I have given above data is hard coded, nothing prevent from adopting an approach as suggested by Frank Shearar in his Squeak Check project. Method that return the array of parameters can rely on any arbitrary complex data generator class, that may produce different data randomly each time tests are run.
First Tests of a Helper Robot in a Shopping Mall
At the ESUG 2013 conference, we presented the current status of the RoboShop project. Santiago did a great job and now we are able to run tests of our scenario of a helper robot in a shopping mall. Based on a map built using laser SLAM, the robot computes the shortest path to fetch items listed by a customer in a shopping list. The slides below include a video of the first tests. They also give a bird’s eye view of the architecture, where we use Pharo for orchestration. We also reuse existing software from the ROS community through our client PhaROS.