skysight-inc/HackerNews huggingface dataset:
This sort of attitude ignores the fact that a lot of people would rather spend time designing things and prototyping, rather than fix their printer.

I had the experience of getting and assembling a Prusa MK3 kit for myself, and getting access to a cheap Chinese printer at roughly the same time.

The Prusa cost more than twice as much and I've already made upgrades. Worked correctly right after assembly. I've already gone through several kilos of successful prints. And the frills just make it so much nicer to use: spring steel bed, auto mesh leveling, the Prusa fork of Slic3r just keeps getting better and better.

The Chinese printer required you to attach the gantry to the bed. But after weeks of tweaking. It still doesn't work correctly. It's completed prints. But none of them have been of decent quality. Now, some of the Chinese printers appear to be good. But do yourself a favour and research the specific models if you want to buy one.

Otherwise, if you really care about designing and prototyping, spend the extra cash and spend more time making things. There are a few brands out there. I reckon Prusa has the best kits if you swing that way.
Yes. Thank you for this post - this was exactly the sort of thing my comment was referring to.
Probably lack of generics?
Thank you, I know. Though I need to build ScalaJS (and I have one small Scala Native) project. This is a total no-go for Bazel. Unfortunately.
I have already lost hope for Apple. I'm just hoping they don't make things worse and just keep the quality as is but this seems optimistic too. Maybe in 5 years, Linux gets bit better when Mac is finally crap as a whole.
People can, and frequently do, make distinctions between nations and states. Hence the term "nation-state" to refer to those nations which are also states. If there wasn't a distinction, the combined term wouldn't be necessary.
I was not advocating that gross corporate income be taxed. I was pointing out that your statement: "for a C corp each dollar of income is already taxed at the corp level", is flatly untrue.

A lot of large corporations get their net income down to zero or next to zero, deliberately pushing their business strategies to bolster their stock price rather than net revenue. In those cases, capital gains tax is the only tax paid on their activities, and the advantage of capital gains tax rates vs ordinary income rates is by no means collapsed.
No way, maintenance of a system , especially a critical system, is much much harder than building from scratch.
No info whatsoever on where you get revenue data... you'd think that might be the first thing you address?
the story also goes that, since he was only given milk and bread while in solitary confinement, he would make inkwells out of bread, in order to write with said milk. I can't remember off the top of my head what he used as a writing utensil.
Interestingly, the type of `x` actually does matter here in Rust! For most types, yes, passing something by value into a function will cause the memory to be "moved", which means that reusing `x` will be a compiler error. That being said, you can also either pass a shared reference (i.e. `&x`), which will allow you to access the data in Rust (provided you don't move anything out from it or mutate it, which would cause a compiler error) or a mutable reference (i.e. `&mut x`), which will allow you to access or mutate the data in `x` but not take ownership of it (unless it's replaced with something else of the same type).

