HNHacker News
TopNewBestAskShowJobs

TFortunato

778 karma · joined January 23, 2011

I build robots.

Current: Staff Robotics Engineer at Chewy

Prior: Atlas @ Boston Dynamic; Robotics and Embedded Systems Engineering @ Amazon Robotics, Rethink Robotics, iRobot; Automation Engineering @ Ginkgo Bioworks.

Early Career: Electrical Engineer in Semiconductor Industry @ Applied Materials, Analog Devices, Allegro Microsystems

submissionscomments
TFortunato··on Re-Reading Tanenbaum’s Critique of RPC 30 Years Later
Tanenbaum's original critique, which is quite readable, for reference.

https://www.cs.vu.nl/~ast/Publications/Papers/euteco-1988.pd...

TFortunato··on Re-Reading Tanenbaum’s Critique of RPC 30 Years Later
FWIW, in Tanenbaum's original paper (which the author is reading), the correct meaning of the example is given quite plainly:

"consider a simple UNIX pipeline: sort <infile | uniq | wc -l >outfile that sorts infile, an ASCII file with one word per line, strips out the duplicates, and prints the word count on outfile."

So yes, it does seem the author did missed at least that part. Not sure about the rest of their arguments, but at this point, I'd say it's easy enough to find the original paper, which does seem quite readable.

https://www.cs.vu.nl/~ast/Publications/Papers/euteco-1988.pd...

TFortunato··on What =delete means
Yes, this part is super relevant to answer WHY it is written the way it is.

C++ has a lot of nice ideas under the hood, but the syntax and reading experience definitely isn't ideal because of the desire for backwards compatibility (which includes the very strong desire to not introduce new keywords / tokens if there is any possible way to avoid it)

TFortunato··on What =delete means
You're definitely not thick! This is getting a bit into the weeds of lower-level C++, but it is useful. So what delete is doing is explicitly saying that a given method (with a particular signature) is defined to not exist. It's usually used in cases where the compiler would automatically create a method for you, or use a method you wouldn't want to be used.

The example they give is the reference wrapper, which (as the name might suggest), is used to wrap a reference to some thing. To reiterate, with hopefully a bit more of what is going on.

If the creator of this method had just created a function:

template<class T> auto cref(const T&) -> std::reference_wrapper<const T>;

Then by C++ overloading rules, you could call this function with either an const ref LValue, or an RValue of type T. (In their example, they used a number). Which for 95% of functions is totally fine, and desired behavior! However, in this case, it would be bad, because remember, we are trying to wrap a reference to some value (e.g. basically a pointer under the hood), so a pointer to some ephemeral value is likely not what we want.

In order to solve this, the creator explicitly adds: template<class T> auto cref(const T&&) = delete;

Now, if the user calls cref on an RValue like a number, they will get a nice error message saying that the function has been explicitly deleted. The reason this works is because "const T&&" is the better match for the type of an RValue, compared to "const T&", so this is the overload that the compiler will try to use, rather than the original version above.

Some other reasons to use delete, is if you want to do stuff like explicitly forbid the use of copy constructors, because you have some object that you don't want copies made of for whatever reason. By explicitly deleting the copy constructor, you can be sure that no copies are accidentally made somewhere in user code (which is especially useful when your code interacts with other libraries you don't control)

I hope that made sense, but the TLDR is that there are a lot of ways construct objects, delete objects, to copy / move data around, etc. If you are doing low-level memory management / optimization, you may want to explicitly tell the compiler not to do the normal "helpful" stuff it does for you, such as creating default constructors / overloads, and this is the supported way of doing that in the standard.

TFortunato··on Coverage is not strongly correlated with test suite effectiveness
Nobody is arguing that usong a subset of tests won't catch all bugs.

They are stating that having X% code coverage does not imply that you will be able to catch X% of bugs (at least, of the trivial type they introduced here) so you shouldn't use code coverage as a proxy for how good your test suite is.

This may be obvious to you, but I've definitely seen teams fall into the trap of using code coverage as a primary measure of how good testing is.

TFortunato··on Intuit sabotages the Child Tax Credit
In this case, no, many of those in question are not required to file a tax return.
TFortunato··on Throwable military robots sent to assist with Florida condo collapse
These bots have moved through a few company splits / mergers / acquisitions, but for a while these were made by iRobot (along with the mentioned Packbot). When I was working there, these used to be a fun one to bring to schools we were giving talks at, because they could take a serious beating. Great way to get kids attention at the start of a talk by just lobbing one of these across the room / out into the hallway and let the kids try driving it.

Glad to see they are getting some use in helping people out!

TFortunato··on Regularization is all you need: simple neural nets can excel on tabular data
Not Excel: the spreadsheet software, Excel: the verb.

They aren't saying that they "canned" Excel (the software), they are saying that neural nets have the potential to perform well on tasks involving tabular data that are traditionally performed by other ML techniques.

TFortunato··on Internal Amazon documents shed light on how company pressures out office workers
Amazon does it in dollars. Employees have a target comp figure in dollars, the annual stock refreshers are based on the price of the stock at that time, so if you got 100 units one year, and the stock doubles, all things being equal, you would only get 50 units the next year at refresh time.

In practice this means you can make good money off your hiring grant if price keeps going up, but you will also see your total comp hit a cliff / drop after a few years, since while stock going up is usually good, in Amazon's eyes, you've been lucky to be making more than your target comp those years and they aren't going to keep giving you the same amount of units if those units are worth more.

