If oauth makes an authenticity claim, it should be true. Saying it's the same user when it's not is bad, clearly.
in other words: Google could make a more accurate authenticity claim than they currently do.
This problem would be worse without oauth, though, right? With plain email login, all they would need to do is "forgot password" and there wouldn't even be a way to tell.
in other words: Email login would never be able to make a more accurate authenticity claim.
> Failed startups don’t always shut down cleanly like that.
Agreed, and with the number of services and the "ease" of oauth it's likely impossible to even track. You could make a list of the major ones, but there could be hundreds per user, ultimately thousands of unique services used depending on the breadth of the startup's activities.
I think it's more like there's more surface area to forget when you have humans handling so many concerns, and it's not likely the part that's changed the most so it's a likely candidate for being "pushed out of the buffer" (of the human).
In a more typical model, backend devs focus more on security, while not needing to know the frontend, and vice versa.
It seems like that's the point of the story -- they were willing to tip well, and received bad service. If it came after, then drivers would have a reason to make sure food was delivered fast and efficiently.
Yeah, the way it's setup, with the delivery company on board with stacking deliveries, and no guarantee of good service despite a good tip, there's no incentive to tip at all.
The ligatures are really interesting, but at a glance I process them so much slower than the raw characters, especially the ones that change the graphical semantics such as <= vs ≤. Does anyone have experience getting used to these and 1) does it end up faster? 2) once you are used to it is it harder than it was before to process the raw characters when reading code in fonts that don't have the same ligatures?
For me it's not a matter of speed, but distinctness and fitness to the meaning.
A ligature happening is kind of a "syntax affordance" saying that the code is correct, and it indeed says "!=" and not "! =". It kind of helps my brain elevate the code from "sequences of characters" to "serialised syntax tree".
The fact that the "not equals" operator is the exclamation mark followed by an equals sign is purely an artefact of the practicality of keyboard input. Ligatures are a simple way of stepping away from the raw text and into the meaning of things, just like syntax highlighting helps transform "words" into "tokens" on our brains, or rainbow parens help us visualise the hierarchy of the language in question.
(Though I find rainbow parens a bit too colorful and distracting, so I don't use them in practice, I like the idea behind them)
It is the same idea that proponents of visual coding advocate for, but text as a medium is much better because of how compact we are able to make it without feeling cramped.
Which leads me to another tangent, which is that there is a very clear split between programmers that "manipulate text" and programmers that "manipulate structure".
It can be seen in the choice of tooling, some people really go ham with multi-cursor editing, find-and-replace patterns, "select next word", editor macros, and other text manipulation based tools. While others (myself included) prefer a more content-aware tool like JetBrains' "rename field", "extract method", "widen selection" (select AST parent's text span), etc.
Which is not to say that either group is more correct or efficient, it's just a pattern I see on people.
As someone in the second group the IDE is basically just doing the first thing efficiently for you when you do the second thing. Not a good or bad thing but I do think that that’s interesting to note
I'm in the first group (these are text files first and foremost) and I think that's a really interesting observation. Do you have any thoughts on what the consequences might be?
Can only speak of experience writing code for both groups and seeing them work, don't take any of the info below as statistical truth.
As I said before, it certainly affects the choice of tooling, and therefore this property of programmers often places them in either side of the eternal "IDE vs text editor" wars. Which is distinct from the GUI vs TUI wars, but in practice most IDEs are somehow graphical. Structure-ers generally prefer tools to be thorough even if they're slow, while Text-ers prefers tools to be as fast as possible so they can be thorough themselves.
I don't think there is really that much of a difference in code style, the general pains of weirdly styled code are often universal regardless of how you look at it. (Text-ers might dislike identifiers with multiple words because it takes longer to navigate through, while Structure-ers might dislike having complicated expressions for the same reason.)
I guess the main impact I see is from pair programming, it is supremely distracting to watch someone with a different mental model of the code do things in what appears to be this "inefficient" way.
As someone who manipulates structure, the refactoring tools and the like, as well as the formatting IntelliJ does for you, make my programming less portable between editors. Text-driven development is very portable, but I actively dislike using VSCode in comparison to IntelliJ because it refactors and formats code in different ways.
I have nothing to add, just wanted to say I think this is the best-written explanation I’ve come across for why I like both ligatures and good syntax highlighting.
It took me a bit to warm up to them, but now I find myself relying on them to more quickly spot errors, so yes it ends up faster. Somewhat counterintuitively, I find the ligature characters easier to process at a glance and see if there's a problem or not (I suspect its something along the lines of my brain looks at "<=" as two separate characters, one after the other, and has to process each in serial then combine them into the concept of "less than or equal to", whereas the ≤ is a single character that goes straight to the "less than or equal to" concept in the same way its easier to remember the number "six hundred ninety-three" than "six, nine, three". I also find it way easier to spot the "≡" vs the "===" in JS land, which surprised me but here I am.
I wouldn't say its harder to go back, but it does make me do a double take. Overall I would say the effect is quite minor and I'm just fine without the ligatures, but given the option I would enable / prefer them.
Ligatures became one of my favourite features after trying out Fira Code. It felt like an obvious improvement that I was yearning for, for years.
I guess my brain likes having distinct continuous symbols to represent different operations - it reminds of of math in school & university. And I don't see a problem during editing, knowing they're made of multiple symbols.
And yes - I feel that I do struggle much more without them.
Completely out-of-the-blue, unproven guess - my mind is used to learning new symbols quick, from all the gaming I've done. And it's much easier to learn a new symbol that's cohesive, continuous & unique, rather than having to read disjoint characters and figure out a different meaning for them.
I find ligatures more interesting for the slightly more "exotic" syntaxes like arrows → instead of ->, ⇒ instead of =>, etc. Most of them are incredibly similar to their non-ligature counterparts, and even ones like != don't seem to cause much trouble.
I don't seem to have any trouble switching between ligatures in the IDE and no ligatures on github. I haven't really had to think of them.
I initially hated ligatures. Decided to give them a try with JetBrains Mono.
Now when they are turned off I feel like something is missing, and scramble to turn then on again. For whatever reason my brain feels more comfortable with them.
Coming from a math background and using latex a lot, ligatures were really godsend for me. Without ligatures code looks unnatural but it's just an aesthetic thing in the end and I don't mind either way
I also can’t use ligatures. In my head it’s two symbols and to see it as only one just complicates it. But I also feel like if you had a language and it just supported a Unicode symbol then I’d be fine with it. I think it has to do with the fact that I know / sense the facade and it causes me to always resolve it to its two character canonical form.
if you see the <= "less than or equal to" ligature and hit backspace once it will become <. it's very intuitive. this is how emoji operate to combine a face with a skin tone - it is two characters merged into one.
dunno why so many people see ligatures and clutch their pearls like it is some kind of rock and roll devil symbol.
I think people don't like it because it's not intuitive. When I hit backspace next to a character, I expect the character to be deleted, not for it to shapeshift into another character. I see how ligatures can be nice for some people, but it's definitely not as intuitive as showing the actual characters in place.
Also if I type two characters, I expect to see two characters - and not a single character that is somehow not aligned with every other character's columns. And because it is not aligned, the space left and right seems to be off. Everything about monospace ligatures feels unintuitive to me.
I tried to get used to them, but eventually gave up when I found that I was getting ligatures for parts of runs of symbols when they weren't actually appropriate. I think it was `|` and `>` placed next to each other that pushed me over the edge.
i don't think of it as faster or slower to read, it's just more aesthetically pleasing to me. i use cascadia code in vscode with ligatures enabled, it's really nice looking.
I initially liked them, but later changed my mind. The same goes for e.g. prettify-symbols-mode in Emacs or conceal in Vim, which takes the same concept further.
I often work with files (both documents and code) where Unicode input is permitted, and it can then be important to know what exactly is written in the file. Fancy ligatures make this ambiguous.
I would also advise against ligatures in terminals, as it can mess up some text-based interfaces.
I just think they are pretty to look at while coding. I have to stare at code for long stretches of time. It's easier to do so when things are aesthetically pleasing.
I guess looking at font that doesn't support ligatures does become a little bit harder, but I can't imagine the switch being too time consuming.
I've been using JetBrains Mono for years now. It's great.
I have the opposite experience with ligatures owning to years reading academic mathematics papers before coding seriously. I can still parse semantically dense symbology significantly faster than most code (even with years of experience) to the point where code seems almost comically inefficient. That said, I know many programmers take the implicit context intrinsic to mathematics symbology as often times an inexplicable cognitive load.
If you have a lot of different symbols, it makes sense that ligatures would help to distinguish them more easily. So, ligatures for Haskell symbols also probably help, since there are so many infix operators in Haskell. There are also a bunch of old papers that showcase Haskell code and use the ligature representation of its operators.
However, most programming languages really just have a few symbols: arithmetic operators (+, -, /, *), comparison operators (<, >, <=, >=), and logical operators (&&, ||, !). C also has bitwise operators (~, &, |). It's already easy enough to distinguish these without ligatures, so the benefit is negligible here, IMO. I prefer to go without ligatures, because I have no trouble remembering or distinguishing them, and, like someone else mentioned, I find ligatures in a monospace font kind of weird (how they morph into a two column character when you write them, and turn back to a one column character when you delete half of it).
