https://www.visidata.org/ is way, way, way, way better than excel and it’s FOSS.

As for the rest:

• I don’t really miss Word because WYSIWYG editing is just kinda bad across the board. Much better to write with markup rather than fighting an auto-formatter all the time.
• I thankfully have not needed to make much of any PowerPoints, but I think I would probably feel similarly about them and want them in some kind of markup language as well.
• Teams just sucks ass compared to many other alternatives, though I’m admittedly not familiar with good FOSS ones
• Outlook is basically just a dinosaur and there’s a million ways to do email better. Frankly, FOSS has it beat by a huge margin

The rest of Office isn’t really even worth talking about tbh.

For excel stuff, https://www.visidata.org/ is way, way better than excel assuming the data is tabular (which, frankly, it should be anyway). Like it’s not even close.

Completely agree. Just a bunch of people who clearly don’t play the game and know nothing about it talking out of their asses.

IMO you can’t have a serious opinion about the game without having actually played it competitively. If you’re just somebody that’s casually played a couple games with friends and family, your opinion about the game isn’t really relevant.

This couldn’t be further from the truth, and it’s pretty clear you don’t actually play the game. I had no idea this misconception was so common.

Chess is ALL ABOUT creativity and figuring out how to outplay your opponent and secure a win. It’s a game of strategy and tactics, of timing and technique. The way “memorization” works is that players tend to have some number of moves in their opening(s) memorized (typically 5-10, though top players can go to greater depth), at which point they are “out of book” and into the middlegame, which is where the game is actually played using some combination of positional ideas, tactics, and calculation. Many players opt to play less theoretically viable openings (that is, variations that are not quite as good with best play), because it gets their opponent out of book faster. “Novelties” (a move in a variation not previously played by a master/grandmaster in a tournament) are played all of the time, even by grandmasters.

Based on the number of comments in this thread, apparently this is a common misconception. Memorization is not the primary skill of chess. Knowledge of chess principles and common ideas, strategies, and tactics and the ability to synthesize those ideas with elements of the current position are the primary skill of chess. In fact, novel problem solving is very fundamental to the game.

Opening theory prep ultimately makes up a pretty small part of the game (though it is more pronounced at top levels of play). The primary purpose of studying openings is not to just memorize a bunch of lines (though having lines prepped is helpful), but to understand the common thematic elements that arise from said openings and common middlegame positions and ideas.

Do you know their rating? Tbh most people’s idea of being “pretty good at chess” is actually not very good at all (I don’t mean that as an insult, more lack of familiarity with the game).

That’s not to say that it’s impossible for someone to think those things and be a strong chess player, but it’s probably not super common. I’ve actually ran into a couple people at a local chess club with “interesting” ideas about vaccines and uh… let’s just say they were not hard to beat (I think I mated one guy in like 12 moves). And btw, I’m not even a super strong chess player myself (~1134 USCF). But like, they probably would seem really strong to someone that just occasionally plays chess at family gatherings or whatnot. Chess is a game with a low skill floor and very high skill ceiling, so you have a huge range in ability.

This is not at all what chess is. This reads to me like you don’t really play chess?

Like sure, good chess players have studied opening theory for the openings they play (and top players know at least some theory about most competitive openings), but there’s so much more to the game than simple memorization. Memorizing a bunch of lines and doing nothing else will get you nowhere with the game. Chess is about principles, concepts, ideas, strategies. It’s about tactics and positional ideas and how the two intersect. It’s about tempo and conducting the initiative. There’s a reason it’s the game with the most number of books written about it by a large margin. It’s an incredibly deep game that rewards investment and fine-tuning your own learning process (and, in fact, a great deal of unlearning bad ideas you learned earlier).

It is decidedly not a game about memorization, even if there is some amount of it involved. At high level of play, memorization (or what we simply call “prep”) is table stakes for playing the actual game. At lower levels, many players don’t know a lot of opening theory and simply rely on some combination of positional ideas, tactics, and calculation.

Do you know what rating your friend was at? In my experience, the super strong players I’ve met (including a Senior Master that occasionally visits our chess club who’s 2450 USCF or so) are incredibly intelligent and sharp. Anecdotally in my own chess career (only ~1134 USCF atm, though I think I’m a bit underrated due to my last tournament being in 2023), I’ve definitely noticed a difference in my own thinking since I started studying chess. Progressing in chess involves a lot of meta-cognitive thinking, and that kind of thing translates to all kinds of things in life.

