MehdiHK

One of my favorite books! Any plans to make this series a book as well? (Will be an instant buy for me)

Moravec's paradox

That's the author's (Anders Hejlsberg) journey of these programming languages. Doesn't need to be evolution though.

https://en.wikipedia.org/wiki/Anders_Hejlsberg

If you need true multithreading

I didn't say multithreading anywhere. Mutitasking (concurrency) != Multithreading.

You can do pre-emptive concurrency with a single thread in other runtimes, where each task gets a pre-defined amount of CPU time slice, that solves fair scheduling for both IO and CPU-bound workloads. Nobody is supposed to pick NodeJS for CPU-bound workload, but you cannot escape JSON parse/stringify event-loop blocking in practice (which is CPU-bound).

JSON.stringify was one of the biggest impediments to just about everything around performant node services

That's what I experienced too. But I think the deeper problem is Node's cooperative multitasking model. A preemptive multitasking (like Go) wouldn't block the whole event-loop (other concurrent tasks) during serializing a large response (often the case with GraphQL, but possible with any other API too). Yeah, it does kinda feel like amateur hour.

No pricing page? Also how does it compare to Cribl?

Synology is still my go to with the model I already purchased. But I'm not sure I'll be buying them again after this:

https://www.tomshardware.com/pc-components/nas/synology-requ...

Not related to VPC, but I'm a big fan of the author. Loved his book "Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People" when it came out a few years ago. If you know anyone struggling with common data structures and algorithms, this book can make it fun for them.

This.

I'd also add that code readability goes a long way too. Rust compiler has better checks than Go, but when LLMs make mistakes it's a lot easier to identify and fix generated Go code than Rust.

So the balance between verbosity and readability is important too, in addition to soundness checks. Java and Go are both verbose, but Go is intentionally designed for readability.

And compile time as already mentioned. Go wins there too.

All of these help together to iterate faster with fast and often subtly wrong generated code. LLMs will continue to be less wrong as the available training samples increase over time. That's something for the future to see what wins there.

How does it compare to Telepresence?

https://github.com/telepresenceio/telepresence

That's quite interesting. Thank you for the link.

Prometheus scrapes metrics at constant intervals. How does being serverless helps here?

Slightly off topic: I was a bit surprised nobody ported space-efficient marisa trie to Rust, or any other languages.

Anybody knows why?

https://github.com/s-yata/marisa-trie

Oh, didn't realize that. How does it handle key input in Windows? Text Services Framework or something else?

Cool. Do you have plans for Windows and macOS frontends?

I use revanced for this on Android. Pretty cool, adblocker, sponsor block, customization like removing shorts. It patches YouTube APK, so you retain same UX, no need to use a new app.

Edit: forgot to add link - https://revanced.app/

Be aware of the fake ones.

See MakeCode: https://www.microsoft.com/en-us/makecode

It starts like Scratch but then can help kids transition from block-based to text-based programming (JavaScript or Python).

I recently discovered Photostructure. After trying a few other alternatives, this is what I prefer now.

https://photostructure.com/faq/why-photostructure/

I recently switched to https://www.trancy.org/

Came here to write about AdGuardHome too. I was PiHole user until I found this. So much polished, so much better. This folks deserve more publicity.

I don't have enough HN points to downvote this comment, otherwise I would.

You don't know how comments like this affects people with anxiety, which probably led them to search for a solution online in the first place.

Anyway, you are person unworthy of any attention. I'm just trying to make sure op isn't taking you seriously.

One solution that seemed to be the best of both is, a take home test followed by pair programming session to add a small feature on top of that, or refactor something, or write tests etc.

Real world challenges needs time to think, often time to refactor after initial working prototype. A take home allows that.

Also the candidate is already relaxed in the pair programming session because it's a familiar codebase. You'll get signal if they didn't write it or wrote something they didn't quite understand.

Git Tower GUI app has undo feature too, which is very handy. They announced it in this post: https://www.git-tower.com/blog/how-we-built-undo/

Have you seen Terraform CDK? https://github.com/hashicorp/terraform-cdk

Terraform CDK is a thing too, if you want to go beyond AWS.

We are going to upgrade from LEGO Boost + block based coding [1] to LEGO Mindstorms + Python [2] this year.

[1] https://www.lego.com/en-us/service/help/products/electronics...

[2] https://youtube.com/playlist?list=PLj_k_RHuTqaUojvL-J76TVjG2...

I'm currently a software engineer based in Berlin and I've found that stock options are not common at all in Germany [1]. I'm curious to know, is this scene different in Netherlands or other places in EU?

[1] https://www.ft.com/content/5778f3d0-1b3c-11ea-97df-cc63de1d7...

Thanks. This actually makes sense. I'm going to try this from tomorrow.

bit is my latest favorite git TUI. Check it out here: https://github.com/chriswalz/bit

Thank you for the link!