cmcaine

No, you'd likely get unrelated style changes in your commits. Read the gofumpt readme to understand why.

Ksplice was never owned by Ubuntu...

It's got good macros and the implementation of both regular code and macros operate on the same core datastructures.

It has the interactive features for inspecting and modifying a running system that Lisps often have.

It has reflection APIs

Its ints are big like Lisp

etc.

Seems pretty Lispy to me.

ThePhD is project editor for WG14, the C language standards committee. The other poster is probably referring to them as "the sheep dev" because ThePhD is prolific on GitHub and have an anthropomorphic sheep as their profile image.

I like it a lot even though almost all of my functions have no dispatch (only one implementation) or single dispatch (implementation differs based on the type of just one of the arguments).

Firstly I like the aesthetic and implications of f(x, y, z) over x.f(y, z). I like that f is its own thing and not a property of x.

Secondly, it's really nice to be able to reach however far down the callstack you need to go to patch some function "owned" by someone else to act correctly or more efficiently with whatever your type is. You can get correct code most of the time with single dispatch and well-thought-out interfaces, but getting interfaces right in advance is really tricky and requires coordination with other users of the interface whereas multiple dispatch can often work well without much coordination and can also handle cases where you want the implementation to vary dramatically based on the type (the OneHotVector in Karpinski's "Unreasonable effectiveness of multiple dispatch" talk is an example of this).

Also, several of the buggy uses of @inbounds were safe at the time they were written (early <1.0 julia when arrays were always indexed from 1).

Fundraising and publishing are specialised skills that artists don't necessarily have. Also, lots of people, including many artists, like the stability of a steady pay check and employment rights, which means companies or co-ops.

The sci-fi author Charlie Stross has a series of blog posts on their site about all the work that goes into publishing a book and how much of it is done by employees of the publisher (and how that is not work that Stross can do / would like to do).

It's correct if you want to do something `length(A)` times and want an iteration counter, but it's never better than `for idx in eachindex(A)` if what you actually want are indexes into A (which is of course the much more common case).

Julia did not initially support arrays that aren't indexed from 1 (experimental support added in Julia 0.5, I don't know when it was finalised), and at that time I'm not even sure we had something like eachindex, certainly there would be no reason why someone would use it for an array.

Julia released experimental support for arrays whose indexes don't start at 1 in Julia 0.5, October 2016.

The boundschecking feature was added in 2015, so at the time they wrote their code and examples, they were correct.

The documentation and review happened in December and January 2016/2017 when the non 1-based indexing was still experimental and very new, so I don't think this is as big a fail as you've made out either.

Yes, the documentation should have been updated when non-standard indexing was made non-experimental, and the reviewers should maybe have noted the new and experimental array indexing stuff, but it's only natural to miss some things.

I don't think there's any clean way to stop that at a language level (some languages prevent this by disallowing random access to arrays, but that's a non-starter for a performance-oriented language), and also it would be a massively breaking change.

Dogs often eat a lot less when they are stressed, though usually not so little or for so long that they get emaciated.

Julia REPLs and editor plugins have adopted a nice feature where you can type the LaTeX name of the symbol you want to get it.

e.g. `\subseteq` followed by tab yields `⊆` or `\trademark` for `™`.

You can also do emoji with `\:eyes:` for ``

I think this is very practical and if you read code in Julia you can see that it's led to quite a lot of unicode and emoji in source code.

The regulation has yielded questionable results, however. Last month in Guangxi, mine bosses visited a pit for a routine inspection. Shortly after, seven assistants were promoted to managerial roles to complete their bosses' former obligation in the mine, according to local news reports.

http://edition.cnn.com/2010/WORLD/asiapcf/10/13/china.mining...

I really like Baselet.jl[1] which provides Tuple-specialised implementations for a bunch of Base APIs that the compiler is very good at unrolling :)

[1] https://github.com/tkf/Baselet.jl

Why would they exclude a repo and then not exclude all PRs from that repo?

You can use unbindurl, so you can unbind tridactyl's j/k on mail.google.com, for example. Keys not bound in tridactyl are passed through to the page.

