Welcome to the droidymcdroidface-iest, Lemmyest (Lemmiest), test, bestest, phoniest, pluckiest, snarkiest, and spiciest Android community on Lemmy (Do not respond)! Here you can participate in amazing discussions and events relating to all things Android.
The rules for posting and commenting, besides the rules defined here for lemmy.world, are as follows:
1. All posts must be relevant to Android devices/operating system.
2. Posts cannot be illegal or NSFW material.
3. No spam, self promotion, or upvote farming. Sources engaging in these behavior will be added to the Blacklist.
4. Non-whitelisted bots will be banned.
5. Engage respectfully: Harassment, flamebaiting, bad faith engagement, or agenda posting will result in your posts being removed. Excessive violations will result in temporary or permanent ban, depending on severity.
6. Memes are not allowed to be posts, but are allowed in the comments.
7. Posts from clickbait sources are heavily discouraged. Please de-clickbait titles if it needs to be submitted.
8. Submission statements of any length composed of your own thoughts inside the post text field are mandatory for any microblog posts, and are optional but recommended for article/image/video posts.
Community Resources:
We are Android girls*,
In our Lemmy.world.
The back is plastic,
It's fantastic.
*Well, not just girls: people of all gender identities are welcomed here.
Our Partner Communities:
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.
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.
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.
You and op need to start a support group for addicts
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.
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.
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?
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.
I've spent a significant amount of work time for a few years working with Powershell. There's a hell of a lot it does right, and it's set up such that the grand majority of commands and modules follow the same syntax in terms of pattern and terms. It's not hard to just pick up and go with new stuff within it. That is it's biggest strength, and it makes Windows SysAdmin work a hell of a lot smoother.
That said, there's a shit ton of little idiosyncracies that would catch me every time if I wasn't using VSCode/ium with Intellisense suggestions.
Specifying the properties to return from Get-ADUser? Use -Properties. Specifying the properties to return through Select-Object? Use -Property.
Working with Exchange Online? Import the module. Confused that the commands you need don't exist after you imported it? You have to use the Connect-ExchangeOnline command to authenticate, connect, and generate and load a new temporary module first with just the commands for shit the account you used to authenticate has access to. This is the only module I've found that does this.
Need to send an email using your script? I sure hope you like using third party modules or loading dlls to do .Net/C# shit through PowerShell, because if you use the built in Send-MailMessage function we'll give you a warning that it's insecure, with a link to more info that's just a wiki page on github for .Net, not PowerShell, without any actual info that notes this has been an issue for six fucking years! The warning even states that there is no built in alternative in PowerShell despite it being insecure.
Don't even get me started with the absolute clusterfuck of the multitude of modules for working with Azure, half of them deprecated without equivalent functionality existing in the replacement. The latest and greatest one doesn't even has documentation pages with shit like "NOTE: FILL THIS INFO IN LATER" in them.
Like ffs, am I using a professional product developed by one of the largest corps in the world, or someone's open source project? It often feels like you get the worst of both worlds.
Don't get me wrong, I love PowerShell, it's an amazing tool for Windows environment sysadmin work. I just often find people's attitudes about it to be either "it's a neat toy" or "it's the most amazing tool on Windows ever" when the reality is between.
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).