Like other embedded systems, spacecraft computers use real-time operating systems (RTOS) and languages:

* The Rosetta probe ultimately runs SCL (Spacecraft Command Language) [1], a COTS spacecraft programming language developed for sale to the military [2]; SCL is based on the syntax of Ada 83, which has a long legacy in spaceflight and other real-time applications (e.g. Boeing 777) [3]. However, what are known as Flight Control Procedures (uploaded commands), are written using another language and transformed and compiled into SCL in a two-step process that involves XSLT [1]. On-board Control Procedures, which are procedures the probe decides on its own to run, and handle tasks such as receiving FCPs and sending back telemetry, are written in SCL [1].

* The Mars rover Curiosity is programmed in C and uses the VxWorks RTOS [4], which is very much like many commercial embedded systems. It has about 2.5 million lines of code, much of it autogenerated. Curiosity's predecessors, Spirit and Opportunity, used the same software stack, as did their predecessor, Sojourner [8].

* The Voyager probe, which has now left the solar system and entered interstellar space, uses "...interrupt driven computer[s], similar to processors used in general purpose computers with a few special instructions for increased efficiency. The programming is a form of assembly language." [5]

* The Space Shuttle was programmed in a custom language called HAL/S (High-order Assembly Language/Shuttle) [6], as was the Jupiter probe Galileo [7]. The language is descended from PL/I and its compiler is written in a subset of PL/I called XPL.

[1]: http://www.rheagroup.com/wp-content/uploads/2014/01/SpaceOps...

[2]: https://www.sra.com/scl/

[3]: https://en.wikipedia.org/wiki/Ada_(programming_language)

[4]: http://programmers.stackexchange.com/a/159638

[5]: http://voyager.jpl.nasa.gov/faq.html

[6]: https://en.wikipedia.org/wiki/HAL/S

[7]: https://en.wikipedia.org/wiki/Galileo_(spacecraft)

[8]: http://programmers.stackexchange.com/a/159687

Very interesting. I didn't think C would be used that much (except for the core of the os of course). I somehow thought of either a specialized language with strong guarantees (such as ADA), or a high level language for IA-like feature.

Which makes me wonder, since this is HN after all, if Rust wouldn't be an ideal candidate for coding this kind of layer in the future. Maybe a compiler targeting VxWorks is in progress somewhere.. ? :))

Anything even remotely new is usually not a candidate for these types of long duration missions. Part of it is institutional inertia, but also partly a desire to use a technology stack that will still be in use decades from now. Even for missions that only take a few years, some of the same people will work on those missions as well as decade plus missions, so you have to hire people who are experts in mature technologies. Institutions like NASA and ESA want to work with a technology stack that will remain stable and which they know will be maintainable by people in the future.

C and languages that compile to C (Fortran is used as well) are often employed since you have powerful control over memory usage.

Source: I work in the aviation industry, where the technologies are different but the lifecycle concerns are very similar.

Most likely they have headless web browsers running on both the main spacecraft (probably chromium) and the Philae lander. Web sockets enables the lander to communicate to the spacecraft which then sends its signals down to earth using regular HTTP (you don't want to keep an interstellar HTTP connection open). All of it is of course written in JavaScript, more specifically vanilla-JavaScript - which frankly I find weird given that I'd hope they would use a framework such as socket.io - bad engineering if you ask me. The lander obviously uses latest Node.js and npm to update some of its modules which are again sent across the wire using interstellar HTTP.

You joke, but FTP has indeed actually been used to communicate between Earth and a probe. A team at NASA's JPL , led by Vinton Cerf, completed a study of what would be needed for an Interplanetary Internet [1]. There are already IETF RFCs for delay-tolerant networking [2], which include mechanisms for store-and-forward communications (e.g. each transceiver is a relay).

Science fiction has some great depictions of interstellar communications, such as my favorite by Vernor Vinge, the Hugo award-winning novel A Fire Upon the Deep. It is a most excellent space opera that prominently features an interstellar system like Usenet as part of the plot [3], as well as superhuman intelligence, physics, and all sorts of other wonderful bits.

[1]: https://en.wikipedia.org/wiki/Interplanetary_Internet

[2]: https://en.wikipedia.org/wiki/Delay-tolerant_networking

[3]: https://en.wikipedia.org/wiki/A_Fire_Upon_the_Deep

All this without docker? Their devops team is seriously behind the times...

This is the best thing I've read all day.

I think there's probably some CFML involved too?

There's some discussion here, written by Attila Baksa who according to his linkedin is "Designer and developer of flight software of On-board Computer of the Rosetta Lander of ESA, which was successfully launched in 2003 and arrived to comet P67 in 2014."

eg: "The on-board software of the central computer of the Philae Lander consists of a real-time operating system and 8 application tasks. All these software modules are specially developed by our team for the Harris RTX2010RH microprocessor. The co-ordination of the scientific program and the overall control of the algorithms used by the application tasks are done by the MSO modelling language."

http://www.hiradastechnika.hu/data/upload/file/2004/2004_12/...

Also the "scheduling system, called the Rosetta SGS Scheduling Component" is discussed here:

https://ai.jpl.nasa.gov/public/papers/chien_iwpss2013_schedu...

which uses a framework called APSEN written by NASA:

http://aspen.jpl.nasa.gov/

which takes code like this:

Activity prevalve removal {

duration = 15

slot subsystem

after prevalve prep with (subsystem == this.subsystem)

before prevalve replace with (subsystem == this.subsystem)

Reservation hydraulic lift usage {

resource = hydraulic lift; usage = 1;

duration = 5;

requires state prevalve-purged TRUE

requires state prevalve-illuminated TRUE

to control the thing

http://metahack.org/isairas97-aspen.pdf

This article is a classic, coming up on 20 years old, specifically about how differently the shuttle software team was from the dotcoms. http://www.fastcompany.com/28121/they-write-right-stuff

No idea how relevant it is today, or any differences between the shuttle team and whoever's building/built the software for this lander, but it's definitely worth a read.

There was a nice bit about the shuttle's computer systems in the Challenger appendix to Surely You're Joking, Mr. Feynman, too. As I recall, it was the only part of the shuttle process that Feynman thought was engineered correctly.

Ron Garrett (formerly Erann Gat) has some background on how these decisions are made. It's not pretty.

http://www.flownet.com/gat/jpl-lisp.html

Also his "How I lost faith in Lisp" post is interesting.

I'm not sure how I stand on "w/ a great language one does great things" vs "great engineers do great things with any tools they have" debate.

There is not much to find, but apparently, they do software updates over the "air": http://blogs.esa.int/rosetta/2014/03/28/software-upgrade-at-...

While I'm not sure what this exact probe is built upon, some popular choices for mission critical applications I've seen in the past are:

* VxWorks for real time operating system (proprietary)

* Ada/C++ for programming language.

Here's a handful of videos and presentations: http://flightsoftware.jhuapl.edu/files/_site/workshops/2013/

The last answer here has a lot of links for the Curiosity Rover: http://programmers.stackexchange.com/questions/159637/what-i...

Start with vxWorks.