https://www.visidata.org/

Way, way better than excel for working with tabular data. Excel is child’s play in comparison.

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

Who gives a fuck about whether or not you were planned? It literally makes no difference whatsoever.

I’d definitely prefer more sunlight in the morning. It’s 6:45am right now and the sun hasn’t even risen yet and won’t start for another half hour.

Meanwhile, more sunlight later in the day is often gone to waste anyway, between work/commute/dinner/etc. It’s especially wasteful later in the summer… You already have sunlight super late in the day anyway.

But honestly, I would take either as long as it stops changing.

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.*

I’m not sure what you mean by “locality of reference”. I assume you mean something other than the traditional meaning regarding how processors access memory?

Anyway, it’s often been said (half-jokingly) that Haskell is a nicer imperative language than imperative languages. Haskell gives you control over what executing an “imperative” program actually means in a way that imperative languages don’t.

To give a concrete example: we have a custom monad type at work that I’m simply going to call Transaction (it has a different name in reality). What it does is allow you to execute database calls inside of the same transaction (and can be arbitrarily composed with other code blocks of type Transaction while still being guaranteed to be inside of the same transaction), and any other side effects you write inside the Transaction code block are actually collected and deferred until after the transaction successfully commits, and are otherwise discarded. Very useful, and not something that’s very easy to implement in imperative languages. In Haskell, it’s maybe a dozen lines of code and a few small helper functions.

It also has a type system that is far, far more powerful than what mainstream imperative programming languages are capable of. For example, our API specifications are described entirely using types (using the servant library), which allows us to do things like statically generate API docs, type-check our API implementation against the specification (so our API handlers are statically guaranteed to return the response types they say they do), automatically generate type-safe API clients, and more.

We have about half a million lines of Haskell in production serving as a web API backend powering our entire platform, including a mobile app, web app, and integrations with many third parties. It’s served us very well.

As a senior engineer writing Haskell professionally, this just isn’t really true. We just push side effects to the boundaries of the system and do as much logic and computation in pure functions.

It’s basically just about minimizing external touch points and making your code easier to test and reason about. Which, incidentally, is also good design in non-FP languages. FP programmers are just generally more principled about it.

Because they are universally incapable of coming anywhere close to the full power of git.

I can’t tell you how many times I’ve had GUI-only people ask me to unfuck their repo (fortunately not at my current job, because everyone uses the CLI and actually knows what they’re doing). It’s an impedance to actually learning the tool.

Ultimately any GUI is a poor, leaky abstraction over git that restricts many of the things you can do for little actual benefit.

The point of the joke is not that the Python interpreter will change types mid-program on its own, but that you don’t have any real way of knowing if you’re going to get the type you expect.

Programs are messy and complicated, and data might flow through many different systems before finally being used for output. It can and often does happen that one of those systems does not behave as expected, and you get bugs where one type is expected but another is used in actuality.

Yes, most likely what would happen in Python is a TypeError, not actual output, but it was pretty clearly minor hyperbole for the sake of the joke.

You don’t see how type mismatch errors can happen in a dynamically-typed language? Then why do they happen all the time? Hell, I literally had a Python CLI tool crash with a TypeError last week.

Kids are just really good at learning quickly. That’s all it is, really. Chess is all about study and learning, so kids are very adept at getting good quickly. Obviously there are some who are prodigies, but that’s pretty exceptionally rare.

Adult learners also can get good quickly, but it requires a lot of meta-cognitive thinking (thinking about how you think, or “learning to learn”), time, and discipline. The guy that runs my local chess club is probably in his 60s, and he told me that he was sitting around ~1100 for a long time until recently he started studying, where he rapidly jumped up to ~1600 after, as he put it, “things clicked”.

It’s never too late to rapidly improve your own abilities, which is what I really love about the game, because I find it teaches you to apply that mindset to all aspects of life.

Think about how many columns you can fit!

We have someone at work who uses it and he’s constantly having tooling issues due to compatibility problems, so… yeah.

I’m sure it’s fine for sticking in the shebang and writing your own one-off personal scripts, but I would never actually main it. Too much ecosystem relies on bash/posix stuff.