First I tried playing DVDs straight from PC which is connected to TV. That was horrible quality and UX.

Then I bought a good quality DVD player with hardware upscaling. It provided better image quality and slightly better UX. But you still had to deal with the menus and buch of other slow loading stuff that comes with DVDs... Gave up on it.

I have two major use cases:

1) a TODO list

2) longer texts (project plans, travel plans, shopping lists for things to buy sometimes in the next 6 months (e.g. books to read), etc.).

The TODO list is my daily driver. As the family became larger, it became difficult to track what needs to be done the next day (including simple things, like "give a daily dose of vitamin", "clean & lube the bike chain every 2w"). For a very long time, I used pen & paper. It was OK, used it for years, but it didn't scale so well with kids. An Android TODO/reminder app with notifications and repeats was a life saver. I used BZ Reminder (https://play.google.com/store/apps/details?id=com.bzzzapp) which ticked all the boxes. But the author decided to downgrade the lifetime licences to periodic... It's still not expensive but I don't approve the behavior. After trying out a dozen of similar apps, I ended up with "Reminders: Todo List & Notes" (https://play.google.com/store/apps/details?id=com.pocketbril...). I can't live without a tool like this anymore. TBH, pen & paper TODO lists are still around.

For the longer texts I used an offline wiki (ZIM) for quite some time. Then gradually moved to Google Keep (simple, can accept text & lists, and can be shared). The Keep collection kept growing. With both lists and texts. It's pretty bad input method, but its simplicity kept me using it for years. Now I'm happy with simple txt files (syced between phone & PCs, and properly backed up).

It has a lot of content & good presentation (minimalistic, but crisp). All about sales and marketing. I have no idea how an experienced sales or marketing person would rate it, but to me it sounds reasonable and useful. Give it a try (e.g. try this video: https://youtu.be/FMzKk73iUhw -- his videos have clickbaty titles, and are pretty long -- don't let that discourage you).

He also has two books (sales and marketing), but I didn't read them yet. The reviews say that they are somewhat basic. I'll still give them a try.

- no service is expected to last long enough or to keep your data safe,

- a physical medium is the way to go,

- create 3 backups stored in different location,

- use a different brand for each backup,

- every 10y review the backups: check the data degradation, rebackup on a new medium if the current one is getting phased away, reencode the content if the format is becoming obsolete & hard to open. [IMO, this is the key point]

Getting the old works of a predecessor on a physical medium is a really good feeling (I know how I felt when I'd discover the old notebooks from my father, uncle, etc.). Based on my experience and Internet, CD-R seems to be a good choice if the data volume allows. But it's getting slowly phased away. (fun fact: a few months ago I found the first CD I burnt -- works flawlessly (although, no checksums checked) after 25y)

You get that organically when you are serving lots of users. And, there's not much GPUs etc. used for that. Training LLMs gives you a different utilization pattern. The "best effort" resources aren't as useful in that setup.

TL; DR: It's not ~free.

I worked on large Python, C++, Java & Go services. I have 10y+ of experience with the first 3. C++ allows you to write incomprehensible code (even to the experienced C++ devs) and justify its existence (because of the performance gains). But you need to be a top expert to write a compileable code of that type. I'm comfortable with diving in any C++ codebase except for the libraries like std, boost, abseil, folly, etc. Most of the code there is absurdly difficult to comprehend.

On the other hand Python leads in the ways a junior dev can introduce hell in the code. Especially if the team doesn't rely on the strict type check. I have seen horrors.

I was bewildered when I realized that working with JavaScript with type checks (Closure compiler) was insanely more productive and smooth than working with Python (before the type checks).

That's why Java won the enterprise world. It takes an effort to make a mess in Java (but people still manage). Go is in a similar place.

This was ~10y ago, so my memory might not serve me well. A bit of context:

- proprietary service, written in Python, maaany KLOC,

- hundreds of engineers worked on it,

- before this framework, writing the integration tests was difficult -- you had a base framework, but the tests had no structure, everyone rolled out their own complicated way of wiring things -- very convoluted and flaky.

The new integration tests framework was build by a recently joined senior engineer. TBF, it's wrong to say that it's was a framework, if you think in the xUnit sense. This guy built a set of business components that you could connect & combine in a sound way to build your integration test. Doesn't sound like much, but it significantly simplified writing integration tests (it still had rough edges, but it was 10x improvement). It's rare to see the chaos being tamed in such elegant way.

What this guy did:

- built on top of the existing integration tests framework (didn't rollout something from zero),

- defined a clear semantic for the test components,

- built the initial set of the test components,

- held a strong ownership over the code -- through the code review he ensured that the new components follow semantics, and that each test component is covered by its own test (yep, tests for the test doubles, you don't see that very often).

Did it work well longterm? Unfortunately, no. He stayed relatively short (<2y). His framework deteriorated under the new ownership.

Travis, if you are reading this and you recognized yourself, thank you for your work!

Why even consider the insurance as investment (money increasing tool)? A stock market would get you higher gains at more controlled risk.

The 3rd best financial advice I got is about insurances: "Pay the insurance only if the negative outcome would cause you a significant financial loss" (and is of relatively high probability)

So, insuring a house from fire etc. makes sense. But, my $2k bike is not worth covering (from my PoV). Or, if we go to extreme, my (unnecessary) motorbike/boat/jet ski as if they are destroyed, I can continue living without them (a bit of exaggerated example, but I hope you get my point). Same for insuring a house from unlikely events.

Are the answers stable/reproducible? (I'm not in a location where this is launched)

But the absurdity of most of the answers is believable. I'm still perplexed at how much Big Tech is betting on this broken (and absurdly expensive) technology.

Look for "Metadata information"/control bits at https://abseil.io/about/design/swisstables

An accurate answer is often driven by a concrete and highly confident fact in the training dataset (e.g. structured data fact, like a birth date from Wikipedia etc.).

The hallucinations are derived facts of (hopefully) low confidence. Nondeterminism is more common if you have low scores. Only a few facts can take high score (in a usable system), while many can take a low score -- then numeric instability can make a mess.

I'm not very familiar with LLMs, but I do have experience with the traditional ML models and content understanding production system. But, LLMs are not far from them.

- https://ibb.co/gJQhTbK

- https://ibb.co/bJZ7JVR

I get the same behavior for the people queries like "Barack Obama". (Android 14, Pixel 4a)