Question: I know that our planetary probes often use planetary gravity to boost their speeds. That only works for prograde speeds, right? Because you're subtracting a miniscule amount of orbital speed from the planet and adding it to your spacecraft's speed. You couldn't whip around a planet and somehow use that to give you retrograde speeds, could you? (Presumably an airless planet, like Mercury.) Or what about using a large moon during the retrograde (relative to the planet's motion around the sun) part of its orbit?
Problem is another. To got additional speed from other body, you need to move very close to it and in perigee use some powerful acceleration to increase rotation speed fast, so could not use slow acceleration engines, like ion engines.
Idea of gravity-assist acceleration, mechanically is just rotation of pair tightly tied bodies (and cut tie in right moment, so one body got acceleration and other got deceleration), but as it is impractical to tie for example to Moon with rope, used gravity force.
What also interesting, gravity-assist could use not only orbital speed of large body, but also got some acceleration from rotation of large body, as for gravitation, large planet is not just one material point, but system of few smaller (sub)bodies, and closer (sub)bodies give more acceleration than others.
I’m not an expert on orbital mechanics, I just want to provide some data points.
The voyager craft, which not only had very good acceleration early on (the best we could do, really), combined with exceptional gravity slingshots and a lot of time - and are by all accounts some of the fastest man made objects ever - are going 15.4 km/s and 17 km/s relative to the sun.
3I/ATLAS is going so much faster than these objects they might as well be stationary.
Even ignoring the limited amount of time we have to intercept, catching up to 3I/ATLAS would be incredibly difficult to do. Perhaps impossible with our current technology*. Like catching up to a semi-truck going full speed on a highway with a bicycle. After it’s already passed us and is a couple miles down the road.
*barring theoretical (and kind of insane and dangerous) tech like Orion drives.
When you achieve speed in space, after acceleration, the speed won’t change forever unless you encounter some other force, like a celestial body gravity to change it. So if you achieve interestelar comet’s speed, you can shutdown the rocket and just travel at that speed for eternity like the comet does.
Even better: you can forget the comet, accelerate, keep accelerating until there is no more power or even a working motor while also extending a big sail to let solar wind accelerate you a little more.
> I think there's room for a `C+` language, by which I mean C+templates and not C+classes - perhaps with an ABI which is a subset of the C++ ABI but superset of the C ABI.
indeed, i have spoken to a lot of my colleagues about just that. if overloading is not allowed, perhaps there is still some hope for a backwards compatible abi ?
I don't think we can get away with just using the C ABI - or even if we did, we would need a standardized name-mangling scheme, and then any language which consumes the ABI would need to be aware of this name-mangling scheme, so it would effectively be a new ABI.
We might be able to make this ABI compatible with C if no templates are used, which wouldn't cause breaking changes - but for other compilers to be able to use templates they would need to opt-in to the new scheme. For that we'd probably want to augment libffi to include completely new functions for dealing with templates. Eg, we'd have an ffi_template_type, and an ffi_prep_template for which we supply its type arguments - then an ffi_prep_templated_cif for calls which use templates, and so forth. It would basically be a new API - but probably still more practical than trying to support the C++ ABI.
Another issue is that if we compile some library with templates and expose them in the ABI, we need some way to instantiate the template with new types which were not present when the library was compiled. There's no trivial solution to this. We'd really need to JIT-compile the templates.
If the templates are monomorphized, each instantiation of a templated function will have a different address. To acquire the address of any given instantiation we need a symbol in the object file.
Right. I had interpreted you asking that question as you having taken that position and soliciting responses for a discussion. Seems that was an improper reading.
Addendum: we have Buildroot and Yocto based platforms too. Not clear on the website right now but we have three platforms actually:
* GRiSP Metal - aka just GRiSP (Erlang/Elxiir + RTEMS)
* GRiSP Alloy - Buildroot Linux based, starts the Erlang/Elixir runtime as process 1 similar to Nerves but more language agnostic (Nerves is for Elixir only) and we support RT Linux and running multiple Erlang Runtimes at different priorities
* GRiSP Forge - Similar to alloy but Yocto based.
The idea is that from the high level language level they are more or less interchangeable.
still a draft though.
reply