In the desktop world, we have the option to use the command line: a uniform interface for a multitude of apps that would otherwise be very different when implemented as GUIs.
Using the same interface, I can move or edit files, cross out tasks on my to-do list, retrieve my password for my email account (using Bitwarden or pass), etc. All in the command line. The GUI for each of those are wildly different.
The other benefit is it is very easy to create a new command line app, as opposed to a GUI.
Is anything like this possible for the smartphone world (even if it doesn’t or will never exist)? What would it look like?
Since smartphone typing is much slower, we can’t simply reuse the command line. We’d need something different. An interface that can still support a various spectrum of different operations, yet ergonomic for a smartphone. What are your thoughts?
Termux is awesome, but it is not what I’m looking for. Using Termux lacks the ergonomics of using a terminal on desktop. The keyboard / typing experience is far worse.
How would your ideal solution overcome not having a full-sized keyboard in your pocket?
By not relying on typing speed. Maybe the interface could heavily leverage gestures for example, or auto complete, etc. There are many possibilities.
But also this kind of is the core of my question 😄
The last paragraph in your post should have been the only paragraph in your post. People aren’t getting as far as your last paragraph before they give up and make a comment about command lines on Android.
You didn’t need to spend 4 paragraphs telling everyone things they already know. You should have gotten right to the point.
You’re right, thanks for pointing that out. It does seem that almost no one read to the end, and that’s on me.
That has nothing to do with the terminal. Get Hacker’s Keyboard or use a physical keyboard if you want a regular keyboard layout.
As long as the keyboard is constrained by your screen size, the ergonomics in typing speed and error rate are far worse than desktop terminal. If the keyboard is not constrained by screen size, like a sufficiently large physical keyboard, by definition that is no longer a smartphone or mobile phone experience.
I think the most confusing part is that you want both the backend and gui to exist, yet don’t like the current back end.
Realistically you could create some super weird controller using all your sensors at once and just wrap it around termux/adb.
Things like termux’ first goal is to work both programmatically and via a user, a wheel that would be pretty difficult to recreate just for phones
@matcha_addict the keyboard experience is quite literally just your device’s keyboard
Maybe you wanna try Unexpected Keyboard?
https://f-droid.org/packages/juloo.keyboard2/Nice recommendation! I tried it and it’s probably the first keyboard I actually like.
This + dvorak layout is amazing
The keyboard experience is limited by the small size
I have not tried the keyboard you linked. Does it solve this issue?
@matcha_addict you can make it however big or small you want 🤷
Edit: sounds like you meant software keyboard. That is constrained by screen size and hence cannot be as big as I want.
Below is my original comment which assumed you meant a physical keyboard of sufficient size.
If you’re carrying around a big keyboard with your phone, you’ve officially exited mobile phone territory.
Mobile phone is hand-held and pocket sized by definition.
It’s a software keyboard…
Then you’re constrained by the screen size, so it’s incorrect that you can make it as big as you want.
I really don’t think that the command line is a uniform interface. Every command has its own syntax, its own take on what its switches mean, its own take on regexes/globs and so on. Moving and editing files is something completely different: one is a simple command to move a file elsewhere, the other is a whole experience which replaces the command line with something that looks completely different and is controlled completely differently. What they do have in common is just the medium - the terminal.
Many developers of command line tools try to at least keep a similar design language as the rest of the world, but it is far from perfect. A lot of these interfaces are like they are for mostly historical reasons without proper planning of the user interface, so imho even something like Material Design is already closer to being the “same interface” in the GUI world than the various command line interfaces are.
we can’t simply reuse the command line
We absolutely can and some of us do. I often manage my files, todo list, etc. in Termux. Its not always the best thing to do, but I like that I can keep a consistent interface no matter what device I am using. Its still the same terminal, just on a smaller screen with a worse keyboard.
I really don’t think that the command line is a uniform interface. Every command has its own syntax, its own take on what its switches mean, its own take on regexes/globs and so on.
Powershell was kind of an answer to that. All commands are supposed to emit objects and take objects as input. For me though it is horribly unintuitive. Id love to see an open source attempt at it, but it would be hard since by necessity every dev works on their own tool, while Microsoft could enforce something because they own all the tools.
Well, the fact they emit objects doesn’t really help that much with the user interface. This just means that the standard input and output of commands is (usually) more unified and parse-able. I really like the idea, and have seen multiple attempts at it including PowerShell, however none have reached the level of usability that the good old *NIX shells provide.
Id love to see an open source attempt at it
It seems the difference stems from *Nix treating everything like a file (or stream) from day 1, while windows was built from DEC Alpha, which had a completely different approach.
(In the early 90’s a group of DEC Alpha engineers were laid off, and Microsoft hired them. Technet magazine had an article (written by Mark Minasi I think), showing how clearly NT reflects the structure of Alpha. They may have been working on NT before that, but the influence of DEC was pretty clear).
Every command has its own syntax
I don’t consider this a different interface. Where you draw the line is a personal choice, but I’d be happy with a smartphone equivalent where the differences are similar to command line tools having different syntax.
editing files is something completely different
I should have clarified, but by editing files, I don’t mean the vim-like full text editor experience. I mean things like appending text to a file with echo
>, or using sed, etc.A lot of these interfaces are like they are for mostly historical reasons
Yes, legacy baggage exists. This only furthers my point, that things could be even better using the same principles, without legacy baggage.
Termux
I only use Termux out of necessity (app or functionality I can only access via a terminal). If an app with good ergonomics exists, I wouldn’t look at Termux. But I would still look at command line on desktop.
I’d be happy with a smartphone equivalent where the differences are similar to command line tools having different syntax.
My point was that I think we have that already. The medium is a touch screen, and apps have over time adapted to that the same way they have to the terminal. Here we scroll by swiping up and down, move between tabs by swiping to the side, etc. All held together by system-wide gesture navigation. And yea, every app does stuff differently, and so does every terminal one.
This only furthers my point, that things could be even better using the same principles, without legacy baggage.
I feel like this is exactly what Google was attempting to do with Material Design: a good, consistent interface / design language. It really was a fairly fresh start using what we learned from the smartphone apps that came before, with the design done intentionally. What do you think they missed?
Another thing to keep in mind is that the terminal is built around text and files, while the GUI is not. You cant expect every problem to be cleanly / ergonomically solve-able inside an Android app, just like you cant expect a good Snapchat / Instagram client in your terminal. There are file manager apps, there are text editors, there are todo lists, but the terminal is just a better platform for some tasks while worse for others.
The medium is a touch screen
That’s more like a GUI than a CLI. You have input boxes, buttons, sliders, gestures, scrolling, drag and drop, etc, and their different combinations. Many apps do almost the same thing, except giving you a different interface and a different combination of these steps. You listed some of those variations yourself.
How is that the same as the uniformity of the text only interface? That’s far more different than differences in syntax, but still text. Two hyphens instead of one hyphen for a CLI flag is a really small difference.
Even as a heavy user of CLIs, claiming that their text-only nature somehow makes them more uniform, feels a bit overly reductive to me:
To start with, there’s simple fire-and-return commands, interactive commands, full-blown TUIs and so on. Then there’s the parameters, which aren’t really consistent either across applications either. Neither in the naming of arguments, nor their grammar. The representation of the output is also all over the place.
With all those things, it’s really not so dissimilar from the different layouts of GUIs. Not to mention that there’s also lots of CLI tools that do the same thing but have a different interface, so yeah.
I’m excluding TUI’s because you’re right, they’re pretty different and share some of the ununiformity of GUIs. Still, the command line world remains vast and with that interface you can do a lot, and it is fairly uniform.
there’s parameters
That doesn’t change the uniformity of the interface. Of course every application will need different parameters. Now do they receive these different parameters via a similar and uniform interface? I say yes. I enter it via keyboard, and for the most part they all use space delimited flags, most of them hyphenated. I’d call that pretty uniform.
To phrase it another way, if all GUIs started using the same names for all parameters, it remains non-uniform interface, and it wouldn’t solve 1% of the issue with GUIs.
Out of curiosity, if you don’t see the CLI world as more uniform, why do you use it and for what benefit do you prefer it?
I use the CLI because it’s keyboard-focused (though I use lots of mouse-enabled TUIs) and because it’s programmable.
Generally though, I kind of get what you’re trying to say, but ‘uniformity’ feels like an unfortunate choice in the context of your question, as the meaning can be very arbitrarily defined, hence the confusion. I could, for example, claim that GUIs are more uniform because all chat apps, browsers etc… are so similar to each other that once I’ve learned one I can use all.
Which is why It’d probably be better if you tried to reword your initial question avoiding that term, focussing more on describing the desired benefits of your definition of uniformity.
Otherwise I’d point towards voice recognition, as that’s very similar to a CLI, but probably not what you had in mind, I’m guessing?
Great examples are already in the thread, but generally speaking the answer should be “no”. Smart phones are just slow at typing. In the case of a smart phone, hitting a button is far faster than typing a command. Not to mention our devices aren’t really being used for file management, tooling, complex work, etc. So it doesn’t even make sense to have a command line unless you’re a huge unix fan or if you are doing something quite niche. And in that case, I recommend just connecting via adb.
While I agree with you, I do find myself doing a lot of file management via my phone, as much of a PITA as it is.
I do perhaps 1/4 of my file management there. PC is just far easier.
Despite the smartphone touch interface being worse for these tasks, the convenience of having a phone always with you and within a couple seconds of reach is a big benefit. It would be really nice if the interface could be made easier
It may not have to be typing-centric. Maybe the answer is in interfaces that leverage gestures better and in a uniform way, or mixing it with a clever use of buttons.
our devices aren’t really being used for file management, tooling, complex work
Only because the experience of doing so is not pleasant like it is on desktop. People would use it for that otherwise.
doesn’t even make sense to have a command line
I don’t want to have a command line, and I emphasized that in my post. Only something that is similar in its ergonomic enhancement.
I see. Well without a command line, I wouldn’t call it a terminal. I think you just want tooling to be available on an Android? It would probably look like a button or series of buttons on an app. Maybe you could connect the dots between them to insinuate a pipe? E.g., you have a “mv” button and a “file” button. When you drag from mv -> file you could maybe kick off a process that moves the file. Maybe it would prompt you for other arguments like destination? I suppose this theoretical app could allow people to install additional tooling and make their own custom commands.
But I just feel like a button UI for these kinds of things will always be awkward. If you don’t have a keyboard/terminal interface, it’s hard to implement anything that would even behave like terminals in terms of functionality.
You and op need to start a support group for addicts
Recovery mode. ADB. There isn’t an interface provided for it directly on the phone, but Android phones do have command line commands.
SXMO?
I think closest to your idea is speech recognition and an AI assistant. You can give it commands that way.
I don’t think there’s much that includes fat fingers and touchscreens and is possible without a graphical UI.
You could buy an old Nokia from the 90s with lots of text menus. That won’t speed things up but it’s certainly less icons, more text and as a bonus you can feel the physical buttons without looking at the phone.
Or a Blackberry with a qwerty-keabord on it. Or use convergence and attach a proper keyboard via USB and install Termux.
Theoretically you could have it project a “holographic” keyboard onto the desk in front of you. Or use VR glasses.
Or hold it sideways and type with 8 fingers simultaneously alike on a stenotype keyboard.
That’d be ways to improve on the keyboard / input method and allow you to use the CLI in it’s current form. I mean the CLI itself is already available. It’s just cumbersome to use it. I’d say a speech assistant is more it, if you want an entirely different concept and not just a better keyboard and/or larger screen.
My confusion with this post is that it already exists? It’s just your home screen on your phone.
Ergonomic, supports a variety of functions (adjusting settings, running applications, customization, viewing device info), is loosely standardized (much like terminals across OSs), and widely adopted.
The only difference is touch interface vs. Text interface.
Like what are you actually looking for? A gesture controlled terminal or an interface? You already have the latter.
