Super Star

Note: These pages describe the application process for a Software Engineer Superstar position, which we are trying to fill. The announcement is at http://ihmc.us/robotjobs/


  • The application process for this job is going to be intense and time intensive. If you crave challenges, great. If not, we advise you not to continue.
  • The application process could take 40 or more hours for the successful applicant and we can only hire one person at this time. We cannot pay you for your application efforts.
  • This application process is for an expert programmer. If you cannot program extremely well in either Java (our main language), or a similar Object Oriented language, you are not who we are looking for.
  • This application process is going to be broad. Although a programming expert is key requirement, you will be required to have a broad skill set as indicated by the background section below. If all you can do is program, you are not who we are looking for. If you are the person everybody goes to with programming questions, computer questions, or questions about third party software, then you might be who we are looking for.
  • The application procedure is going to be hard. This is not a cruel joke to try to make you feel like you’re a poor programmer, but a tool to help us find the best, the brightest and the most talented programmer. We wish to hire someone who is smarter than us, and a better programmer than we are. Some of the challenges will be problems that have challenged many in our lab. If you ace all the problems, we will be impressed.
  • To be fair, we will answer inquiries as to what your chances are once you start getting deep into the process. We also will inform you how many other people are in the running at each later stage. Our goal is not to string you along, but to find that one superstar.
  • If you do get far into the process and do really well, yet you do not get an offer, we hope that the work you have done will make you better prepared for other opportunities.
  • We are looking for someone who not only can get through the challenge, but enjoys the fact that it is challenging. So once again, if you crave challenges, read on. If not, we advise you not to continue. We warned you…


We are looking to hire a software engineer superstar to work with a team of about 20 researchers developing legged robots, exoskeletons, and human-robot interfaces. See http://robot.ihmc.us/ for some pictures and videos of past and current projects. This person will:

  • Develop new software, software tools, and techniques to be used by the IHMC robotics lab, our collaborators, and the world at large.
  • Improve existing software tools and techniques which are used by the IHMC robotics lab, so that they are also useful for our collaborators, and the world at large.
  • Maintain, document, disseminate, and advocate these software tools and techniques.
  • Maintain our third party software tools, such as our SVN server, Atlassian Confluence, Bamboo, and Jira servers, etc.
  • Be an in-house expert on all of the software tools and techniques.
  • Establish and maintain a web repository and users group for our collaborators and world at large to use our software.
  • Write articles and blog posts about our software to advocate and teach it to others.
  • Answer user group questions, write FAQ pages, reply to email enquirers concerning the software.
  • Increase productivity of the robotics group and competence and quality of the robots through reliable awesome software.
Typical software that needs to be written, maintained, documented, disseminated, etc:
  • Legged robot simulation software. We currently use an in-house package called the Simulation Construction Set. It needs improvements, feature additions, better test cases, better documentation, etc.
  • GUI robot visualization tools.
  • User interface device software for joysticks, midi slider boards, brain interface devices, etc.
  • Improved automatic build, unit test, and quality control software and tools.
  • Software toolboxes for things like polygons, trajectory generators, etc.
  • Real time robot software.
  • Some low level device drivers.

The person will not need to:

  • Directly develop new robot control software and algorithms. If you are not a software person, but a robotics person who writes software but doesn’t truly enjoy writing software, then this job is not for you. We do also need robot algorithm developers from time to time and will post announcements similar to this one. But this job is for software development. If you like things like kinematics, inverse kinematics, dynamics, Jacobians, PD controllers, twists, wrenches, model predictive control, neural networks, bipedal walking algorithms, etc., you will not be focusing on these things. You might dabble in them from time to time, but more from a high quality software perspective, than from a robotics control perspective. However, if you are both a software superstar and a robotics superstar, then you might be able to get more into robotics control as time goes on, if you contribute massive amounts of code, tests, documentation, etc. and if you find a replacement programmer, who is a better programmer than yourself to fill your shoes.
  • Write research papers.
  • Manage robotic projects. However, from time to time you may need to lead up to a handful of interns or other programmers who will assist your program development activities.
Some details of our software development practices:
  • Nearly all of our software is in Java. We sometimes write some C++ or use C++ libraries, but nearly always wrap it in Java before consumption. We are open to consider other software languages if they are faster than Java in all three of development time, maintenance time, and run time.
  • We use the Eclipse IDE.
  • We use various software development tools from Atlassian, including Jira, Bamboo, Clover, Confluence, and Fisheye.
  • We use some agile programming techniques to various degrees and success, including pair programming, unit testing, morning meetings, and iterations.
  • We use JUnit4 unit testing and despite our intentions never write enough or high enough quality tests, but wish to do much better.
  • We use Ant scripts for our automatic builds, but rely on the convenience of Eclipse for normal compilation and jar file creation.
  • We currently use Swing for GUI development and Java3D for 3D visualization, but are open to using better GUI and 3D packages.
  • We use a variety of third party Java libraries, though we often are not quite happy with them and end up writing our own for many things.
  • We currently have a few collaborations and wish to grow our list of collaborators. We also wish to make much of our software freely available to other researchers and the world at large.
Knowledge, Skills, and Abilities:

Below are some knowledge, skills, and abilities a successful applicant will need to possess. If you don’t currently have some of these skills, but are a “quick learner”, then go ahead and quickly learn these skills if you wish to get through this job application challenge. You should give this challenge a try if you:

  • Excel at object oriented programming. Preferably in Java, but other object oriented programming experience works too. However, our application process will require you to write lots of high quality code in Java, so the person to be hired will need to become a skilled Java programmer if they are to get through the application process.
  • Love to program and proud of your creations. Have no problem spending a weekend doing some software challenges.
  • Understand the benefits of unit testing and have seen first hand what unit testing is good for.
  • Have had experience pair programming and can articulate its advantages and disadvantages.
  • Understand the relative importance of fast code, readable code, and correct code.
  • Type blindingly fast, uses shortcuts and auto complete like a Jedi, and yet find that maximum typing speed is one of the main impediments to amount of quality code written per day.
  • Pay excruciating attention to detail.
  • Write extremely readable, clean code.
  • Write extremely readable, clean unit tests.
  • Are brilliant at logic problems and can develop and implement algorithms for logic problem-like problems.
  • Are good at math including geometry, linear algebra and calculus.
  • Work well both solo, when pair programming, and in a team of 10.
  • Can work with great independence.
  • Can investigate and understand the true meaning of a vague bug report or feature request.
  • Can implement an algorithm based on a textual description from a text book or a research paper.
  • Can design logical, understandable, usable, and maintainable API designs.
  • Can take a piece of spaghetti code and untangle it into a clean implementation while retaining or improving its functionality.
  • Know when to and how to optimize for speed, and when to leave speed optimization alone.
  • Can hunt down the most obstinate bugs like a skilled detective.
  • Are enthusiastic about quality software and writing massive amounts of useful, readable, well-tested, reliable, robust, quality software.
  • Can take a chunk of third party code, navigate through it, figure out how to use it, and write a clean adapter to its API if its existing API is poor.

If you’ve read this far and you are still interested in applying for the job, then take the red pill and move on to the first set of challenges.