erik_seaberg

A hundred inserts per second is going to hit 2^32 within a year and a half. I've seen that volume repeatedly. A colleague has seen this limit blow up prod. Do you really want to spend time on a project you're sure can never succeed to this extent?

I've touch typed since high school (on loud typewriters) and took up Emacs around 1989, but I think people are now less often generating complete chunks of code from scratch and more often refactoring existing code using awkward keybinds that didn't exist when they learned (or should have).

Very glad to see percentage-of-users experiments, that's where it falls short to simply deploy/rollback the new version.

Does every street have lamp posts? Mine only has a few power poles because they didn't bury the lines to the houses.

Thanks, I hadn't seen any of those names before today, not being an experienced embedded builder. I used to browse Radio Shack, Fry's, and Micro Center for breadboards and stuff, but they all shut down over time, as did Halted Specialties (before I heard about them).

The biggest hurdle is being unable to charge a street parked EV; step one is buying a house with a driveway.

https://mall.industry.siemens.com/mall/en/WW/Catalog/Product... seems like a difficult vendor, with no buy button and no price tag.

There may be competing products, but you can't go to a screwdriver shop today and buy quantity=1 to learn from, which vendors should have accommodated even at some substantial margin.

Milton Friedman allegedly repeated

“You don’t understand, Mr. Friedman, this canal is a jobs program to provide work for as many men as possible.”

“Oh, I see. I thought you were trying to build a canal. If you really want to create jobs, then by all means give these men spoons, not shovels.”

Didn't people used to get in trouble for "working from home" when they were actually parenting instead?

There's a very steep tradeoff between the approachability of a macro and that of its expander code. Look at Rust macro_rules!, or Scala macros, or Template Haskell. A formal grammar can define a strongly-typed deeply hierarchical data structure, but the code to drill in and map to a different deeply hierarchical data structure by hand seems to become a nightmare. Even Scheme hygenic macros are noticeably harder than "take a macro call as a list, use quasiquote to return a list that starts with PROGN" which makes it actually feasible (if risky!) to start cranking out macro expanders.

That's a lot more time and effort than should be necessary. You should have at least a week of food just to prepare for an emergency.

"Mongo DB Is Web Scale" is pretty entertaining: https://www.youtube.com/watch?v=b2F-DItXtZs

(https://news.ycombinator.com/item?id=1636198 linked to the original platform, which sadly shut down after a few years.)

Distributed systems don't have a single monotonically increasing clock, so designs should never assume that sorting them works reliably. A system should be benchmarked to check whether hotspots make an index faster or slower.

Base salary isn't as much as I would be vesting while building skills at a new employer.

(Who are Eathlicans? I find no search results.)

https://github.com/deckarep/golang-set offers a thread safety option and methods like contains all, intersect, and equal.

Mechanical sympathy now favors SIMD instructions and hyperthreads because sequential loops are slower even unrolled.

foo is receiving a mutable reference and it can't modify the map without those changes leaking out permanently to the caller: https://go.dev/play/p/DXchC5Hq8o8. Passing maps by value would have prevented this by copying the contents.

It's a quirk of C++ that reference args can't be replaced but pointer args can.

Throwing prevents the caller's control flow from passing into code that assumes a useful value was returned and ready to be consumed when it wasn't. Handling a success or a failure with exactly the same code shouldn't be a default because it almost never makes sense.

A Java exception can suppress stack trace init if needed, letting an instance be created once and reused very cheaply (though logs will be less useful).

Maps and channels and functions are passed by reference. Slices are passed and returned by value but sometimes share state invisibly, the worst of both worlds. It would make more sense if Go either made this stuff immutable, made defensive copies, or refused and required using explicit pointers for all these cases.

Big tech holds impersonal performance/promotion calibration meetings where written track records are debated, so this work goes unmeasured.

The era of a single machine is over. We need remote rendering for services on datacenter fleets without GPUs, so X11 is more often replaced by Javascript for a browser (with support for a user's local GPU) than by Wayland.

A production service is never done. You've realized less than 20% of the total cost in year one, and the payroll spend in years two through five will steadily increase as the team expands. Amortization spreads the front-loaded expense of building a factory out to the same timeframe as the revenue it brings, but software development expenses are slightly back-loaded if anything.

I'm reminded of a build break in Google web search because of a dependency on the self-driving car project. And that's how Bazel rules were given visibility lists.

At my university, "computer science" and "computer engineering" were under different departments, and the latter focused less on algorithms and more on embedded digital hardware.

I think each of these symbols represents where a command was defined (e.g., commands in square brackets came from POSIX.1).

https://landley.net/toybox/roadmap.html

It looks like the nu-ansi-term crate hardcodes escape sequences. It would be more reliable to use terminfo or termcap as the sources of truth for which ones the tty supports.

FYI I do see https://news.ycombinator.com/item?id=41007985, it's currently on page six (out of ten) of this megathread and it looks normal (not dead or flagged).

There's a long history of databases using a client-controlled timezone per connection (which defaults to the server's local timezone) and storing only local time. I wouldn't rely on seeing UTC unless the team is very careful about migrating legacy data and consistently using TIMESTAMP WITH TIME ZONE columns and functions.