HNHacker News
TopNewBestAskShowJobs

egnehots

852 karma · joined June 7, 2016

submissionscomments
egnehots··on Pingora: build fast, reliable and programmable networked systems
from their doc, Reasons to use Pingora:

- Security is your top priority: Pingora is a more memory safe alternative for services that are written in C/C++.

- Your service is performance-sensitive: Pingora is fast and efficient.

- Your service requires extensive customization: The APIs Pingora proxy framework provides are highly programmable.

egnehots··on Why the Future of Cloud Deployments Is Unikernels (2023)
also: https://unikraft.org/docs/concepts
egnehots··on It is hard to avoid JavaScript
for devops, datascience and ml stuff Python is a good contender
egnehots··on Vera: Vector-Based Random Matrix Adaptation
VeRA makes LoRA ~10x more parameter efficient while retaining the same performance.

It's somewhat like a recursive LoRA scheme, where the LoRA A and B matrices are also decomposed using two small trainable vector parameters.

egnehots··on A Technical Dive into PostgreSQL's replication mechanisms
There was recently a very interesting overview of the different distributed PostgreSQL architectures:

https://www.crunchydata.com/blog/an-overview-of-distributed-...

egnehots··on How Open ID Connect Works
No, it can indeed be vastly simpler to handle auth. But you have to consider many complex aspects to provide a simple solution:

- What are your real use cases (authentication, authorization, delegation?)

- What is your threat model? (avoiding silly mistakes, preventing corporate espionage, defending against targeted attacks require very very different solutions)

- How to integrate into your ecosystem (tech stack, actors, layers..)

Then you might be able to remove some constraints. You might not need authorization delegation, stateless and readable json tokens.

But often it's easier to not think too much about it and just use "an industry proven standard", and that is oauth2 and OIDC:

a large auth umbrella to avoid looking at the sun.

egnehots··on Subject-First Commit Messages
there are pros and cons to both verb-first and subject-first commit styles.

verb-first commits can be organised in a few categories. since they are few commit verbs (fix, add, refact..), always use the same verb prefix for bug, features messages and you will have nice categories to scan/filter:

- add feature

- fix bug

- refactor logic

On the other hand, subject-first indeed put the important part first and let you search for a term:

- Instance configure template method called from constructor

- Store's project method is an alias for fetch

- Title is changed

Depending on the use case, are you often searching for something? or would you like to highligh the nb of bugs/features in the last release?, one style is better suited than the other.

For important changes, I like the linux kernel style: oneline summary, details (problem, impact, solution..)

https://docs.kernel.org/process/submitting-patches.html

egnehots··on Demand the impossible: Rigorous database benchmarking
interesting but not very practical?

let's take the max_wal_size parameter for ex.

for most systems it's much simpler to set the max_wal_size to a value high enough that its value does not put pressure for checkpoints under load.

so get enough free disk space, allocate maybe 5%. look at the logs, increase the value if checkpoints are required.

(the downside is that crash recovery will take longer since it will read the wal)

egnehots··on Why does musl make my Rust code so slow? (2020)
Yes, but on the other hand, people who don't care can create huge images (especially in Node.js and Java ecosystems) that slow down CI and have a large attack surface.
egnehots··on Efficient Transformer Knowledge Distillation: A Performance Review
This paper combines knowledge distillation and efficient attention mechanisms.

=> It works (still efficient, lower cost).

Not an unexpected result, but to their credit, they established a new benchmark to test these combinations. KD+LongFormer is one of the best ones, retaining 95.9% of the performance for 50.7% of the cost.

egnehots··on Nicotine (2016)
I'm concerned that many might miss the nuance and subtlety of the main issue:

- Nicotine IS really addictive when distributed through common uses (smoking, vaping).

Yes, if the absorption is progressive and in small dosages, the addiction is less severe, but this is not useful for smokers who want to quit and presents a dangerous introduction for others

egnehots··on Why Async Rust?
The tokio ecosystem is also a world of its own.

Tokio internals are plentiful and more complex than in other runtimes. But the common difficulty is choosing what to use for an http server.

- hyper? just an http library but bring your own boilerplate?

- actix web? it was quite opiniated and there was some drama from its main author.

- axum? wait that seems to be the latest consensus actually.

And that's just the remaining popular choices.

egnehots··on Why Async Rust?
As a Rust user, I have to say that it was an incredibly confusing feature.

