I use Firefox on mobile all the time. Works fine for me. The fact that I get adblock on mobile makes it a no-brainer to use over chrome.

Well, if using vim, this is technically also true, most likely.

What a sorry state of affairs that this is novel. Been doing this for years and always will. Fuck LLMs and the enshitifiation of this discipline.

Ah so it’s not really an export, it’s just the backing store used by some other (locally-running) program that you’re trying to reverse engineer?

In that case yeah an sqlite database is probably most appropriate, though I can see a CSV still being desirable to remove a potential sqlite dependency.

If it’s an export that will be consumed by a separate, unrelated program later, I think a CSV is most appropriate. Databases are persistence tools, not transport.

Based on what I can find, they are microscopic mites. You also have microscopic mites all over your face that you probably ingest at some point or another… So it’s really not that weird.

I’m honestly not sure, but I’m fairly certain it’s intentional obfuscation done for the production build. Why they think it’s so important to hide class names, I’ll never know.

In modern chess, engines have gotten good enough that we generally do know the top moves and humans can’t beat them. We can even numerically assess someone’s chess play with a computer, which we call “accuracy”. Obviously they can always be improved further, and there are a handful of situations where they might misevaluate, but it’s still pretty incredible.

Engines have only made chess more exciting as they have shattered a lot of old theory and helped people find a lot of new and innovative ideas. They are an incredible aid in analysis and tournament prep.

That’s what I’m saying.

That’s a really poor metric, because that encompasses many salaried jobs.

But yes, it’s ultimately just about whether or not you are selling your time for money, or if you have acquired enough money to exploit the labor of others to make yourself more money without doing anything yourself.

There’s no feeding going on. We’re simply laughing at their expense.

Nobody sane uses vim as an IDE

True, same people use unix as their IDE and vim as the editor therein.

What do you mean “build our dev environments around vim”? If you mean they write dev tooling in vimscript and explicitly require everyone to use it, I actually agree with you. I don’t believe employers should really ever force any particular editor or IDE if the work is getting done. I would be equally annoyed by a workplace forcing me to use vscode instead of vim. It would slow me down way too much.

If you are just complaining that they build dev tooling as a CLI, hard disagree. That is absolutely what dev tooling should use because it’s actually universal and can be used regardless of your editor choice.

At my workplace, our dev tooling is done via CLI and our developers use vim, emacs, and vscode. Because it’s all CLI, it’s easy for individual developers to add their own scripts to automate parts of their workflow as they see fit (and if such automations are deemed useful by the group at large, it will get merged into our shared devtools repo). We even have some editor-specific stuff in there people have written that they find useful, but it’s entirely optional.

Vscode definitely can’t handle large files like vim can. I can open files that are multiple GBs in vim without issue. Vscode definitely cannot.

A real nerd would know that React is a library and HTML is a markup language, and neither are programming languages.

It’s just for the “last mile” where code gets packaged up into releases. There’s still thousands of developers that have all of the code on their machines as well, it’s just that their local repos aren’t the ones that end up in the hands of end users.

Changes can come from anywhere. The Linux kernel itself doesn’t use any central repository like Github, it’s instead done via emailing patches that are eventually merged into the mainline kernel repository managed by Linus.

It is 100% decentralized.

It’s not that hard, technically speaking, though of course it takes skill to come up with a set of glyphs that work well together and such.

Also, there are websites that can scan your handwriting and turn it into a font file, which is pretty cool. I have a font I created of my wife’s handwriting.

I just… don’t connect the TV to the internet. Never had an issue with anything like that.

Shit! Sorry, got my wires crossed, I actually meant locality of behavior. Basically, if you’re passing a monad around a bunch without sugar you can’t easily tell what’s in it after a while. Or at least I assume so, I’ve never written anything big in Haskell, just tons of little things.

I’m not sure if I entirely follow, but in general you actually have much better locality of behavior in Haskell (and FP languages in general) than imperative/OOP languages, because so much more is explicitly passed around and immutable. Monads aren’t an exception to this. Most monadic functions are returning values rather than mutating some distant state somewhere. Statefulness (or perhaps more precisely, mutable aliasing) is the antithesis of locality of behavior, and Haskell gives you many tools to avoid it (even though you can still do it if you truly need it).

I’m not really sure what you mean by “don’t really know what’s in it after a while”. It might be helpful to remember that lists are monads. If I’m passing around a list, there’s not really any confusion as to what it is, no? The same concept applies to any monadic value you pass around.

Yeah, that makes tons of sense. It sounds like Transaction is doing what a string might in another language, but just way more elegantly,

I think you might have misunderstood what I was describing. The code we write doesn’t actually change, but the behavior of the code changes due to the particular monad’s semantics. So for example, let’s say I write a query that updates some rows in a table, returning a count of the rows affected. In this Transaction code block, let’s say I execute this query and then send the returned number of rows to an external service. In code, it looks like the API call immediately follows the database call. To give some Haskell pseudocode:

example :: Transaction ()
example = do
  affectedRows <-  doUpdateQuery
  doApiCall affectedRows
  return ()

But because of how Transaction is defined, the actual order of operations when example is run becomes this:

1. Send BEGIN;to DB
2. Call doUpdateQuery
3. Send COMMIT; to DB
4. If transaction was successfully committed, execute doApiCall affectedRows. Otherwise, do nothing

In essence, the idea is to allow you to write code where you can colocate your side-effectful code with your database code, without worrying about accidentally holding a transaction open unnecessarily (which can be costly) or firing off an API call mistakenly. In fact, you don’t actually have to worry about managing the transaction at all, it’s all done for you.

which fits into the data generation kind of application. I have no idea how you’d code a game or embedded real-time system in a non-ugly way, though.

I mean, you’re not going to be using an SQL database most likely for either of those applications (I realize I assumed that was obvious when talking about transactions, but perhaps that was a mistake to assume), so it’s not really applicable.

I also generally get the impression that you have a notion that Haskell has some special, amorphous data-processing niche and doesn’t really get used in the way other languages do, and if that’s the case, I’d certainly like to dispel that notion. As I mentioned above, we have a pretty sizeable backend codebase written in Haskell, serving up HTTP JSON APIs for a SaaS product in production. Our APIs drive all (well, most) user interaction with the app. It’s a very good choice for the typical database-driven web and mobile applications of businesses.

Ironically, I actually probably wouldn’t use Haskell for heavy data processing tasks, namely because Python has such an immense ecosystem for it (whether or not it should is another matter, but it is what it is)… What Haskell is great at is stuff like domain modeling, application code (particularly web applications where correctness matters a lot, like fintech, healthcare, cybersecurity, etc.), compilers/parsers/DSLs, CLI tools, and so on.*