0xFEE1DEAD

Exactly.

I blame apple for making me run an old macOS version because I don't want to look at this ugly mess they've created. I've been running macOS since 2008, and unless they manage to turn things around, my next laptop won't be an apple.

Have you tried WezTerm yet? It also uses lua for writing its configs which makes it highly customizable.

I've switched to it from iTerm2 a couple of years ago and gradually added more and more to my config and it's super powerful.

I think they're using SpamAssassin so don't expect world leading spam filtering.

But, they allow you to write your own sieve scripts so you can really customize the experience a lot.

Don't think of them as another proton mail, they're much more a DIY mail provider.

I recommend purelymail.com (not affiliated in any way, just a happy customer).

I've been a customer for 4-5 years, ever since I saw a hn post about them, and I have zero complaints.

It's dirt cheap ($10 per year for unlimited amount of users).

They allow wildcard addresses and I've set up my own "trash mail" so I can register an account at e.g. LinkedIn with linkedin@my-domain.com.

I've set up 4 different domains and 3 accounts and all of this for $10 a year.

Sorry if this reads like an ad, but I think it's super cool to offer such a great service for a fair price.

For anyone curious: "c" just means that it's a character device.

There is also "b" for block device (e.g. a disk, a partition, or even something like a loopback device) and "p" for FIFOs (similar to mkfifo).

The two numbers are just identifiers to specify the device, so in case of `5 1` it means the systems tty console, while `1 8` would mean "blocking random byte device" (mknod dev/random c 1 8)

I agree with this take, but I'm wondering what vibe coders are doing differently?

Are they mainly using certain frameworks that already have a rigid structure, thus allowing LLMs to not worry about code structure/software architecture?

Are they worry-free and just run with it?

Not asking rhetorically, I seriously want to know.

I honestly don't get vibe coding.

I've tried it multiple times, but even after spending 4 hours on a fresh project I don't feel like I know what the hell is going on anymore.

At that point I'm just guessing what the next prompt is to make it work. I have no critical knowledge about the codebase that makes me feel like I could fix an edge case without reading the source code line by line (which at that point would probably take longer than 4 hours).

I don't understand how anyone can work like that and have confidence in their code.

They actually sued a lego youtuber (or threatened to sue - unsure) for using a lego brick in his logo. this lead to him creating a new word for lego bricks "Klemmbausteine" which means "clamping building bricks".

You should remove any reference to LEGO from the website and the examples. LEGO is extremely protective of its brand (similar to / worse than Nintendo) and does not want third parties using its name, because it is concerned that LEGO could become a generic term which could put its trademark at risk.

See: "Lego sues Dutch firm over anti-terror blocks using name and shape" https://www.thetimes.com/world/europe/article/lego-sues-dutc... ( http://archive.today/q5XrX )

Apparently, they already do https://arxiv.org/abs/2409.01754

Thank you for sharing, what an interesting read.

> Now, the researchers are working on further research to extend their technique to detect breathing [...]

Impressive from a technical standpoint, but super scary from a privacy standpoint. Surely this must allow them to detect and differentiate between plosives, which is probably enough to infer what's being talked about.

On one hand, it's super impressive how far we've come in such a short amount of time. On the other hand, this feels like a blatant PR move.

GPT-5 is just awful. It's such a downgrade from 4o, it's like it had a lobotomy.

- It gets confused easily. I had multiple arguments where it completely missed the point.

- Code generation is useless. If code contains multiple dots ("…"), it thinks the code is abbreviated. Go uses three dots for variadic arguments, and it always thinks, "Guess it was abbreviated - maybe I can reason about the code above it."

- Give it a markdown document of sufficient length (the one I worked on was about 700 lines), and it just breaks. It'll rewrite some part and then just stop mid-sentence.

- It can't do longer regexes anymore. It fills them with nonsense tokens ($begin:$match:$end or something along those lines). If you ask it about it, it says that this is garbage in its rendering pipeline and it cannot do anything about it.

