skysight-inc/HackerNews huggingface dataset:
That's what my company has done. We have a microservice-like architecture, but discourage dependencies on other services. If we need to use one service in another, we use dependency injection (which allows us to switch out the communication protocol later if need be) or talk over a message bus instead. The idea was that we would figure out later which sub-services actually need to be split out based on usage.

AFAIK, we haven't actually split out anything yet after all these years. All of our scale issues have been related to rather lackadaisical DB design within services (such as too much data and using a single table for far too many different purposes), something an arbitrary HTTP barrier erected between services would not have helped with at all.
UK Supreme Court Rules Uber Drivers Are Workers Entitled to Benefits
I don't see how the choice here can promote STEM.

Do you think kids find it sexy to talk about meters, kilograms and degrees Celcius rather than feet, miles, pounds and Fahrenheit?

I can't fault for choosing what is more understandable to the target audience.
You know, it's not OK to be racist, so I'm not sure why you are proud of self-identifying as such. It's not OK even if, as you claim, you grew up with a silver spoon. You know what's in your heart of hearts, so please work on whatever it is that you identified in yourself that makes you hate others for things that they cannot control.
This is a really nice write up and it sounds like you’ve built a solid foundation for the product longer-term. Nice work.
Uber drivers are workers, UK Supreme Court rules
edit: Nah, I'd rather we go back in time and not normalize draconian, authoritarian restrictions on everyday life.
Because all systems try to handle several kinds of unexpected behavior in the exactly the same way
- invalid arguments (e.g. 'x == null')
- code logic (e.g. 'if (x.salary < 0) ...')
- external errors (e.g. 'out of memory')

I'd argue that only the 3rd kind is actually 'exception', it's completely out of program's control.

Code contracts are wonderful way of dealing with 1st and 2nd kind, sadly they didn't catch up and remains mostly unknown. They are vastly superior to tests and also serve as much better way to document intent of the code, how the author expected the code to work.
You can attach context to the errors though.

It's only really a pain when writing libraries as you have to be so specific about your error types, etc.

Overall, it's probably still the "least bad" option compared to other languages' approaches (both Go and Python are painful for this for example). But it can be a lot of extra work sometimes, especially when just working on the first basics of a library crate.
https://devblogs.microsoft.com/cppblog/addresssanitizer-asan...
> The vertical farms that have been commercially active for several years all focus on the same crops. These are agricultural products with a high water content, such as lettuce, tomatoes, cucumbers, peppers, and herbs. However, these are not crops that can feed a city. They contain hardly any carbohydrates, proteins, or fats. To feed a city, it takes grains, legumes, root crops, and oil crops.

They may not "feed a city" in a raw caloric/survival sense, but they're certainly consumed in cities and if that continues to be true, they'll be grown somewhere.

The question shouldn't be "can we grow subsistence crops vertically?"

Rather, the question is whether vertical farming can provide any crop more efficiently along any of several axes (and at sufficient scale for us to bother talking about). If something can be usefully grown vertically, netting us realizable gains in terms of cost, land use, freshness, price, carbon, or some other metric, then by all means, why not?
I love the aesthetic, but not so much the fixed width design.
At this point I'm quite happy with error handling in Rust. I just wish the backtrace member on the error trait was not nightly only and we had the ability to attach backtraces to errors.
The tree structure is inherently flawed for storing undos when using features like undoing within a specific region, because the new state doesn't map to any previous node on the tree.

By default, Emacs has a linear undo structure, while still allowing you to never lose history.
What? Did I miss a memo or something? I would have hoped to get an actual answer to my question instead of rhetorical sighs (and downvotes). Note: I am not a native English speaker.
Does each microservice/module have its own db?
It would be nice if you can move your existing C codebase piecemeal towards a more safe standard using linters and compiler checks. Because projects with a lot of legacy (mostly C) code (which means all popular operating systems) cannot be rewritten towards safer languages without having an additional motivation like features that have a meaning to the business. So most likely a lot of it will stick around for a very long time but still needs to become 2021 level secure.
I am running a program called Insiders' Updates - which emails sponsors each week and gives them access to a portal, to get recurring revenue and offer more value.

