skysight-inc/HackerNews huggingface dataset:
Breathing also produces greenhouse gasses. :( Considering only the costs without the benefits is not a workable approach to moral analysis.

What I think you could say is that writing inefficient code when it would be exactly as easy to write efficient code is immoral, assuming you derive no other benefit from the code being inefficient, and assuming you believe that global warming is likely to increase net suffering, and assuming your moral system values net suffering. But even then it's very marginal unless your code is being run on hecka computers.
cause lawyers cost money
> Mind you, a big plus, I think, is that Go doesn't have the ridiculous library ecosystem that others I've worked with (JS/Node, Java) have; I only use a handful of libraries at the moment (for REST api, .env file handling, database interaction and logging, and some additional ones for development like mocking, neat diffs for tests, and code generation (xsd & swagger to code).

I think this is a great selling point. Probably due to the stdlib being so extensive.
As a C, Go and Javascript programmer (nearly 10 years of experience with both of them), I really feel what the author is saying when they say there are too many ways to do something and fighting the compiler. There comes a point when the languages quirks start to eat into your productivity.

That being said, I have a feeling that the author lacks programming expertise to develop a language (I am not saying this in an offensive way). They are dodging things that are needed to build a language (memory management, choices of libraries etc.).
https://www.realclearpolitics.com/elections/betting_odds/201...

After seeing this, I lost some faith in the Election betting markets.
I agree, but those are different problems. they are related, but different.
What about all the ways that code has helped reduce suffering of others? If writing less efficient code allows people to iterate faster and improve lives then wouldn't it be morally wrong to spend years trying to write perfectly optimal code instead of solving imminent problems today?
It is funny that you mention human need for food. Hog is actually an inefficient food production method because they need to be fed more corn/soy etc than the food they produce.

If your goal was to make food more accessible to the poor then one way to go would be to stop this inefficient food production method and just consume the corn/soy protein directly. That would be healthier also. Consuming corn/soy directly would drive down the price of food because we would need less of it.
Not OP, but -

It doesn't have to be an either/or proposition.

* I keep my savings, checking, and loan accounts at a local bank, which also issues a debit card.

* I have credit cards from Discover and BoA, so that I get big-bank services for them.

The bulk of my value as a customer is tied to my mortgage, so my local bank, and possibly Fannie Mae, holds onto those profits.
No, only the ones I like ;)
Trade it for a cryptocurrency with stronger anonymity properties and then slowly launder that through a self-owned digital service that ostensibly accepts cryptocurrency payments or donations.
And now we have to watch the Bitcoin Cash and other forks too.
Dana Library Hand
TPB’s servers are running in Sweden last I checked, but the US still claims jurisdiction over them
Austrian economics doesn't actually deny the existance of natural monopoly. That is simply a wrong headed reading of Austrians by people who hate it.

If anything it says, natural monopolies exists, but some of the regulation designed to fight it, can be more harmful.

Austrians also try to not narrow down market so much, that monopolies are everywhere. Is Tom Hanks a monopoly on Tom Hanks, sure but does that matter. Is the market acting? Entertainment?

Just saying 'its a natural monopoly, therefore government need to come in with some strong handed specific regulation' is often a bad approach that can stop other mechanism from functioning. For example, locking in natural monopolies forever, even when future technologies means that monopoly would have been broken.
"The One Pollster in America Who Is Sure Trump Is Going to Win"

https://www.nytimes.com/article/trafalgar-group-poll.html
I'll have to check that out. I've been feeding flightaware since November 9, 2016 it would be nice to feed ADS-B Exchange as well.
I've been looking into this and couldn't find any studies or reports that showed any notable negative effect of particulate emissions by laser printers.
You're willfully misinterpreting the GP.

"Separation of corporation of state" should be interpreted in the same light as separation of church and state - using the state to clearly define boundaries and avoid interference on the state from the church (or corporations), not to give them autonomous and unregulated powers.

Citizens United gives corporations leeway to spend as much as they want to help elect officials and influence citizens' electoral decisions, thus inverting the power structure and reinforcing the de facto oligarchy. To separate, we need to regulate.
Anyone can pick up a HackRF and probably get away with skirting the FCC's ire if they're very careful about it. If they try to use it to develop a product that interferes with licensed RF and that they plan to sell, they won't get very far.

Similarly, some person in their garage won't be stopped from violating this law as long as they're careful about it. This law stops facial recognition products from being mass deployed and being made ubiquitous, though.

The same logic applies to someone cooking meth in their garage. They'll probably get away with it if they're careful, but good luck turning that into a legitimate business.
A single hog being killed for 150000 kcal of sustenance is a lot more morally acceptable than 50 minks being killed for a single luxury coat. It's not cognitive dissonance to think this.

(numbers from quick, non-exhaustive googling)
Yeah, the problem with jumping into Rust headfirst is that you assume that the most complex parts of the language are what you need to use to solve your problem.

It turns out that the vast majority of Rust code is just fine using Arc and letting the reference counts handle your memory management.

The lifetimes are a really cool feature for library/data structure authors, but if you're writing "web server" style code just use Arc, call clone, and be done with it, unless you've got a specific perf issue.
You can't win if you don't play. Could get it right on the first go!
I am really curious about this -- do you have it just for the effect? What does it look like?
Florida County Overwhelmingly Supports Granting Legal Rights to Rivers
This is not correct.

> Limits and requests for CPU resources are measured in cpu units. One cpu, in Kubernetes, is equivalent to 1 vCPU/Core for cloud providers and 1 hyperthread on bare-metal Intel processors.
"Being around" as a farmed animal may bear little relation to being around as a free, wild creature. Given a few generations, we tend to turn the animals we farm into a parody of the original creature. How well would the average battery chicken survive if it were set free?
Google now also supports Cloud Native Buildpacks (https://buildpacks.io) to build and deploy your functions to Google Cloud Function: https://github.com/GoogleCloudPlatform/buildpacks

They have support for NodeJS, Go, Java, Python, even .NET Core!
Interesting, it works fine on Firefox. I was able to reproduce it using Safari. After poking around I noticed it's a tumblr blog, so I tried some other tumblr blogs with the same result. It seems Tumblr's nav code does not get along with Safari/Webkit.
Highly subjective and project-specific, but I still think it provides a nice counter-anecdote to the constant Rust praise we tend to see here. And I say that as a Rust fan myself.

> ...but remember that garbage collectors are great. By having a GC, we don't have to do any of the stuff that causes all these problems in Rust. Maybe that costs performance, but I need the ability to quickly write code a lot more than I need the extra performance.

This is very valid and sensible. Worth noting is that C++ would be a ridiculous choice for this type of application, and Rust manages to be a not ridiculous choice which is already a huge accomplishment. But that doesn't mean it's always a good choice.
I don't think it's a bad thing. Like them or not, they have a somewhat controversial history; a lot of people worried that their projects would fork the ecosystem, or give them too much control of it - I wouldn't be surprised if they decided that it would be better for the foundation's goal of being a community effort to not be seen as having a heavy hand in it. Some people have expressed similar concerns about Facebook and IOHK as well, just from the financial influence they might have, even though their haskell projects haven't been as close to critical infrastructure as FPComplete's have.
The article ends with why Rust wasn’t chosen, but not before randomly disqualifying some other arguably more obscure languages; the author ends with saying that low level languages “suck”, and that garbage collectors are “great”, and yet Go isn’t mentioned once in the entire post?

I’m not even arguing that Go would be the best or even a good choice here, but it seems strange to not even mention it as it also qualifies as great judging by the arbitrary statements of what does and doesn’t “suck” at the very end.
About what findings, sorry?

Linear Scan is an example I reach for when I talk about what parts of the compiler are really important, if that's what you mean.

http://web.cs.ucla.edu/~palsberg/course/cs132/linearscan.pdf

> The linear scan algorithm is considerably faster than algorithms based on graph coloring, is simple to implement, and results in code that is almost as efficient as that obtained using more complex and time-consuming register allocators based on graph coloring.

Also things like escape analysis and inlining are often called 'the mothers of optimisation' because they fundamentally enable so many other optimisations. Not sure there's really a citation for it but I doubt anyone would dispute.

I wrote about the impact on optimising Ruby.

https://chrisseaton.com/truffleruby/pushing-pixels/
Glorified code gen developer using his 15min of fame.
You might love doom emacs. I've used emacs for 8 years and switched in July, and I can see myself using this for the next 10 years.

I tried Spacemacs, and the vim integration was so sloppy that the first time I tried to install a single package I was dumped in with unfamiliar emacs bindings, which I then had to look up to even get out of it. The integration in doom emacs is much tighter and better fitting.

https://github.com/hlissner/doom-emacs
C definitely isn't portable assembly. For the most part, it has locked computing into the late-70s VAX ISA, then C++ just dug the hole deeper.

And last I checked, Pascal has both PChar and PByte. Much better than C where both are called *char.
Its just delegated to the host platform I'm assuming. Also, I don't know anything about Dark, but it's a DSL, and not a general purpose language, and could very well be running interpreted right now, just mapping things back/forth to the host.

This is all hypothetical, I actually don't know, just my best guess.
I’ve never found the cw/dw case illogical. When I’m deleting a “word” (in prose or code) it’s rarely, perhaps never, my intention to leave a double space between the surrounding words. But if I am changing one, the likelihood is that I’ll want to trailing space to remain after I type the replacement.

So whilst I see nothing illogical, I’m in agreement that a change to these commands would throw me!
I'm really good in vim too, though. I like vim. I just wish we had nice things in vim, too. Besides, vim bindings is a square peg in a round hole. There are edge cases and community momentum to think about, all of which run against the grain when nonstandard setups are used with anything, including emacs.
> Here are two headlines I offer without comment that can be searched with your favorite search engine for more information.

Headlines are not arguments...
> because they don't understand memory management. How is memory going to be managed in Dark? If it's GC'd, how is that implemented?

That's one more thing you can afford to not understand and still be productive.
I agree with you except for one thing: slow programs do cause suffering
On my connection it takes like 30 seconds for the full page to become readable because of all the images. MathML would be more efficient, I think.
They will be providing more than minimum wage as per prop22. The real issue is that the state should provide health insurance.
meat isn't a vice. It's a traditional part of the diet of the majority of human civilizations. Stop creating vices just to be against them.
Markets form naturally from consensual interactions of goods and services for money.

I suppose you could argue the government creating the money allowed the market but alternatives currencies would be created like gold or now crypto.
One big underlying issue is that here is no health insurance. Let's CA provide that instead of acting lazy.
For those who may be unfamiliar with the "immediate mode" vs "retained mode" terminology here, an aha moment for me was realizing frameworks like React are essentially immediate mode APIs (such as declarative JSX) abstracting an underlying retained-mode system (the DOM).

It may not be a perfect analogy, but seems to be basically true.
Dennet wrote a lot about animal perceptions and self consciousness

It's hard to tell if the life they live makes some difference for the individual

It's hard for us humans to fathom it, but is it for them?

We still don't know for sure.

https://lafavephilosophy.x10host.com/dennett_anim_csness.htm...
This is not true.

psychedelics are widely used for micro-dosing, which isn’t about being high - its meant to be sub perceptible dosing.

Also for therapy and mental well being.
There are a number of tools for distributed bug tracking:

https://news.ycombinator.com/item?id=22833037
Screen – My Favorite Multi-Purpose Tool for Pair Programming
And end up with a situation where you can owe taxes and be in the negative even without making profit? No thanks.
Or just have the state pay health insurance and solve the issue at the root. But that's too much work for CA apparently.
Github offers far more than a git repo. PR reviews, issues, etc. are important for many projects. Linux gets by with LKML but that's a nonstarter for most people now.
This is so woke, I can't even...
And the degeneracy of society continues.
Plus the forced into the same location dynamics - guess where we also see that? Prison. If you defined the school system behavior using prison system behavior it is hard to find anything present in schools not essentially present in prison. Graduation/release, lipservice of "development of skills" when they really worry about socialization the most.... Seriously could someone find anything that proves school isn't a subset of prison in its behaviors instead of just how people treat it?
>It's kind of weird to me that language developers would pass on Rust because they don't understand memory management. How is memory going to be managed in Dark? If it's GC'd, how is that implemented?

This was weird to me as well, but it looks like Dark is more like a RAD tool with a custom integrated scripting language. In that case I don't think you need a sophisticated GC.
I think you're missing the point that US states have rights that can't be infringed upon. They are all allowed to make their own types of ballots, allow (or not allow) mail-in voting, decide how many workers to employ for the process, etc. The US government is, by law, not allowed to mess with any of that. Check out how different, for example, Maine's process was this year. They didn't have one winner. They split out electoral votes to two different candidates.
American Express's passwords are (still! after 10 years!) case-insensitive.

An attack on the US Banking system is a matter of when, not if.
If one of the usb port allow OTG someone can hack a driver to turn the 400 into a keyboard (albeit a very bloated one as it would be running a full OS!).
A bank I’ve never had a problem with is USAA (yes, they do banking as well). So if you qualify to have insurance with them, check out their banking. Never had an issue with them in half a decade. They also reimburse ATM fees up to a certain amount per month ($20?)
This link has more detail

https://github.com/erlang/otp/pull/2745#issuecomment-6914821...

“

LLVM is much slower at generating code when compared to asmjit. LLVM can do a lot more, but it's main purpose is not to be a JIT compiler.

With asmjit we get full control over all the register allocation and can do a lot of simplifications when generating code.

On the downside we don't get any of LLVMs built-in optimizations.

We also considered using dynasm, but found the tooling that comes with asmjit to be better.

“
You are yourself the counter example that proves you are wrong. People like you do in fact care about non-local pollution. there are steps: first you need to get far enough out of poverty that you can start thinking you can accept the lower standard of living not having poison around you is acceptable. When you don't have enough to eat or in danger of freezing to death (or other weather/nature related disasters) that poison is something you just stay away from - particularity if your job is with whoever is dumping it since making them clean up might me they don't pay you and then you can't eat. When you don't have those basic worries to you worry about more avoidable ones like local poison/pollution. Only after the above do non-local concerns matter.
Chinese-style censorship is no fix for the Covid-19 infodemic
LLVM is much too heavyweight for a JIT. It's slow at generating code, and makes it difficult to implement common JIT optimizations such as inline caches, which rely on code-patching.
Fair enough. TIL.
Not at all, not conceptually and not historically.
I'm suprised by:

> Good parts: library ecosystem is great

> Bad parts: having to fight the compiler

My limited impression of Rust was the opposite on both points - that the compiler is super helpful but the crate ecosystem sucks.
> About what findings, sorry?

These findings: The important bit is removing object allocating, removing boxing, deep inlining, and specialisation... when you've done all that work the exact registers and instructions don't seem to really make a huge difference.

> Linear Scan is an example I reach for when I talk about what parts of the compiler are really important

Sure, but you just said that register allocation is not a relevant factor compared to other achievements when using Gral VM. Or did I get that wrong?
Show HN: A small PoW CAPTCHA thing I made
I have been working on this for a few days and I got a good API ready, which overlays my old server-dependent system. Now I made it so it can work with a backend server that issues verification keys and an API to verify.
California votes against granting Uber and Lyft drivers employee status
I think the author values immutability and/or managed mutation quite highly, as well as functional programming. Since their last startup was CircleCI where they picked Clojure[Script] and later for Dark they picked OCaml, and said they were considering F#, Haskell and Rust. So I'm guessing that disqualified non functional mutation heavy alternatives like Go.
it's all about

\usepackage[garamond]{mathdesign}

after running

sudo getnonfreefonts --sys -a
> even if we cannot concretely defend every premise in this first iteration, then it is sufficiently plausible that it should at least make us pause for thought

The breadth of amazing and terrible things that this statement can apply to makes it all a bit meaningless.
UK Study;Covid-19 infection rates steeply increasing among secondary schoolers
This was literally predicted by the Dutch presenter Lubach two weeks ago: https://www.youtube.com/watch?v=LOT9BTMVRUI
If that’s the case, I’m going to hell.

In all seriousness. Everything you do have an impact on global warming.

But optimizing code for the sake of reducing emissions is ridiculous.
There are other things you can do in your life to reduce emissions. Using led lights or dialing up your AC a couple of degrees during summer probably offsets all my bad code.
They have a very flat / horizontal management structure for such a large company. Usually for an IC it goes:

You <- Manager/PMs <- VP <- SVP <- Bezos or C-level.

Usually a manager runs a 2-10 person team who they advocate for, and a few PMs interact with the teams that work on the projects they oversee. The PMs are sort of like sales in a traditional company, customer-facing roles who prioritize and occasionally promise features.

There are usually enough VPs that you can meet with one if you have an idea that your peers like, and the support of a VP seems to be enough to let a small team work on a tangent for a year or two.

It sounds a lot like how Google develops new products, because it's surprisingly easy to turn a working proof-of-concept into a public-facing product or service. So why don't they suffer from the product-killing disease that plagues Google?

I don't know, but I have a couple ideas:

* Amazon throws people and money at things that work. Products like Lambda and Alexa used to be small upstarts with modest expectations, but when they sold well, the company invested heavily in them.

* Amazon promotes people based on peer feedback and manager recommendations. It's an easy system to game, and there's a bit of graft as teams defend likeable underperformers since they stopped leaning so heavily on "rank-and-yank" performance reviews. But it also means that you can get promoted for maintenance, like "X prepared our retail service for holiday traffic, and we didn't lose millions in sales when it didn't crash."

I'm not sure how applicable their management structure is to most organizations, though. They can tolerate massive loss-leaders because they have a couple of money printers, and they re-invest most of that money in the company rather than sitting on it or paying it out in dividends. People tend to like working there if they can cope with a bit of stress, and I saw as many people leave the company as I saw take internal transfers during my time there, so "tribal knowledge" also fades more slowly despite the churn.
It does seem very similar. It's a little different. The new law imposes a fine of $100 and appears to be a civil citation. I was suggesting it be a summary offense with no fine and education of the rehab option available. The main difference is in secondary impacts. The civil citation may not show up on a background check, which may not prevent the person from purchasing weapons. Any criminal conviction (even just a summary offense) related to drugs would prevent the purchase of weapons.
> It turns out that the vast majority of Rust code is just fine using Arc and letting the reference counts handle your memory management.

There are disadvantages to Rc/Arc compared with GC, though:

- They tend to be less performant

- Reference cycles can leak

- In languages where they exist at a library level instead of a language level, they're much less ergonomic than GC

So if your core problem domain involves creating and disposing of lots of heap-allocated stuff all the time, you're probably better off just using a language with a proper GC. The Rust version may not even perform better if you're just using Arc, everywhere, by default.

Use Rust when your core domain/hot paths can mostly stick to the single-ownership model (and ideally the stack). Rc/Arc/RefCell are a band-aid for when that fails.
>and yet Go isn’t mentioned once in the entire post?

The author is coming from OCaml and eventually switched to F#. Having a powerful type system probably eliminated the author from considering Go.