Bubble Tea: fun, functional and stateful way to build terminal apps

I'm actually kind of glad that X11 forwarding didn't stick. TUIs are generally efficiently navigatable using just the keyboard, a property I very much enjoy and frequently miss in "real GUI" apps.

Less modern systems have been running cross platform forever. Eg Free Pascal/lazarus.

TUI/GUI (qt,gtk,cocoa,...) & even has pas2js

Curses is screen reader compatible!

JAWS might have dumped all their TUI accessibility features now that they think blind users should only use the GUI, but BRLTTY is based around the console. Orca does assume Gnome and/or a web browser, but it's no worse than usual with a console. (That is to say - I hate Orca, no matter where I'm using it.)

If you're making your own TUIs, there's a few things that curses sneaks in to make things a nicer experience. It uses the start of heading, start of text, file/group/record/unit separators from the invisible portion at the start of the ASCII table, which your sighted users can't see, but things like BRLTTY announce.

(Note: I don't use BRLTTY with an actual Braille display. I use it with espeak.)

Tk is my goto for cross-platform desktop apps; it's unreasonably good for them. However non-desktop support was essentially nonexistent last time I checked.

Game engines (at least the lightweight ones) seem good for cross-platform graphical apps in general but the idea of redrawing a static GUI at 30 FPS just sounds too inefficient to me.

Just why? At that point just get a plain old framebuffer and plot individual pixels to it in serial code. How is it better to hack a use-case terminals were not meant to handle? They will have all the other complexities of GUIs still to solve, you just now has a hacky render path to worry about as well.

It's cool stuff but unfortunately I need icons.

Requires installing a web browser and having access to the computer’s renderer on some level

Qt is solid, no doubt. But it's rather high level and bloated. Plus the company appears to be actively be trying to pull away from open source.

I feel like I've seen TUI's from a completely different angle, including full use of modifier keys , full mouse support, etc.

Its amazing how one persons perspective can completely disagree with anothers.

What did you mean by the "OS task switcher becomes useless" ?

I'm only really interested in learning a language if it excites me, or if I'm getting paid to do it. I don't hate Go, and would be fine to learn it on company time for company projects, but there is no spark that would lead me to learn the language on my own. I've written some basic Go, but if I'm using it in personal projects, I'd would have to invest time to understand the ecosystem, runtime, standard lib, best practices, etc.

What exactly is hard to switch in/out of Rust, context-wise...?

I just can't get past the fact that Go doesn't have sum types. As someone who dabbles in category theory, it makes no sense to me that so many popular languages have product types but not their categorical dual. The lack of sum types leads to so many hacks and weird design patterns in the language, like returning two values when you only want the caller to read one of them (that is actually Go's error handling strategy!). To work around the limitations of not having sum types, Go has a "zero" value for every type so you can for example only set the fields relevant to your particular use case, and just hope that no one reads the fields you didn't set.

The problem is that sometimes the zero value is valid, but not special in any way and doesn't make sense as the default. Go has arbitrarily decided that one particular value is special without your blessing or the ability to override it. This leads to bugs in which the zero value shows up in places where you don't expect it, simply because there is some code which doesn't explicitly set it. That's a very easy mistake to make, which makes writing Go an error prone activity.

I shudder to think that there's probably some Go program that deals with money, and a user's balance might be cleared to zero simply because some operation forgot to explicitly set it in some struct.

In order to implement "optional" fields in Go where you want to distinguish between zero (a valid value) and none (a missing value), the common solution is to either put the integer behind a pointer (which can be null) or use some "sentinel" value like -1 to indicate that the value is missing (as long as that sentinel value isn't actually valid in the domain of discourse). These are terrible hacks, but exactly what you'd expect from programmers who spent the majority of their careers writing C.

This design also leads to another kind of issue: sometimes you don't want people to be able to construct values of a particular type without going through a constructor which ensures the relevant invariants hold. This concept ("smart constructors") is widely used in other programming languages, but it's impossible in Go because Go allows anyone to construct an inhabitant of any type simply by declaring a variable of that type.

A simple example of that kind of issue is pointers: in (safe) Rust, references are guaranteed to be non-null, and you use sum types to implement optionality. This is great because you can always dereference a reference and not worry about handling the null case. In Go, all pointer types have that nasty zero value (null), and there's nothing you can do about it. The billion dollar mistake.

I like the fact that Go encourages simplicity, and for the most part the language is fine. But I'm convinced that having every type be pointed rather than supporting proper sum types is actually more complex in terms of the implications it has on writing and reasoning about code. They have mistaken minimality for simplicity.

looks pretty and I think its pretty easy to use. Didn't look at what anyone else had done, tho.

Hey it’s our Internet friend!

>Will it copy the references anyway, meaning both structures now have a pointer to the same object?

Correct. A value copy is a simple shallow copy. Deep copy requires use of reflection (if you don't want to manually manage copying).

yes, that's what it does in go

Yes, but it doesn't actually matter. You can use pointers for models, return the same pointer, and it will re-render fine. We do this for our CLI at https://www.inngest.com for creating new serverless functions via a quick walkthrough.

It's actually the `tea.Msg` that causes re-renders. Here's the code: https://github.com/charmbracelet/bubbletea/blob/v0.20.0/tea.....

tea.Msg is, in Redux land, an "action" that triggers some state updates and _always_ triggers a re-render, even if nothing changes.

This is elm-like, but we have to understand the limitations of what we're working with: a terminal with no way of (nicely) updating elements in place. It's essentially an immediate-mode UI, and so it always paints.

You can use arrays, but if you want to maintain the Elm-like model of before and after states, then you need to explicitly copy the array into the new state rather than rely on Go copying just the pointer.

Some of the features that make Elm and Elm architecture work so well together:

- Light-weight lambda syntax

- Sum types and records

- Global type inference

- Exhaustive match expressions

- Powerful generics

- Immutability by default

- Partial application / currying

- Modules

- Ecosystem of packages built around pure functions

elm?

I'm having trouble thinking of a single example of a language, library, or piece of technology that is not either an acronym, a name of something that exists, or a combination of such names. Be it an object (Flask), a concept (Scheme), a letter (C), a person (Sinatra), or an animal (Python).

Maybe we need explicit namespacing in English? I'll start saying stuff like "programming languages colon colon ruby" so people can be absolutely sure what I'm talking about.

All Terrible.

I call it "Golang". I also _hate_ the use of 1 letter variables in Golang. Give me three and make it easy to search for symbol names in my no-frills editor.

/derail.

I myself just don't understand why any reasonable person would pick an existing common word for a project in 2022 instead of using the plethora of name generators that can give you something original without even trying.

But like, people that work for Google surely know something about search term collision. Or just don't care about making anything else that has "Go" in the query gets confusing results. Which is an odd stance for Google employees, but none of my business I guess.

Of course it's common anyway, I just don't see why you'd do this to yourself. You either bury your own project, or you are so successful with branding that no one can find what used to have that name. Google can push something hard enough with perfect SEO to make sure that Go the language shows up. A github page?

I mean, it's not Google but: https://duckduckgo.com/?t=ffab&q=go&ia=web First hit -- https://go.dev

https://duckduckgo.com/?t=ffab&q=bubble+tea&ia=places This project is not anywhere near the front page and I can't imagine it ever being. Too many different companies are selling boba tea.

I never really like it when companies use existing common words, but unless you're a huge project or a company that can push the SEO and marketing it's actively burying your work from anyone finding it.

I do.