https://github.com/sponsors/alexellis/
https://github.com/sponsors/openfaas/

The "Treasure Trove Portal" has discounts, and updates since 2019 now, as a user of openfaas or any of my software, there's definitely value here that shouldn't be passed up.

The weekly features are not about my OSS projects, but about the industry, marketing, business and Open Source - so that there's something for everyone.

The comment about companies not using open source is not really valid, them not valuing the time of maintainers would be more accurate.
You make the argument against locking devices (which I agree with) for reasons related to that not deterring theft - which has a point.

Thieves will not profile a person using a premium locked phone against stealing it because it might not be worth it. They don't care about that. They will take whatever they can if only for practicing their skills.

Locking phones does not deter theft but unlocking them will offset the price of unlocking from the phone-shop to the thief increasing the profitability of theft.

I personally don't care about Apple, their phones, their M1's and their ecosystem. But acting out your premise leads to a place I don't like. And others as well. And if you think you can buy a cheaper premium phone if it is unlocked, ask yourself why thieves would continue to sell you cheaper if they know they give you a usable device?
Why not work on some very small machines that can mine and refine materials to make more of themselves?
I question the value of the comment of someone who loads css but not background images.
Solving problems that don't exist so you can sell inventions to people with more money than sense. Yay.
Another way to do it:

https://www.digitalmars.com/articles/C-biggest-mistake.html

i.e. just change:

void foo(char* a)

to:

void foo(char[] a)

and that passes a phat pointer (pointer and length) instead of just a pointer, enabling array bounds checking.
>Have you been to Switzerland?

Yes, I live in Switzerland.

Is it more expensive to go to a restaurant than in America? Yes, sure, but at least the people working there can have a good quality of life and don't rely on tips to pay rent. Prices of things that involve service are higher, true, but wages are good enough here that you can still live really well.

Maybe the average person can't afford to eat out every day of the week, but should they be able to? I feel like this is only possible if you underpay service staff.
Top Man on the Saturn V
For a second I thought the title was about a developer that bought an M1 MacBook Air and realised he or she liked the Touch Bar after all.
Ahh, if only more companies would be like Fairphone! I'd love to buy a phone from them at one point.

Thanks.
The Analytical Workflow Is Broken
I just wanted to know how it would compare with Sanic, because I never used it.
In terms of control flow, this:

try {
someCall();
} catch (ErrorICanHandle err) {
//handle
}

perfectly equivalent to this:

err = someCall();
if canHandle(err) {
//do something
} else {
return err
}

I don't see why so many people think exceptions make code harder to analyze. In my opinion, it is errors themselves that make code hard to analyze, regardless of implementation strategy.

The only difference between exceptions and error returns/error codes is in human readability: one makes the bubbling behavior explicit, which clutters the code but makes it obvious; the other makes the bubbling behavior implicit, which keeps the code cleaner, but also less obvious.

