I find that much of the time I want WolframAlpha for when basic arithmetic, because I like the way it tracks and converts units. It's such a simple way to check that my calculation isn't completely off base. If I forget to square something or I multiply when I meant to divide I get an obviously wrong answer.

Plus of course not having to do even more arithmetic when one site gives me kilograms and another gives me ounces.

qalc also tracks and converts units, and is open source (practical benefit: runs offline). I have it on Android via a Debian subsystem but just checked and Termux simply has it also (pkg install qalc)

Random example off the top of my head to show off some features: say it takes 5 minutes to get to space, and I heard you come around every 90 minutes, but there's differing definitions on whether space is 80 or 100 km above the surface, then if you're curious about the G forces during launch:

    (2*pi*(6350+ 90±10)km / 90 minutes) / 5 minutes to gees
    
    ((2 × pi × ((6350 + 90±10) kilometers)) / (90 minutes)) / (5 minutes) ≈
      2.5470±0.0040 gees

(the output has color coding for units, constants, numbers, and operators)

It understands unicode plusminus for uncertainty tracking, units, function calls like log(n,base), find factors, it will do currencies too if you let it download a table from the internet... I love this software package. (No affiliation, just a happy user who discovered this way too late in life)

It's not as clever as WolframAlpha, no natural language parsing or Pokédex functions (sometimes I do wish that it knew things like Earth radii), but it also runs anywhere and never tells you the computation took too long and so was cancelled

Edit: I just learned there's now also an Android app! https://github.com/jherkenhoff/qalculate-android | https://f-droid.org/packages/com.jherkenhoff.qalculate/ I've checked before and there wasn't back then, so this is cool. This version says it supports graph plotting which the command-line version doesn't do

Qalculate! has been my go-to calculator on my laptop for years, very happy to have it on my phone now too! And it definitely knows planet radii, try `planet("earth"; "radius")`. Specifically, it knows a bunch of attributes about atoms (most importantly to me, their atomic mass) and planets (including niche things like mean surface temperature). You can see all the data here: https://qalculate.github.io/manual/qalculate-definitions-fun...

Woot! I need to read the docs better! Thanks for sharing that :D

If you're willing to learn to work with RPN calculators (which I think is a good idea), I can recommend RealCalc for Android. It has an RPN mode that is very economic in keypresses and it's clear the developers understand how touchscreens work and how that ties into the kind of work pocket calculators are useful for.

My only gripe with it is that it doesn't solve compounding return equations, but for that one can use an emulated HP-12c.

RealCalc Plus is great on the Android side. If using iPhone/iPad/macOS, try BVCalc. Its RPN mode shows you the algebraic expression (i.e., using infix notation display) for each item on the stack, which both helps you check for entry mistakes and also more easily keep track of what each stack item represents. I haven't found another RPN calculator that can do this.

On Android, I just went straight to using an emulator of the HP42S that got me through engineering school in the early 90s. The muscle memory for the basics was still there, even if I can't remember how to use the advanced functions any more.

I still have my actual HP, but it seems to chew batteries now.

Proper ones are certainly usable for more than napkin math. I deal with fairly simple definite integrals and linear algebra occasionally. It's easier for me to plug this into a programmable calculator than it is to scratch in the dirt on Maxima or Mathematica most of the time if I just need an answer.

This relates to what I wrote in reply to the original tweet thread.

Performing arithmetic on arbitrarily complex mathematical functions is an interesting area of research but not useful to 99% of calculator users. People who want that functionality with use Wolfram Alpha/Mathematica, Matlab, some software library, or similar.

Most people using calculators are probably using them for budgeting, tax returns, DIY projects ("how much paint do I need?", etc), homework, calorie tracking, etc.

If I was building a calculator app -- especially if I had the resources of Google -- I would start with trying to get inside the mind of the average calculator user and figuring out their actual problems. E.g., perhaps most people just use standard 'napkin math', but struggle a bit with multi-step calculations.

> But for some reason the authors of calculator apps never optimize them for the number of keypresses, unlike Casio/TI/HP. It's a lost art. Even a simple operator repetition is a completely alien concept for new apps.

Yes, there's probably a lot of low-hanging fruit here.

The Android calculator story sounded like many products that came out of Google -- brilliant technical work, but some sort of weird disconnect with the needs of actual users.

(It's not like the researchers ignored users -- they did discuss UI needs in the paper. But everything was distant and theoretical -- at no point did I see any mention of the actual workflow of calculator users, the problems they solve, or the particular UI snags they struggle with.)

I'm the developer of an Android calculator, called Algeo [1] and I wonder which part of it that makes it feel like slow/not snappy? I'm trying to constantly improve it, though UX is a hard problem.

[1] - https://play.google.com/store/apps/details?id=com.algeo.alge...

This seems to be an expression mode calculator. It simply calculates the result of an expression, which makes it like the other 999 calculators in the Play Store.

Classic algebraic calculators are able to to things like:

    57 x = (displays the result of 57x57)

    3 = (repeats the multiplication and displays 57x3)

    [+/-] MS (inverts the result and stores it in the memory without resetting the previous operation)

    7 = (repeats the multiplication for 7 and displays 57x7)

    7 [1/x] = (repeats the multiplication for 1/7, displays 57/7)

It doesn't have to be basic arithmetic, this way you can do complex numbers, trigonometry, stats, financial calculations, integrals, ODEs etc. Just have a way to juggle operands and inverse operators, and some quick registers/variables one keypress away (see the classic MS/MR mechanism or the stack in RPN). RPN calculators can often be more efficient, although at the cost of some entry barrier.

That's what you do with the classic calculators. Often, you are not even directly calculating things, you're augmenting your intuition and offloading a part of the problem to quickly explore its space in a few keypresses (what if?..), give a guesstimate, and do some sanity checks on whether you're in the right ballpark, all at the same time. Graphing, dimensional analysis in physics, error propagation help a lot in detecting bullshit in your estimates as quickly as possible. If you're also familiar with numerical methods, you can do miracles at the speed of thought. Slide rules were a lot like that as well.

People who do this might not be your target audience, though.