1,354 karma · joined June 16, 2016
Alabama, Alaska, Arizona, Arkansas, Colorado, District of Columbia, Georgia, Hawaii, Idaho, Indiana, Iowa, Kansas, Kentucky, Louisiana, Maine, Michigan, Minnesota, Mississippi, Missouri, Montana*, Nebraska, New Jersey, New Mexico, New York, North Carolina, North Dakota, Ohio, Oklahoma, Oregon, Rhode Island, South Carolina, South Dakota, Tennessee, Texas, Utah, Virginia, West Virginia, Wisconsin, Wyoming
[1] https://recordinglaw.com/united-states-recording-laws/one-pa...
Spin Volt = 0.1 newtons
Spin Coulomb = 10 meters of chain
Spin Ampere = 10 meters of chain per second
Spin Ohm = 0.1 newton-seconds per meter
Spin Farad = 100 meters per newton
Spin Henry = 0.01 newton-second-seconds per meter
Spin Watt = 1 newton-meter per second
> mbed TLS supports SSLv3 up to TLSv1.2
> I don't see that anywhere.
I didn't find it on the website, but I did find it on the GitHub:
If launches are cheap, then refueling in LEO makes a lot of sense. Historically, this has not been the case at all, but it's all part of SpaceX's model for Starship.
My favorite online presentation of his music is the collaborative video made by Adult Swim for the song "When I was Done Dying".
Here's a picture he posted of his gear:
https://twitter.com/ebaynetflix/status/442078506655023104/ph...
In his NPR Music Tiny Desk Concert, you can see an OP-1 on the near-right of his table.
https://www.youtube.com/watch?v=heFRwLfjVXI
edit: I found a website which catalogs musicians and the equipment they use. It lists 190 users of the OP-1.
https://equipboard.com/items/teenage-engineering-op-1-portab...
[1] https://docs.xfce.org/xfce/thunar/bulk-renamer/start
As far as planned missions go, a proposal by the Goddard Space Flight Center for a 2021 Venus atmospheric probe called DAVINCI+ was shortlisted in February 2020 [1], but was waylaid in favor of asteroid probes Lucy and Psyche[2].
[0] https://www.nasa.gov/feature/jpl/nasas-venus-rover-challenge...
[1] https://www.nasa.gov/feature/goddard/2020/nasa-goddard-team-...
https://spaceflightnow.com/2020/04/20/nasa-narrows-design-fo...
Edit: to your other points, I've thought of some justifications for this architecture:
* The sample return mission will have very limited payload capacity, so the samples should be chosen on the basis of potential scientific value, and selected from a large land area. This can probably best be done with a multi-year rover mission equipped with the best scientific instruments and locomotion available.
* Perseverance's scientific instruments are useful for studying rocks that won't be sampled, so spending weeks or months ferrying samples to a return vehicle would be a sub-optimal use of its very valuable time.
* Mechanically interfacing (to transfer samples) with an orbital solid-fuel rocket is probably somewhat dangerous, so it's best for Perseverance if there's a less-valuable robot to do that.
* The return vehicle will probably be limited in where it can land, because it will have to land on ground that is suitable to launch from. It is unlikely to be landed anywhere close to a bunch of interesting rocks and formations.
* Science instruments, and the manipulators to use them, are heavy, power-hungry, and fragile. If the sample-collection rover doesn't have any, then it can be better-specialized for the task: faster, less fragile, able to traverse softer or more rugged ground. Traveling many tens of kilometers to collect samples may not be nearly as difficult for it as for any previous, science-burdened rover.
This is basically how concatenative stack-based languages do it, although by convention they put the arguments before the function call. (Reverse Polish Notation) In Forth, your example would be written one of the following two ways, depending on whether multiply() or sum() is consuming the extra 2:
2 2 2 * 2 + +
> 8
2 2 2 * * 2 +
> 10
Also valid would be:
2 2 2 * 2 +
> 2 6
where the left-most 2 is not consumed, but rather is left in place.
> This work is placed in the public domain.
> In regions where this is not possible, the author grants unlimited license to this work.
Unfortunately, the CC0 explicitly does not waive patent rights, the Unlicense doesn't mention patents at all, the Blue Oak Model License and Apache 2.0 don't attempt to place the work into the public domain, and 0BSD and MIT-0 neither address patents nor attempt to place the work into the public domain. None of these licenses aggressively waive all of the author's rights to their work; I wonder why there isn't a strong public-domain no-patents-or-anything-else license ?
iCE40 FPGAs come with up to 7,680 logic cells.
The J1 was designed for a board with a Xilinx XC3S1000, which has 17,280 logic cells.
First, realizing that you can have separate instances of functions at the same time -- different stack frames. Making the mental leap from "the content of x in function f" to "the content of x in f(0), and also the content of x in f(1)" is a leap of abstraction, but not necessarily a tremendous one.
Second, mentally modeling recursion when it gets complicated. Simple recursive cases are easy to model in your head, because either there is little state to keep track of, or because you can extrapolate the pattern between function calls, mentally compressing the state of the whole call tree.
Tail-call optimization, for example, is really easy to mentally model because you only have to keep track of the state of one function's variables at a time -- unless you start passing continuations or thunks into your function calls, in which case you're carrying a stack of unlimited complexity into each function call. It's still just a function call, with the same number and types of arguments, but now one or more of those arguments contains turing-complete, recursive programs of unlimited complexity.
This similar to the worst-case mentally-complicated recursion without TCO, where you can build a complex graph of function calls, scopes, shared data accesses, and mutated copies of what used to be the same data, that can all be present at once, and where you might need to keep track of all of them in order to track down and understand something that you need to understand.
You can, of course, build similarly tangled-up structures in a purely-iterative manner, but the upside is that the complexity will be confined to the data state -- there will be no call tree to mentally model, and no need to track variable scope.
---
Shorter version: if the efficiency and elegance of recursion (with appropriate compiler/runtime optimizations, like TCO) is like zip compression for your mental model of code complexity, then there exist recursive-program equivalents of zip bombs.
---
Even shorter version: recursion itself isn't hard to reason about, but recursive programs can be very hard to reason about
In 2020, in the same city, I voted by marking a paper ballot and inserting it into a machine which scanned it and output it into a sealed box.