FORTH is FIRST!

[Julian Skidmore]

Breaking News!

The ESA Philae lander has just landed on a comet, the first time that's ever been done! Amazingly, the Lander's CPU is a radiation-hardened RTX2010, a native FORTH CPU. http://en.wikipedia.org/wiki/RTX2010

We're in good company!

--

                             
                  The DIY 8-bit computer from nichemachines™

[Romilly Cocking]

ISTR that FORTH has been on all the NASA probes.

--
You received this message because you are subscribed to the Google Groups "FIGnition" group.
To unsubscribe from this group and stop receiving emails from it, send an email to fignition+...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Si Brindley]

Wow! If there was any doubt in my mind of the value and relevance of learning FORTH it has just been eradicated!

[Rikard Lang]

Den onsdagen den 12:e november 2014 kl. 17:37:16 UTC+1 skrev Julz:

Breaking News!

The ESA Philae lander has just landed on a comet, the first time that's ever been done! Amazingly, the Lander's CPU is a radiation-hardened RTX2010, a native FORTH CPU. http://en.wikipedia.org/wiki/RTX2010

                             
              

Parts of the Rosetta team did an AMA on Reddit yesterday. I asked about the CPUs and Forth, I think people here might be interested in the reply.

 

[Julian Skidmore]

Excellent! So the first NINE computers to land on a comet were powered by forth :-)

It really shows the confidence ESA have (or had) in the language. For me, the sheer determinism in forth is priceless: you know that every operation you execute will be done in the same way - the compiler won't reorder stuff left, right and center - it'll do what you say.

Most of the problems in compiler technology to my mind are due to false assumptions made by compiler writers in the semantics of source code.

The difficulty is that programmers both embed and overlook semantics in their/our code. A classic historical example is variable volatility; so in theory something like

While(x<5) x+=y;

Means that y could be aliased in a register, if y is in a memory location that can be modified then that assumption no longer holds true.

That was why C introduced the volatile keyword into the language. But related problems to these never really get solved, because there's always ambiguity between the theoretical semantics of a language and the machine model a programmer works to. The  information is literally missing from the source, and it can't be  unambiguously reconstructed - you'd need an infinite number of additional semantics in a language to cover the difference between what's stated & what's intended. It's a corollary of the incompleteness theorem.

Forth is different, because the compiler works to a machine model & the programmer specifies code imperatively. I.e. if you wanted the equivalent of caching y in the above example you'd have to explicitly do it:

Y @ x @ begin dup 5 < while over + repeat x !

Vs

Y x @ begin dup 5 < while over @ + repeat x !

Well I could go on, but for now i think it's enough to know that Forth is alive in space :-)

One day future space archeologists may land a probe on a comet fragment to test the theory modern computers originated from rocks in space (plentiful silicates and minerals there you see). They'll find a family of 9 CPUs all running the same language as theirs (obviously ;-) ). What more proof would they need :-) ?

-cheers julz

[Si Brindley]

Not just the first nine computer landings on a comet but also the second and third nine landings too :)

--

[Rikard Lang]

There were some speculation over at c.l.f that the CPU was chosen mostly for low power draw and rad hard. and while that surely played a huge role, the answer which shows that most of the CPUs were in fact coded in Forth (one instrument was done in C) tells me that they used Forth for a reason. Otherwise everything would have been written in C. Julz is on to something I think. It's something that is all around us these days. Machines with multiple layers of software, making it hard to understand and/or predict what a piece of code will really do. You are writing code for a compiler (which itself is black magic to most programmers) that takes the source and does stuff to it. This is why I like Forth, for good or bad, it does exactly what you tell it to do.