I'm not an OpenAI hater, I wanted to like it and had high hopes after watching the announcement, but this isn't a step forward. This is just a worse model that saves them computing resources.

> on internal, legacy codebases, enterprisey stuff

Or anything that breaks the norm really.

I recently wrote something where I updated a variable using atomic primitives. Because it was inside a hot path I read the value without using atomics as it was okay for the value to be stale. I handed it the code because I had a question about something unrelated and it wouldn't stop changing this piece of code to use atomic reads. Even when I prompted it not to change the code or explained why this was fine it wouldn't stop.

Yes, for me it is and it was even before this experience. But, you know, there's a growing crowd that believes AI is almost at AGI level and that they'll vibe code their way to a Fortune 100 company.

Maybe I spend too much time rage baiting myself reading X threads and that's why I feel the need to emphasize that AI isn't what they make it out to be.

I wish they wouldn't use JS to demonstrate the AI's coding abilities - the internet is full of JS code and at this point I expect them to be good at it. Show me examples in complex (for lack of a better word) languages to impress me.

I recently used OpenAI models to generate OCaml code, and it was eye opening how much even reasoning models are still just copy and paste machines. The code was full of syntax errors, and they clearly lacked a basic understanding of what functions are in the stdlib vs those from popular (in OCaml terms) libraries.

Maybe GPT-5 is the great leap and I'll have to eat my words, but this experience really made me more pessimistic about AI's potential and the future of programming in general. I'm hoping that in 10 years niche languages are still a thing, and the world doesn't converge toward writing everything in JS just because AIs make it easier to work with.

I've added a section to the README that goes into the subtleties of compiletime elimination and what to watch out for to ensure that calls to dlg.Printf can actually be eliminated: https://github.com/vvvvv/dlg?tab=readme-ov-file#true-zero-co...

I'd appreciate any feedback on whether these changes make the behavior more transparent and less misleading.

> but if you do find a bug, you write a new test and fix it.

Maybe there's a misunderstanding here but this library is not meant to replace tests. It's for initially finding the bug for which you then write a test case (or not).

Well, my vim is missing buttons like these and I wasn't aware such a feature existed.

Maybe I'm just old, maybe it's just a different approach, but I built dlg for myself because it fits my workflow.

> What does this meaningfully offer over the "built-in" debug logging?

For you, it most likely doesn't offer anything meaningful.

For devs who use fmt.Printf a lot, it maybe does.

Thank you!

You're absolutely right, it annoys me as well.

It's a bit finicky to do so, but I'm currently in an exploratory phase of providing an even more fine grained stack tracing feature and filtering out dlg itself is definitly on my todo list.

I do write tests but I'm not a fan of aiming for 100% coverage because it's incredibly tedious to achieve, and the gains in my experience are marginal.

That being said even with 100% coverage your code may still contain bugs. If you've never had to debug code with extensive tests then hats off to you.

In short: You're right - Go will still evaluate argument expressions. In hindsight, I should've made that more obvious, not calling this out initially was an expert blind spot on my part, not an intent to mislead.

If we consider this example:

  func risky() error {
    return fmt.Errorf("unexpected error")
  }

  func risky2() error{
    return fmt.Errorf("also an error")
  }

  func main() {
    fmt.Printf("something failed: %v", risky())
    dlg.Printf("something failed: %v", risky2())
  }

And look at the disassembly:

  0x10009f354  d503201f  NOOP                ; Dead code of dlg.Printf
  0x10009f358  b0000000  ADRP 4096(PC), R0   ; Load "also an error" string address
  0x10009f35c  9124ec00  ADD $2363, R0, R0   ; Calculate exact string address
  0x10009f360  d28001a1  MOVD $13, R1        ; Set string length=13 (R1)
  0x10009f364  aa1f03e2  MOVD ZR, R2         ; Clear R2
  0x10009f368  aa1f03e3  MOVD ZR, R3         ; Clear R3
  0x10009f36c  aa0303e4  MOVD R3, R4         ; Clear R4
  0x10009f370  97ffd890  CALL fmt.Errorf(SB) ; Call fmt.Errorf