After writing professionally in both languages with Exceptions (Java/C#/Python) and in Go, I much prefer Exceptions to error values/codes, but I can appreciate that it may be different in other domains or for other people.
How to be more productive without forcing yourself
For predicate pushdown in S3, I'd see that operation in the SSD controller. You wouldn't even have to load the date in RAM before filtering it.
Open-source macro keyboard with E-Ink display
The most common time this comes up for me is trying to use continue/break if a value is None/Err :

loop {
let thing = match foo() {
Some(bar) => bar,
None => continue,
}
}

Yet I still always first try to put the continue in an unwrap_or_else first..
> From what I can see fission reactors are doing just fine in France and Belgium.

They aren't, France has had nuclear for geopolitical reasons, not primarily economic ones. And now that these plants are old, they won't be replaced with new ones (save 1 big project that is already way over budget and won't be price competitive once it is live).
guilty on the latter. tho only contributors to my packages and coworkers complain about it. I am fine with it.
Modular First.

You start out as technically a monolith, but that is prepared at all times to be decomposed into services, if and when the need arises.

It's nothing too fancy - can be simply another name for Hexagonal Architecture, functional-core-imperative-shell, etc.
AGPL?
Hahaha. I have been saying the same for years but have either been punished by my managers or mercilessly downvoted on HN.

Somehow mentioning that microservices might not be perfect solution in every case triggers a lot of people.

I have actually helped save at least one project in a huge bank which got rolled from 140 services into one. The team got also scaled down to third of its size but was able to work on this monolithic application way more efficiently. Also reliability, which was huge issue before the change, improved dramatically.

When I joined, I have observed 6 consecutive failed deployments. Each took entire week to prepare and entire weekend to execute (with something like 40 people on bridge call).

When I left I have observed 50 consecutive successful deployments, each requiring 1h to prepare (basically meeting to discuss and approve the change) and 2h of a single engineer to prepare and execute using automation.

Most projects absolutely don't need microservices.

Breaking anything apart brings inefficiencies of having to manage multiple things. Your people now spend time managing applications rather than writing actual business logic. You have to have really mature process to bring those inefficiencies down.

If you want to "do microservices" you have to precisely know what kind of benefits you are after. Because the benefits better be higher than the costs or you are just sabotaging your project.

There are actually ways to manage huge monolithic application that don't require each team to have their own repository, ci/cd, binary, etc.

How do you think things like Excel or PhotoShop have been developed? It is certainly too large for a single team to handle.
For some reason I went in expecting either someone complaining about a UI redesign where a bar had been removed, or a former lawyer commiserating about being disbarred.
Indeed. The best description that I’ve heard of the process is “work out the hardware you want to exist to solve the problem, and then write the HDL code which will synthesize into that hardware”. In verilog/vhdl there are a lot of ways you can write the HDL which will give correct outputs but synthesize into hardware which is garbage (too big or won’t meet timing). You have to learn the specific patterns to write which hint to the synthesis tool what you would like it to synthesize.
You can do something like that

```
let x = Some(1);
let x = match x {
Some(x) => x,
None => return,
};

assert_eq!(x, 1);
```
“The fast fashion of building products”
> You can attach context to the errors though.

I'd say you should attach context.

If there's problems accessing a file, then having an error message without the filename in it is near useless.
We closed things down too late, this is pretty well understood.

The last lockdown was imposed when it was, essentially, because the powers that be wanted christmas retail open, and christmas day to happen, when cases were already massively on the rise. I'm not saying "it wasn't harsh enough", I'm saying that every time it's been done too late, and ramped up too slowly. It could have been shorter and well controlled had it been sooner, like it has been in other countries.

There's no need to be so incivil. Perhaps think about your own words.
> now everything has to be boxed [...] every access has an indirection, etc.

The article makes clear that it is speaking of compiler intermediate representations. Those are pretty much by definition boxed, linked data structures that live on the heap.

> Migrating some C++ code from OOP inheritance to variant-like stack-allocated value types has always resulted in n-fold improvements to runtime performance in my case.

Was this in the context of processing some form of programming language IR?
People are never just ONE type of awful. It's almost always a package deal.

See also https://blog.valerieaurora.org/2017/07/18/the-al-capone-theo....
> C strings, no matter how much people have complained about along decades (often quoting Pascal as a good counter-example!),

Because Pascal is a good counter-example to the awfulness of C strings.

I need to point to you that any strings in C is a potential buffer overflow. You can't use a string in C without introducing a potential security risk you will have to thoroughly check for. Ada gives you compile-time guaranties.

> C strings, no matter how much people have complained about along decades (often quoting Pascal as a good counter-example!), were simple and versatile and thus could stand all usages without a change in the base principle (so other string types never took off).

C strings are not so much versatile that they are not actually strings (as usual in C). They are raw byte arrays (in so much as you can C arrays arrays) with a special termination code and UTF-8 took care of staying compatible with this representation.
For the curious, it weighs 370 grams.. I just put it on my coffee scales this morning.

https://twitter.com/alexellisuk/status/1362710626385207297?s...

Thanks again for all the messages on Twitter - and to GitHub for this token.

You can find out more about my journey through the interview or blog post on my GitHub profile - or get weekly emails through GitHub Sponsors (another thing I appreciate about GitHub) - https://github.com/alexellis/
What "JetBrains hack"?
And I wrote this about the topic https://71lines.com/no-code-needs-code.
In Python this would look like sqlalchemy's query layer (which is great).
The answer to your questions is, hire competent SRE’s.
I take this same philosophy at all levels of my code.
It's like the big bang: start out with a dense hot lump of code and as it grows and cools off things break apart into subunits and become more organized, documented, standalone, etc.
People do say things like 1.25mm, which is 1/8th of 1 cm.

Presumably someone who uses Imperial would say 5/128th inches if they wanted to describe something that's equivalent to 1mm?
I'm pretty sure eyre[0] can provide backtraces in stable using `stable-eyre`

[0]: https://docs.rs/eyre/0.6.5/eyre/
Yup, I should have used a through hole part.

Power over audio cable felt iffy too - feels like it will short on insertion? Maybe it needs some thermal fuse in line with it or something.
> the compiler struggles to optimize them,

Nitpick: I'd say if you need the compiler to optimize exception handling you are using them wrong.

Exceptions are for exceptional circumstances.

(if you mean that exceptions mess up optimization of surrounding code that could be a bigger deal but I won't accept that without pointers to benchmarks$
>>As long as it’s serviceable, the amount of outstanding debt is kind of meaningless.

Serviceable now or serviceable forever? its not the same thing, and its the kind of thinking that convinces someone who just got a small bump in pay to go out and lease a new $800/month car because they can affords the payments today, or buy an expensive house at the top of the market, because in their opinion house prices only go up, and their job will only ever pay more - neither of those things are always true, and when the conditions change, they can change fast and have a huge domino effect.
I've not seen it mentioned yet so I'd be remiss not to link to undo tree [1] for vim. I tend to put my list of plug-ins on a diet over time, but undotree is one I always kept! Having a visual of the history (like in the article) make it much easier to do a quick back and forth through time.

Also for fun, consider having your scroll wheel traverse time instead of space [2].

[1] https://github.com/mbbill/undotree
[2] https://xkcd.com/1806/
Just hate these long form articles that takes forever to get to the point. They are designed to have your eye balls kept on page as long as possible as opposed to transfer maximum aloof information in given time.
Ramanujan Machine Redux
"Probably the nicest thing I have to say about the updated paper is that it is better than the original. My complaints about the tone of the paper remain the same, but I don’t think it is necessary for me to revisit them here."
There is actually a provisional timetable now: https://www.dailymail.co.uk/news/article-9267563/Roadmap-loc...
Join me and the co-founder of IndieHackers Channing Allen for a discussion
I will be talking with the co-founder of IndieHackers Channing Allen on the biggest Startup channel on ClubHouse (Startup Club 280k members) at 3:30 PST today February 19. We will be covering User Acquisition and Growth for Tech Startups make sure you tune in we’ve got some really cool insights.

In the pannels discussion, I will be joined with Soumeya Benghanem and my other partner Darko from ZeroToUsers.

Feel free to join.
> It always looked like a weird community to me (but that has indirectly to do with how Adacore conduct their business).

I don't know the community (or communities), but yeah, Adacore looks like a special beast. I saw a few discussions on their damn stringS, and lately a bit of discussion on array literals I believe, which left be rather sceptical.

I tried to use one of their languages, Parasail, and I couldn't. I tried to compile it, and failed, even after correcting a few layer of mistakes. Then I tried to use the binary, and only half of the proposed binary tools worked ; and I couldn't figure out how to use the working half to build/run a source file located outside of the compiler/interpreter archive tree...

And that was a version number 8.x, published after over 10 years of development... I just don't get it; I don't get how you can just dump something like that; I don't get how you haven't fixed problems known for years or that you'd encounter for sure if you only bothered to try to make a clean install on a fresh machine instead of dumping your working copy. Even getting the package was a pain for me, because it was hosted on a Google Drive (you don't even know it when you click because it is hidden behind a link shortener service! why? don't ask me), and none of the 3 browsers on my computer will display that damn site correctly, I had to fetch the package from another computer. Why can't they simply put their package on their webserver? It's not like it's ever going to be popular and generate lots of traffic with its single 50Mo zip :-)

I mean, I have zero love for the modern trends in development and methodology I meet a bit everywhere and which occupy a lot of threads and are often praised here, but this... this is extremely on the other end of the spectrum. It's like coming back to the bad practices of the DOS days (not even the good ones).
Uber has lost in the Supreme Court. Here’s what happens next
I've migrated a few big projects through several iterations of different error handling crates, which was always painful. For now I've settled on thiserror, but only until backtraces are stable - then it's back to the churn :)
And there are a lot of people, like myself, who do use vim regularly and somehow completely missed this feature. For those people the OPs post is excellent.

Likewise, if you have any recommendations for your preferred workflow I'm sure some will find it useful. Hopefully those who don't use your preferred $EDITOR don't then rush to complain that not everyone uses $EDITOR. ;)
The article is from 2015, so doesn't look like this had much impact!
This article is a very interesting example of capitalization on the Lump of labour fallacy.

Two examples made it very obvious:

1. there's only one diagram, and it looks catastrophic. the article is designed to give the reader the impression that there is a catastrophe going on, by hiding the counterpart (that is, jobs created in the meanwhile)

2. cleverly, what the article doesn't show, it describes, in ridiculous terms:

> from the point of view of, say, a 10th century farmer, over

> 90% of the jobs we do now are effectively made up–make-work

> stopgaps that simply prove, in the words of Mark Twain, that

> "civilization is a limitless multiplication of unnecessary

> necessaries."

so, 90% of the jobs that didn't exist in the 10th century are essentially... vanity.
Is anyone around who has implemented a substantial project in nMigen? Looking at the syntax it looks very unintuitive and awkward, mainly due to being shoehorned into Python syntax. Do the advantages of being able to metaprogram in Python outweigh the disadvantages of the syntax? (I’m comparing to a hypothetical HDL which is at a similar abstraction level but has a dedicated syntax and some other way of embedding metaprogramming)
Quick, how many miles is 26357 feet?

With metric it's a matter of shifting the decimal.

How much is a sixteenth inch anyways.
I'm surprised by your first line. In the UK it's been considered that a combination of the sea and weather has saved us on numerous occasions including with the Spanish Armada, the Napoleonic Wars and WW2.

"The waters of the Channel are notoriously treacherous, which could have posed problems for the smaller boats" -
https://www.bbc.co.uk/weather/features/52808043
We started operating our CNC machines remotely
Our first steps towards safe and remote machine operation
This topic is pretty close to flamebait so it gets downvoted would be my guess.
I just want to add. It's quite common in carpentry to work with 120cm base wood. Which devides just as nice. And even then it's easier to convert when moving into bigger or smaller units.
Went in with righteous anger at the title came out agreeing with the article. The main advantage of any pattern being a part of the language is the ergonomics of it. If you want to use the pattern in another language for whatever reason that's just as valid but obviously less straightforward.
I'm not sure where you got the second point from, certainly in my experience it hasn't been a bit issue with Haskell.

The third point is the same with just about every ecosystem in my experience, there are libraries written by big open source contributing companies which are completely dead as far as maintenance. I've even been bitten _this week_ by a JS library which is dead in the water.