However, a few types, including integers, but also things like booleans and chars, implement a trait (which for the purposes of this discussion is like an interface, if you're not familiar with traits) called Copy that means that they should be implicitly copied rather than moved. This means that in the specific example you gave above, there would not be any error, since `x` would be copied implicitly. You can also implement Copy on your own types, but this is generally only supposed to be done on things that are relatively small due to the performance overheard of large copies. Instead, for larger types, you can implement Clone, which gives a `.clone` method that lets you explicitly copy the type while still having moves rather than copies be the default. Notably, the Copy trait can only be implemented on types that already implement Clone, so anything that is implicitly copied be can also be explicitly copied as well
It won't compile, because the compiler keeps track of where you moved the value and notices that x now has no value. If you want the function to borrow the argument instead, make it take a reference, &x.
Generally I think people tend to underestimate how quickly life arose on Earth but underestimate how quickly it took for life to turn into complex life. Just judging from how things went on Earth we should expect cemosynthetic life to be relatively common but photosynthesis to rarely arise, much less eukaryotic cells or multi-cellular animals. I drew out a timeline comparing how long it took various stages of life to arise on Earth versus how long it took Mars to lose all its surface water. Even on Earth we humans didn't arise until relatively close to when the expanding Sun will render the surface uninhabitable.

http://hopefullyintersting.blogspot.com/2019/04/how-likely-i...
You'll get a compile-time error explaining the situation, yes, including documentation links and possible fixes. The differences between the versions are minimal.

fn add1(x: Thing) -> Thing {
x + 1
}

fn add2(x: &Thing) -> Thing {
x + 2
}

This works on the assumption that whatever "+ 1" really means doesn't itself need ownership of x, e.g. because it mutates it. If it does, then you'll get an error. Or you could do this:

fn add3(x: &mut Thing) {
x.add(3)
}

Which, presumably, modifies x instead of returning a copy. It's your job to make sure it makes sense to do that, but Rust has another trick in its pockets:

let y = add1(x); // Works; takes ownership.
let z = add2(&y); // Works, and doesn't take ownership.
let zz = add2(&y); // So you can do it twice. (Y tho?)
let h = add3(&y); // Compile-time error!
let hh = add3(&mut y); // Works. You need to specify that you're fine with y being mutated.
> I think it's problematic because it creates perverse incentives to make more criminals.

We have this issue all over the US. Private prison contracts often have a "minimum filled cell" clause that causes penalties to the city/county/state if there are too _few_ people incarcerated.
I have 3M PELTOR X5A Ear Muffs. I use them all the time, from getting a snooze while my car charges, to working in louder than necessary cafes, to getting decent if slightly uncomfortable sleep in a hotel. They're $31 delivered from Amazon. It amused the hell out of me that I had to click through an agreement saying I was a profession. I am a professional.

Since these are 31db ear muffs, they're heavier than something with less protection. These are over the head model and I may get the X5B behind the neck model. Harder to get though. Not on Amazon.

I tried noise cancelling headphones. When they work, they're great. But anything unusual and I'd get feedback. Dumb ear muffs work all the time plus they're super ugly and so people leave you alone.

I don't understand why noise cancelling doesn't recognize it's in feedback.
This is where we’re feeling the real harm of fossil fuels, I think. We quickly moved from traditional energy levels to astronomically more energy just by burning oil and coal. We can lug around freight with relatively small amounts of fuel. We could do even more astronomical feats with nuclear fission, but introduced the technology to ourselves by blowing up two of our cities. So it’s associated with mass death meanwhile the death associated with pollution and fossil fuels are less visible.
If add1 takes ownership of the argument, yes (and x is not implicitly copyable).

Compare with C++, in particular types with deleted copy operators (e.g. unique_ptr<T>). In order to call a function that takes an unique_ptr by value as argument, you must explicitly move the object into the function:

void foo(unique_ptr x) {
...
}

unique_ptr x = ...;
foo(move(x));
foo(move(x));

Linters (i.e. clang-tidy) can be configured to complain about this, but it's completely valid C++ (because move leaves the object in an unspecified but valid state). In Rust, the argument will be automatically moved in the first call, and the second call will generate a compile-time error.
Even more troublesome, IMO. This as a gate to interviews leads to a really uninclusive hiring process.
I wonder if the author would have a more positive impression of Go 2, which is planned to ship with generics...
Burn money brute forcing. How else would "non intelligent" organization accomplish?
It used to be at the end of the block, which caused all manner of annoyance. So they spent a lot of effort improving the borrow checker, and now it's 'after last use'.

It's not just a matter of memory use. References and mutable references form a sort of compile-time read-write mutex; you can't take a mutable reference without first dropping all other references. See https://stackoverflow.com/questions/50251487/what-are-non-le... for more.
Informed? Did you see the guy with a full on explanation on how basic physics work got shat on by people who claim the shoe 'rebound 2 or 3 times higher than other shoes'. You literally can't communicate with toxic people like that.
Siraj Raval found plagiarizing “neural qubit” paper
that's a weird criterion. market cap has little to nothing to do with it. I don't think it's reasonable to be mad at anyone in this particular situation - we all knew that 32-bit was going away - but there are certainly other reasons to be disappointed by both Apple and Adobe separately.
Of course. The most successful businesses are ones that give people what they want. The same goes for how you treat your employees.

It's why slavery is hopelessly unable to compete with free markets.
Sealand is an incredibly interesting story. I absolutely love it. Hopefully I hear more about what comes of sealand.io
“Users” don’t know what CarbonLib is. When Apple announced that they weren’t porting CarbonLib, developers knew.
The Ironies of Democracy and Freedom
8 bit software still works.
The entire game is exploiting those who lack the critical thinking skills to sufficiently fact check themselves.

The median IQ is 100.
That could be a great and passionate discussion over a beer with snacks and pizza. But since we are far removed (on the "internet") I'll just say that socialists tendencies are extremely destructive long term in complex economies/countries. My arguments are a nagging, somewhat harsh (maybe annoying), nudge towards research and unbiased conclusions about the matter. Unless you are a running "democratic" politician, you should get the gist.
Slightly less crippled. One can keep the performance and feature comparisons going for a while.

Go shouldn't be Rust. We already have Rust. Though while I say that, I'd still hate to have to use Go.
Does that domain actually exist, and what does it host? (I don't want to check right now for obvious reasons).
You should expect it to work, naturally. But if you make an environment change (eg upgrade) well, the softwares expectations have changed so your expectations should change too.
With the trade deficit as large as it has been for decades, America never had China.
Please state the alternative.
> Difficulties increase the nearer we come to our aim.

The first 90% of the code accounts for the first 90% of the development time. The remaining 10% of the code accounts for the other 90% of the development time.
Consider the following code:

fn add1(x: Vec<i32>) -> Vec<i32> { // Takes ownership
return x.iter().map(|&x| x + 1).collect::<Vec<_>>();
}

fn add1_borrow(x: &Vec<i32>) -> Vec<i32> {
return x.iter().map(|&x| x + 1).collect::<Vec<_>>();
}

The first will take ownership of the thing you pass in, so you can't do something like this:

let x = vec![1, 2, 3];
let y = add1(x);
let z = add1(x); // error[E0382]: use of moved value: `x`

but the follow code is OK, because the function just borrows the value instead of owning (and destroying) it:

let x = vec![1, 2, 3];
let y = add1_borrow(&x);
let z = add1_borrow(&x);

This is legal too:

let x = vec![1, 2, 3];
let y = add1_borrow(&x);
let z = add1(x);

but as before you can't use x after this.

(Note, I chose Vec here because Vec does not implement Copy: if I used i32 it would just copy the value in the non-borrowing case, which would make the code fine as no ownership would be transferred.)
I'm curious about those who use a monorepo with microservices: how do you solve CD/CI? Is Bazel the only solution?
I'm in NY, and the gas & electric company is National Grid, and they do give you the option of choosing a supplier.

I've always thought that there must be hidden pitfalls of selecting a different supplier, since National Grid would have the ability and incentive to tilt the playing field.
Price seems totally reasonable to me. Whenever I research the cheaper printers, I read about all the upgrades people have to implement. This ends up costing more time and $$.
I use Howard Leight’s Max every night during sleep to keep my sanity.
Or, he chose to go with the software he had bought instead of moving to Adobe's new model of software as a service, where you pay a subscription fee plus an up front cost to use their software. It isn't so easy as "choosing not to upgrade to 64 bit" when the production company makes untenable demands. At this point, it's almost better struggling through with GIMP and Inkscape (almost) than dealing with the corporate hellscape that Adobe has become.
Noise isolating ear tips or IEMs for listening to audio are another great option if you want to maybe sacrifice a little bit of comfort for wonderful audio reproduction and probably portability/convenience.
Yes. The difference is that here the operation represented by putting wires next to each other is the direct sum, whereas in the Penrose notation the operation is the tensor product. They're both examples of the string diagram notation for monoidal categories. (https://forum.azimuthproject.org/discussion/2335/lecture-73-...)
> If yes, why shouldn’t adobe maximize their profits with a subscription based business model? It’s the market baby.

It's inefficient. You should get a good if its marginal cost is below its value to you. If Photoshop is worth 550 to you, the marginal cost of a copy is neglible and Adobe charges 600 €, you don't buy it and the market just threw away 550 €.

That is partially justified in that the business somehow has to finance the actual development and other fixed costs, and we don't have a much better mechanism for that yet. But preventing someone from using software because they can't afford someone's profits is just pure waste.
Fail as in it won't compile, not as a runtime error
As I understand it, most large universities have something like this. At smaller schools it might be less formal. Where I went to college, the students were expected to have their methodology approved by the "stats guy" in the department.

As for programmers, it's not just a matter of cost. Most scientists don't understand software engineering, but most software engineers don't understand science or math. Also, programmers who belong to their own organizational structure can't keep up with requirements that could change from one hour to the next. Despite "agile," realistically most software development is comfortable with timelines of months or years.

Don't get me wrong, I'm an R&D scientist at an industrial business that makes commercial software. The programmers are brilliant, and the software they make is amazing. But I have no choice but to be self sufficient for my own software needs in R&D. It's two different worlds.
The Author point to [1] for reason for Raku instead of Camelia.

One thing that struck me,

12. Both raku.com and raku.org are currently available.

I was surprised that a 4 letter .com or .org is still available. So I looked it up and turns out to be not true.

And it was interesting half of the discussion had domain name availability as factor.

[1] https://github.com/perl6/problem-solving/issues/81#issuecomm...
The multi-repo pattern certainly meshes well with Amazon's team structure, and of course integrates well with the build system and deployment system, given that they were created around it. But "handling it pretty fine" seems like a stretch.

When last I was there things were finally beginning to burst at the seams. Platform architecture migrations were failing or being abandoned over too many untracked dependencies on specific versions of platform-provided libraries. (RHEL5, anyone?) Third-party had become a jungle of unmaintained libraries with dozens of versions that nobody ever upgraded, that may or may not have security vulnerabilities or known bugs, and many teams hadn't released new versions of their clients/libraries into Live for years in fear of breakage. The Builder Tools team was talking about giving up and abandoning both Brazil and Live as unsalvageable. Framework teams (Coral) were throwing their hands up in the air about how Coral-dependent services would not be able to upgrade to Java 11 without fixing a bunch of breaking changes that they would never agree to fix. The solutions being proposed to these problems by the Builder Tools team looked a lot like moving toward a monorepo, at least conceptually.
Show HN: Opentelemetry Perf – Annotating Spans with Perf
It used to, they got subtler. See https://stackoverflow.com/questions/50251487/what-are-non-le...
> Let's face it you are cheap,

Or, hear me out here, some people can’t afford to buy new Adobe software because it’s ridiculously expensive. They’re not wealthy enough to call themselves cheap.
Actually, it may well have been a dark pattern. Did you go to Amazon via an affiliate link? I believe that Amazon pays a lesser commission on smile orders than affiliate linked ones.
Not quite. Skinner calls the mind, will, ego, and the like explanatory fictions, because they are supposed to explain something but fail to explain, for at least two reasons (criticisms of mentalism): autonomy[1] and superfluity[2].

He does not deny their existence, he just deems those explanatory fictions impractical to focus on (see the two criticisms below) and that they are not a necessity or a requirement when it comes to observing and modifying behavior. Radical behaviorists take the pragmatic approach.

The definition of "cognition" in the context of behavior modification is "covert verbalizations and imagery; frequently called believing, thinking, expecting, and perceiving". Its existence is not denied by radical behaviorists.

> An important aspect of Skinner's approach is that he rejected the distinction of a mental world that is separate from the physical world (which is mentalism, a form of dualism). Thus, although he accepted that private speech and covert images exist, he regarded them as being no different in principle from public speech and overt acts of seeing. Moreover, like Watson, he emphasized the importance in a science of behavior of studying the effects of the external environment on overt behavior.

In any case, to clarify, I am not trying to say that cognitive-behavioral therapy = radical behaviorism. What I am saying is that Skinner's conditioning theories (along with Watson, and radical behaviorism in general) had a foundational influence over the development of cognitive-behavioral therapy. It greatly influenced both the development of behavior modification and cognitive-behavioral therapy.

I really recommend the book I mentioned above, along with this one: https://www.amazon.com/Behavior-Modification-What-How-Do/dp/...

You might want to check out the differences between the behavioral approach and the psychodiagnostic approach. They have different goals, methods, and so forth, but they are supposed to work together. :)

---

I apologize if my comment raised more questions than provided answers, but this subject is really really broad and I would even dare to say complicated. If you are really curious then you should probably read the two books I mentioned (at the very least).

---

[1] The capacity of a thing, particularly an organism, to behave. When a hypothetical entity, such as mind, inner self, or an inner homunculus, is said to act so as to cause observed behavior, the supposed autonomy obstructs inquiry by diverting study to the impossible task of explaining the behavior of something that cannot be observed.

[2] Mental causes only restate the original observation in more obscure terms. When mental causes are inferred from the behavior they are purported to explain, the supposed "explanation" is purely circular, is superfluous, and impedes efforts to find an explanation based on natural events.
The church bells create a very regular cacophany from seemingly every direction however, at least here in Switzerland (can't speak for Germany). This seems to be much less common in the US.
Oh yeah, I'm definitely not providing the definitive or original account, just throwing out a decent overview for anyone interested in more details.
Why this episode OP? IMO the proof of fullness is quite belabored. In fact the very next episode gives a much better one-page proof in the section starting "Here’s what we mean by this rather cryptic remark". It's faithfulness that's more interesting, ie. are the graphical rules sufficient to prove that any two diagrams that produce the same outputs given the same inputs are equal, ie. is the list of graphical rules complete?

A string diagram is also equivalent to a program in a generalized-stack language (in the stronger sense of equivalence up to difference in the topological arrangement of the wires, not up to the full graphical rules). Unlike a pure stack language, you can operate on values at any point in the stack, not just the top. The four operations are: drop an element from the stack, push a zero to the stack, remove two elements from the stack and push their sum to the stack, remove an element from the stack and push two copies of it to the stack. Obviously any program in this language computes a linear function of its initial stack (there is a full homomorphism to matrices). A stack language captures the same ability of an input to be consumed that a string diagram does.
And it’s happened on the Windows side, too.

You can’t just run transport tycoon, rollercoaster tycoon, or xcom without any sort of modification on Windows 10. You’re either using an open source drop-in game engine or a packaged DOSBox setup from Steam. Or in the case of Rollercoaster Tycoon, a rewritten game (RTC Classic).

Windows 10 doesn’t run 16-bit applications, and Windows 10 doesn’t work nicely with a large amount of Windows XP era software.
https://github.com/idris-lang/Idris-dev/blob/5965fb16210b184...

Idris is not a Lisp and I've never used it, but it has dependent types (types incorporating values) and encodes matrix dimensions into the type system (I think only matrix multiplications which can be proven to have matching dimensions can compile). I think the dimension parameters are erased, and generic at runtime (whereas C++ template int parameters are hard-coded at compile time). IDK if it uses dependent types for optimization.