... and Mozilla. The company that most of the core team are from ;)

Other quotes from the chain by ESR about Eric Schultz:

I am not fooled. You are mounting an ideological attack on our core principles of liberty and nondiscrimination. You will not succeed while I retain any ability to oppose this.

and

Because that way he couldn't use our prestige to advance his goals. He couldn't use OSI to pretend to be pro-freedom while actually being against freedom.

Both of these messages are hostile, assume bad faith and (as noted by some supporters of ESR's position) unhelpful for resolving the issue.

Those are already problems with aviation, so that's nothing new. The existing rules didn't emerge from primordial ooze, they were also influenced by lobbyists and have certain effects.

You can have a more expressive voting system than that. People can rank their priorities, etc.

If you just give fines to companies that don't run flights on routes then you can impose a penalty without incentivising empty or near-empty flights.

You can just fine the companies rather than incentivising them to run empty planes.

Better yet, institute a proper carbon tax and either a carefully thought-out market for slots and/or fines.

Julia can stack allocate all sorts of values. I think it currently stack allocates all immutable values and also every mutable value that it proves do not escape their function.

Kind of besides the point, though, because the GC is probably not heavy anyway. Lots of fear of GC is not based on benchmarks.

The other replies are slightly out of date and imprecise.

PackageCompilerX replaced PackageCompiler (and there's a PR open that will pull all the X work in soon).

The binaries produced bundle the whole Julia sysimage by default and they're quite big, but they are quite fast!

A more traditional static compilation approach is being tried with StaticCompiler.jl by tshort, but it's in early development.

Jury trials are practiced in many jurisdictions and did not originate in England.

https://en.wikipedia.org/wiki/Jury_trial

These links are unrelated spam, I think.

Why this comment? I don't see a report button.

But why? What problem would that rebate seek to solve?

If the concern is that poor people might be unable to afford to stay in their homes, why not target poverty or house prices directly rather than adjusting the tax?

Nearly twice the emissions with over four times the population. Nearly 20% of the world's population is in China. Of course they're going to emit more.

But if China were rapidly increasing its emissions per capita, that could still be a problem, but that doesn't seem to be the case. China seem to have held their emissions more or less still for the last few years where data is available:

consumption adjusted: https://ourworldindata.org/grapher/prod-cons-co2-per-capita

per capita with comparison countries: https://ourworldindata.org/grapher/co-emissions-per-capita?t...

In the same period, the US, and indeed most states have achieved only quite small changes to their per capita emissions. So the US has reduced emissions a bit, but from a much higher starting point.

My gripe is that westerners often leap to talking about China and India or, worse, overpopulation.

The implicit belief seems to be that foreigners are an inconvenient drain on global resources, that they deserve less than us.

This is not true.

The letter is here if you'd like to read it: https://github.com/drop-ice/dear-github-2.0

This blame China narrative is pretty ridiculous.

China's per capita emissions are about half those of US or Canada (though still over the global average). That should help you understand how incredibly profligate North America is. China's growth in per-capita emissions also seems to be slowing while in the US, the per-capita emissions are basically static since 2012.

The USA is also the world leader in cumulative emissions (which is what really matters if you're trying to draw up a carbon budget or assign blame). While the biggest historical emitters continue to do so little it's no wonder that others don't take climate change as seriously as we might want.

Cumulative emissions sources and plots:

https://ourworldindata.org/grapher/cumulative-co-emissions?t... https://wriorg.s3.amazonaws.com/s3fs-public/uploads/historic... https://wriorg.s3.amazonaws.com/s3fs-public/uploads/cumulati...

These emissions figures will be assigning the manufacturing emissions of exported goods to the country that exports them, not the one that imports them. This is one contributor to China's high emissions: manufacturing loads of stuff for the west. Those emissions should really be attributed to the purchaser.

Source for CO2 emissions over time:

Nice table: https://knoema.com/atlas/ranks/CO2-emissions-per-capita?base...

Source data for that table: https://edgar.jrc.ec.europa.eu/overview.php?v=booklet2019&ds...