TFortunato··on Internal Amazon documents shed light on how company pressures out office workers
On top of what other folks said, the warehouse folks not getting stock is a fairly recent development (2018, when minimum wage was raised). They do have a shockingly high turnover rate, but not sure if there is much that can be said about that relating to stock price currently, given how soon it's been since their stock comp went away, combined with the general strangeness of the Covid-19 pandemic

https://www.cnbc.com/2018/10/03/amazon-hourly-workers-lose-m...

TFortunato··on Internal Amazon documents shed light on how company pressures out office workers
I think they may be conflating Focus and PIP/Pivot, since they mention 35% w.r.t. focus later in the article.
TFortunato··on 2021.06.08 Certificate Lifetime Incident
They are stating that they would put 19A of load on a 15A rated socket. E.g. creating an obvious safety hazard that should be caught and addressed.
TFortunato··on QucsStudio – HF Circuit and EM Field Simulator
FWIW, the developer of QUCS Studio, is Michael Margraf, the original founder of the QUCS project
TFortunato··on Using io_uring to make a high-performance finger server
Is this because the finger protocol is defined such that it must use ASCII, and not UTF-8? (Honest question, have not used finger in a looooong time)

https://datatracker.ietf.org/doc/html/rfc1288#section-2.2

TFortunato··on In praise of --dry-run
Not quite the same, but apt commands like apt-get require user interaction to confirm what you are about to do, unless you explicitly add a "-y" / "--yes" to the command.
TFortunato··on Cerebras’ new monster AI chip adds 1.4T transistors
The article mentions that developers use standard PyTorch and Tensorflow.
TFortunato··on Nodes.io – A new way to create with code
Yakindu comes to mind as one (if you aren't allergic to eclipse :-) )

https://www.itemis.com/en/yakindu/state-machine/

TFortunato··on Ercot nearly at capacity for Texas power grid
The trick here is that with heat pumps, they aren't generating the heat, just moving it. As such, you can have, e.g. a 1 kW heat pump moving much more than 1 kW of heat. Wheras with a resistive heater, the best you can do is turn 1 kW of electric power into 1 kW of heat output.
TFortunato··on Super-expressive – Write regex in natural language
Something like this, perhaps? http://regex.inginf.units.it/
TFortunato··on The J1 Forth CPU
Seconding folks re: some of the advantages on latency, efficiency, etc.

I also wouldn't describe it as "just" a emulator, or to think of it as something interpreting / emulating some digital logic. It's much lower level than this, in that it is actually implementing your design in real hardware (consisting of lookup tables / logic gates / memory cells, etc. all "wired" together.

As such, they can be useful not only for implementing some custom bits of glue logic (e.g. interfaces which need high speed serialization / deserialization of data), or accelerating a particular calculation, but also for anywhere you need to have really deterministic performance in a way that isn't easy or even possible to do in software / an emulator alone.

TFortunato··on I Tried to Reduce Pylint Memory Usage
I wouldn't say they are less limited, so much as you are able to trade your money for resources a lot faster.. You can scale quickly, but at some point the monthly cloud bill come due, and code optimization starts to look a little more appealing :-)
TFortunato··on As Their Numbers Grow, Covid-19 “Long Haulers” Stump Experts
Did you read the article? They didn't say it was unique to Covid-19, and literally brought up long-term effects of SARS in some patients.
TFortunato··on Watch a Tesla Fail an Automatic Braking Test and Vaporize a Robot Pedestrian
"Sorry you lost a leg, but to be fair, you don't walk like the type of people in our training set"
TFortunato··on Face masks are breaking facial recognition algorithms, says new government study
In case you missed a few months back, looks like it is becoming a reality :-) https://news.ycombinator.com/item?id=23451530
TFortunato··on Functional Language Features: Iterators and Closures
Yes, I'm definitely not saying that std::visit is perfect by any stretch of the imagination
TFortunato··on Functional Language Features: Iterators and Closures
Take a look at my reply above. Your right it isn't built into the language, but it does come with a helper method, std::visit, which does take into account that you've accounted for all possible variant types, and will throw a compile error if you didn't. You also aren't stuck with if, else-if style syntax.
TFortunato··on Functional Language Features: Iterators and Closures
This works out really nicely when combined with variadic template tricks. (Taken from CPP Reference)

  // Helper for creating anonymous visitor functions
  template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
  template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

  using var_t = std::variant<int, long, double, std::string>;

  std::vector<var_t> vec = {10, 15l, 1.5, "hello"};

  // Type matching visitor
  for (auto& v: vec) {
        std::visit(overloaded {
            [](auto arg) { std::cout << arg << ' '; },
            [](double arg) { std::cout << std::fixed << arg << ' '; },
            [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; },
        }, v);
    }
Outputs: 10 15 1.500000 "hello"
TFortunato··on Bad Circuit Design
To paraphrase a joke I heard before, the only difference between an Analog Engineer and a Digital Engineer, is the analog engineer knows they are working on analog circuits.
TFortunato··on More Descent, Less Gradient
https://en.wikipedia.org/wiki/Coordinate_descent - Coordinate descent is another nice one that works well for certain problems.
TFortunato··on More Descent, Less Gradient
If you are interested in this kind of thing, there are a whole host of "derivative free" optimization methods out there. One I've seen used in particular at a previous job, the Nelder-Mead (downhill simplex) method, always struck me as pretty elegant and intuitive once you've seen it explained. https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method)
← PreviousPage 2 of 9Next →