What disappears is the logging work (formatting, interface/slice plumbing, I/O) and the call itself. Go cannot eliminate calls to functions inside of Printf because they could produce side-effects. Eliminating functions calls like this would be very expensive to do and would clashes with Go's focus on fast compilation times.

I'll add a section to the README that explains this. Thanks for pointing it out.

Testimonial:

> I've never been asked to pair up eversince I've started using tattoy

Sure you can, I've done it plenty of times. I'm genuinely curious why you think it's not possible.

The only reasons I can think of:

- you're rewriting a legacy system and migrate parts incrementally

- data compliance

- you're running a dangerous database setup

I try my best to avoid putting any business logic inside databases and see stored procedures only as a temporary solution.

A public chat - like one that anyone can join at any time without needing an invitation?

If so, then you really don't need any extra encryption.

If not, then it depends on who's using your chat, how they use it, and for what purpose. Are the users of the chat room a small group with occasional users joining or leaving, or are many users expected to join and leave at any given moment?

That being said, encrypting the notifications won't bring any real benefits. A bad actor would simply focus on trying to compromise your server.

If you do decide that full e2ee would benefit your users, then look for someone who can help you implement it.

Implementing real e2ee for a 2 party chat is hard for someone without experience.

Implementing e2ee for a group chat is hard even for someone with experience.

Oh wow I didn't know someone was actually working on an alternative. It really does look promising. Thank you, definitely going to try it.

Years ago, I tried lua and wasn't impressed. Then I started using Neovim, did the necessary configuration in lua, but continued writing my own scripts in vimscript. Later I started using wezterm and decided to give lua a second shot, and I began to really like it.

I realized my initial dislike for lua stemmed from my experience with javascript (back in the jwquery days), where maintaining large codebases felt like navigating a minefield. The lack of type system made it all too easy to introduce bugs.

But lua isn't like that. It's not weakly typed like javascript - it's more akin to pythons dynamic duck typing system. Its simplicity makes it remarkably easy to write clean maintainable code. Type checking with type is straightforward compared to python, mostly because there are only five basic types (technically seven but I've never used userdata or thread). And I even started to enjoy using metatables once I understood how and when to apply them.

That being said, lua's lack of popularity probably stems from its limited stdlib, which often feels incomplete, and the absence of a robust package manager. luarocks is a pain to work with.

All that being said, I don't really see the point of using this project.

While I do wish type annotations were a native feature, the ones provided by the lsp are good enough for me.

Sorry for going off topic here but I've had the same experience.

I'm not sure which update improved 4o so greatly but I get better responses from 4o than from o4-mini, o4-mini-high, and even o3. o4 and o3 have been disappointing lately - they have issues understanding intent, they have issues obeying requests, and it happened multiple times that they forgot the context even though the conversation consisted of only 4 messages without a huge number of tokens. In terms of chain-of-thought models I prefer DeepSeek over any OpenAI model (4.5 research seems great, but it’s just way too expensive).

It's rather disappointing how OpenAI releases new models that seem incredible, and then, to reduce the cost of running them, they slowly slim these models down until they're just not that good anymore.

Call me a monarchist, but I think Python has changed for the worse ever since Guido van Rossum stepped down.

Someone on reddit [0] mentioned that they updated their device via USB and hadn't encountered any issues. If that's true, then it might actually have been the previous firmware update that silently bricked the device. Or maybe Samsung only test in a controlled lab environment without real world signal interference.

In any case, it's mind boggling how a multi billion dollar company lacks proper rollout strategies.

I have a pair of Sony WH-1000XM4 headphones, and their app constantly tells me to install the latest firmware update. After the 20th time I finally agreed - only to be met with the update instructions: I must perform the update in a place with no other bluetooth or wifi devices.

Where on earth would I even have to go to find a place without there being any 2.4Ghz signal interference?

I've never been more careful when pressing “Cancel,” making sure I don't accidentally tap “Agree and Continue”.

[0] https://www.reddit.com/r/Soundbars/comments/1jb1ymp/comment/...