Not because of the technical decisions behind async/await, but because of the async ecosystem, especially the runtimes.

Picture a Rust user when the feature came:

- You can use it with future combinators!

- No, actually, use it with a macro library that almost works but not really.

- Here is Tokio (with a lot of moving parts).

- Wait, async std is much simpler (again, almost seems to work but not really).

- Wait, here is Smol, which is truly simpler (or at least smaller but not used).

=> You get "async fatigue."

I can understand the position: let's not commit to anything before seeing what sticks on the wall.

It might have worked for Serde (even that is debatable by some).

But as a user, it's hard to follow, and you get the impression that this feature is not the stable foundation you can build on.

egnehots··on GET3D: A Generative Model of High Quality 3D Textured Shapes Learned from Images
you are barking on the wrong tree, nvidia labs have a history of releasing their codes and models quickly.
egnehots··on Rust 2024 the Year of Everywhere?
as a library user, I dread proc macros since they are often associated with slow, long compile times.
egnehots··on Discussion: structured, leveled logging
Prior Work

- The existing log package has been in the standard library since the release of Go 1 in March 2012. It provides formatted logging, but not structured logging or levels.

- Logrus, one of the first structured logging packages, showed how an API could add structure while preserving the formatted printing of the log package. It uses maps to hold key-value pairs, which is relatively inefficient.

- Zap grew out of Uber's frustration with the slow log times of their high-performance servers. It showed how a logger that avoided allocations could be very fast.

- zerolog reduced allocations even further, but at the cost of reducing the flexibility of the logging backend.

- All the above loggers include named levels along with key-value pairs. Logr and Google's own glog use integer verbosities instead of named levels, providing a more fine-grained approach to filtering high-detail logs.

Other popular logging packages are Go-kit's log, HashiCorp's hclog, and klog.

egnehots··on StyleNeRF: A Style-Based 3D-Aware Generator for High-Resolution Image Synthesis
that's weird that they mostly ignore the comparison to stylegan3: https://nvlabs.github.io/stylegan3/

it's not a nerf based solution but since the goal is high resolution image syntesis..

egnehots··on Learn Rust by writing a small OS
not really, it's an excellent book but focused on Rust. I liked the fact that it explains the memory layout of common Rust data structures.
egnehots··on GCC Rust Monthly Report – October 2021
I know it's very early, but I wonder if the compile times could be faster with GCC Rust?
egnehots··on RenderingNG: Ready for the next generation of web content
Yeah, but don't forget that's just the first post in a serie.

Let's hope that the next post will have more meaningful technical content..

egnehots··on Gio – write immediate-mode GUI programs in Go
really the major pain point is more the lack of cross platform APIs.
egnehots··on Where Everything Went Wrong: Error Handling and Error Messages in Rust (2020)
for exploratory coding you can also just unwrap, assert, panic.. It's useful to remember that error handling is optional in those cases :)
egnehots··on Memory access on the Apple M1 processor
TLDR: he is using a random index with a big enough array
egnehots··on YouTube-dl's repository has been restored
Thank the EFF for their letter: https://github.com/github/dmca/blob/master/2020/11/2020-11-1...

They explained why the DMCA has no grounds.

egnehots··on Interview with Zig language creator Andrew Kelley [video]
Rust supports a global custom allocator.

Per container allocators are on the roadmap : https://github.com/rust-lang/rfcs/blob/master/text/1398-kind...

egnehots··on Show HN: A frame by frame GIF editor with Photoshop vibes
Does anyone know a good real gif editor which show you advanced gif options? such as per frame delay, left, top offset..
egnehots··on Revery – Native, high-performance, cross-platform desktop apps
Every GUI library should have some screenshots..
egnehots··on Announcing Rust 1.28
Global allocators are nice, but what would be really helpful in some performance intensive applications is to specify an allocator for a collection.
egnehots··on What is Rust 2018?
I thought, yeah that's just feature gated stuff. It's just marketing but my code will break even if I don't use the new edition because my dependencies will use it.

Turn out that it's false. What's amazing is that the compiler ensures that projects using the legacy edition can still use libraries relying on the new edition.

that if you’re using Rust 2018, you can use dependencies that use Rust 2015 with zero problems. If you’re sticking with Rust 2015, you can use libraries that use Rust 2018. It all works together

That's great!

egnehots··on Rust programs versus Go

  simplicity

  source      brain load
  Rust        95%
  Go          23%
← PreviousPage 2 of 3Next →