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.

• 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.

• 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.

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.