rockwotj

sure but the unwind flags don’t prevent optimizations like exceptions

And based on a few clang discourse threads, it only removes .eh_frame

I think this only effects binary size, which I understand smaller binaries can load faster but not being able to get stacktraces for debuggers and profilers seems like a loss

Looking how the docs for https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#ind...

How does that affect code generation? It reads as only effecting debug information and binary size to my untrained eyes.

I wonder if this has ramifications on the OpenAI IPhone deal too.

Added to my list why I compile with -fno-exceptions

Agreed - I actually think TypeScript is easier to craft JSON output in tho: https://news.ycombinator.com/item?id=39242314

The Starlark approach is good too - I just like types if it's going to get narly and find Python typing to be suboptimal compared to TypeScript in terms of LSP and tooling (and only Facebook's Rust starlark interpreter supports types)

Sure, hence projects like SearchGPT. OpenAIs main advantage is in mass distribution (Apple deal, etc)

They recently announced they are training their next big model, new models isn’t stopping it’s just taking more time to get more breakthroughs

My favorite deno feature is coming to node directly. Awesome!

Maybe this means I don't always have to install esbuild to strip types - very excited how this will make writing scripts in TypeScript that much easier to use. I lately have been prefering Python for one off scripts, but I do think personally TypeScript > Python wrt types. And larger scripts really benefit from types especially when looking at them again after a few months.

It’s like the email format - it’s the wild west trying to parse these things, it doesn’t help that date/time is already a tricky subject.

> delete crap from topics

You have to rewrite the whole topic to do this right? (or do some hacks with compaction if you have unique keys)

Google has this, IIRC it’s called CDPush

Only create new tables, don't make breaking changes to existing tables. If needed dual write both versions. Looks a lot like a live migration (zero downtime) due breaking change to a SQL DB, except you have to keep the logic longer because you're at the customer's mercy of when the switchover happens.

Also it's important to have a table that is used to coordinate latest version. If you make a breaking change have the client that is behind to ask the user to upgrade. You can also tie this into how long you keep the dual write/read around with a min version supported across all clients.

You can do this with shortwave: https://www.shortwave.com/blog/introducing-ghostwriter-ai-wr...

On thing that is interesting is that they allow you to add additional prompt, because sometimes you don’t want an email to actually sound like you but it to sound like the writer you want to be (leveling up so to speak)

I am pretty sure the -f is for feature. Because there are flags like -fno-exceptions and -fcoroutines

Determinism: via sandboxing builds, it’s a little leaky by default (but getting better). See https://bazel.build/basics/hermeticity

Parallelism: Easier with sandboxing, but the build declares all inputs/outputs so it builds a merkle tree and strictly inforces a DAG. This way you can parallelize independent subgraphs and cache at a fine grained level.

Used this to build a confetti inbox for Shortwave's April fools [1] a few years back. Really run library, and easy to integrate.

[1]: https://www.youtube.com/watch?v=_ROTg3KcoIA

I'm waiting for being able to restrict to a specific JSON Schema

I expect GPU hardware to specialize like Google’s TPU. The TPU feels like ARM in these AI workloads where when you start to run these at scale, you’ll care about the cost perf tradeoff for most usecases.

> CPU/GPU share the same RAM AFAIK.

This depends on the GPU I believe Apple has integrated memory, but most GPUs from my limited experience writing kernels have their own memory. CUDA pretty heavily has a device memory vs host memory abstraction.

Google already did this with TPUs and it supposedly saved them a ton in energy costs. I read somewhere that NVIDIA doesn’t gain as much by making the chips more cost effective, just making them more powerful

You can also do this with https://shortwave.com (and get iOS/Android/Web)

https://twitter.com/Shortwave/status/1760723475923390598

I built dark mode for an email client’s (shortwave.com) HTML emails and this was the last major hurdle to solve. I wish that had existed then :)

Generally making emails dark mode is a non trivial problem, there is an hope source library that is a good start from Tempo: https://github.com/yourtempo/tempo-message-dark-mode

However there are plenty of edge cases that plugin doesn’t handle that we had to fix at Shortwave. Examples include legacy HTML4 attributes, better support for emails that are half dark mode, emails that have background images of #fff (looking at you google play reciepts), the list goes on. It’s honestly pretty solid now

Googletest does this: http://google.github.io/googletest/primer.html#assertions

Question for you, what is the level of ROI for doing simplified just send unmodified existing CI vs integrating with the SDKs?

Do you happen to know if hitting this big required SDK integration?

> I agree, though in practice with many Rust programs that iteration cycle is actually not "edit, compile, run", it's "edit, save, wait for rust-analyzer to update" which is generally much quicker (even if it is sometimes still a little slow).

This is one area that I think Dart did a good job on. They support both a JIT (I am not sure if it’s tiered) and AOT modes of compiling, the JIT targeted for development and AOT for production. This is the ultimate extreme of optimizing for both use cases, obviously it’s a ton of work, but I would love more languages to be like this. (I believe the JIT mode works directly on the source so there isn't an intermediate compilation step like Java, but it’s been a few years since I’ve used Dart)

[1]: https://dart.dev/overview#native-platform

> your runfiles tree

I don't remember using runfiles much outside of tests in Bazel, even at Google. My guess would be that runfiles are packaged up into via MPM [1], which in open source world I would guess a container image is the closest equivalent? Then you get hermetic runtime environment, especially because k8s/containers seems to be the default deployment platform these days. I think the bazel OCI rules [2] should package runfiles too (I haven't checked)

[1]: https://www.usenix.org/conference/lisa14/conference-program/...

[2]: https://github.com/bazel-contrib/rules_oci

Hard disagree. I often read header files directly for documentation and think it’s pretty great. Makes it easy to delve into the source if needed and I dont have to leave my terminal/nvim

Check out Redpanda if you don’t like Zookeeper. Raft based, no JVM, lower cost and simpler to run Kafka compatible system

Oh it’s certainly looking like that IMO depending on your use case for docker

You can run wasm in k8s: https://krustlet.dev/

Docker itself can run wasm: https://wasmlabs.dev/articles/docker-without-containers/

There are a few serverless runtimes based on wasm: https://wasmcloud.com/

A lot of those are powered by wasmtime or WasmEdge.

If you’re wanting to be able to just pull down a random app and run it as wasm, that’s inherently harder with wasm, because you have to recompile, and amazing compiling stuff is always harder than it should be. For example I compiled jq to wasm to other day, so you dont have to worry (as much) about the CVEs that was issued recently. https://github.com/rockwotj/jq-wasi

I also recommend https://sli.dev/ it’s pretty batteries included and mdx based