hexane360

From the original paper, the end result is "highly oxidized carbon", "akin to that of slightly crystalline graphene oxide". So they're not claiming to split CO2 into C and O2, but more to vitrify the carbon oxide in a solid phase. This, presumably, takes significantly less energy than reducing the carbon, and you can't burn the output product.

I'm a little skeptical of the results as well. A tonne of CO2 releases 2489 kW*hr of free energy when formed from C and O2.

However, reading the original paper, it seems like the end product is "highly oxidized carbon", "akin to that of slightly crystalline graphene oxide". So they're not claiming to undo the carbon oxidization, more to vitrify the carbon oxide in a solid phase. This, presumably, takes significantly less energy than reducing the carbon.

I think this is the key part about adopting anything: Make sure you understand the goals behind it, and how those led to the choices it made. Not understanding those is when you start cargo culting.

Of course, it's impossible to know every thought process that went through the original developer's head, but with an understanding of the core goals, you can at least make educated guesses as to what's "load bearing", so to speak.

They're similar. However, an AFM directly measures the deflection of a probe you're rastering, while a STM measures the current caused by quantum tunneling between the probe and the sample. This is extremely sensitive to height because an electron's wavefunction degrades as e^(-sqrt(2*m_e*E)*x/hbar) with distance x and energy barrier E (the measured current will scale with the wavefunction^2). Additionally, a STM allows you to probe electron states as well as just topography.

That was uploaded in 2017. It's not the original.

Aquaculture doesn't refer to fishing, but it does refer to farming aquatic life, usually fish. You're probably thinking of hydroponics.

Now you're falling victim to it!

It appears that that move has increased enrollment in higher level math classes in high school: https://www.sfchronicle.com/education/article/SF-schools-mov...

See also some of the motivation behind the change: https://priceonomics.com/why-did-san-francisco-schools-stop-...

I would argue part of the problem with the American system is that trying to rush students through a rigid curriculum leaves the teachers no choice but to teach by rote memorization and cookie-cutter problems. Slowing down the curriculum is part (but not all) of the fix.

Still, whether or not this policy is good, it takes a lot of spin to turn "San Fransisco is starting algebra a year later" into "witnessing public schools take math out of the curriculum at elementary, middle and high schools", which is what you claimed.

This reminds me of this wonderful blog series that examines the psychology of estranged parents' forums: http://www.issendai.com/psychology/estrangement/index.html

There's lots of discussion of the generational gaps that cause a lot of this friction (many of which I see discussed in this thread):

- Is emotional abuse "real abuse"? Does it "count" for estrangement?

- Do parents owe an apology for mistakes they made?

- Do children own a relationship to their parents?

- Do children owe respect to their parents, regardless of anything the parents have done?

- Is the parent/child relationship one-sided?

But Germany can't do that because it would be against Germany's constitution.

Running 45 MW of miners != Producing 45 MW of energy != Producing producing 45 MW of waste heat. First you have to consider the thermodynamic efficiency of the power plant. With a ~40% efficiency, 1 W of produced heat wastes 1.5 W of heat. Then you have to consider the overhead for running the miners. Ballpark, about half of the energy probably goes to HVAC. Furthermore, that 45 MW of mining power is also eventually getting released as heat, some of which may be returning to the lake.

Overall, 45 MW of bitcoin produced could mean 135 - 180 MW of waste heat.

A lot of what go into both are the same: Water, heat, filtration, purification, etc.

In fact, a lot of chemical engineering (some would say the lion's share) has to do with heat and water management. It's a huge factor whether you're operating a clean room or an oil refinery.

96.3 um/s! That's enough to drain a 6 foot deep swimming pool in 5.27 hours.

I was bitten by something related to this a couple weeks ago:

    >>> with open("pickle.pkl", "rb") as f:
    ...     pickle.load(f)

    Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
      File "/usr/lib/python3.9/pathlib.py", line 1074, in __new__
        raise NotImplementedError("cannot instantiate %r on your system"
    NotImplementedError: cannot instantiate 'WindowsPath' on your system

>small union which julia handles efficiently at runtime

Oh! I didn't realize Julia already optimized small unions.

https://julialang.org/blog/2018/08/union-splitting/ https://docs.julialang.org/en/v1/devdocs/isbitsunionarrays/

I wasn't quite sure whether something like this was possible given the semantics of Julia.

Personally, I'd still prefer something more explicit, so it would be more obvious when a union is being handled efficiently. But given that small unions are optimized, I can see why Julia would make the opposite decision.

This makes me feel a lot better about writing Julia code with union types. Thanks

Doesn't the TypeStable struct just hide the unknown type, not remove it? The type of o.o still needs to be looked up at runtime. Furthermore, TypeStable itself has to be on the heap, which I think means this causes two pointer lookups rather than just one.

Right, I'm referring to the local o being Any, meaning that it must be behind a pointer lookup. I should have clarified because the more common usage is about the function's return value.

I'm sorry if my post came off as gatekeeping. I'm not saying that academic programming is worthless. My argument is that there's a difference between using a language and creating one. Systems programmers, programming language theorists, and CS researchers are among the best suited people to creating a robust language for any domain. My quarrel is not that Julia is targeted towards academic programmers, but that overfocus on academic programming leaves sometimes leaves the developers myopic when it comes to language decisions.

As an aside, I don't see why Rust couldn't seep into "anything seriously academic". C++ is widely used, and I've seen a gradual uptick in the usage of RAII. Rust seems like the next step, especially with the effort put into the ecosystem and learning materials. Sure, it might come slower than in domains where safe memory management is critical, but I don't think the needs of academics are fundamentally different here.

MLStyle.jl is nice, but I think Julia would really benefit from having it enshrined in the language. Multiple dispatch is great for a lot of problems, but sometimes it makes more sense to do your pattern matching inline.

For tagged unions, the difference is in memory layout. A real tagged union type would eliminate indirection and allow more code to be type stable.

For instance,

    mutable struct NotTypeStable
        o::Union{Some{Int}, Nothing}
    end

    function not_type_stable()
        o = returns_option()
        if isnothing(o)
            0
        else
            1
        end
    end

versus:

    enum Option{T}
        Some(T)
        None
    end

    mutable struct TypeStable
        o::Option{Int}
    end

    function type_stable()
        o = returns_option()
        match o
            Some(_) => 1
            None => 0
        end
    end

Both of these features aren't strictly necessary, but they act as a compliment to Julia's existing dynamic mechanisms (multiple dispatch & Union types)

Yes, this is exactly what I was getting at. Speed is one of the reasons to choose Rust/C/C++ over Python, but there's other compelling ones: static types, more control over execution, tight coupling to the OS, etc. To truly solve the two language problem, Julia should have APIs and coding styles which allow greater control, even if they're not used by everyone.

Because it's so closely integrated with C, Python actually does a decent job at this, which IMO is one of the reasons it's been so successful as a general purpose language in addition to a scientific one. I really hope Julia can do the same.

Off the top of my head, here are a few features I think would really improve Julia for general purpose programming:

- Static type checking (JET.jl[1] looks promising)

- Faster startup (again, great strides have been made)

- Tagged, closed unions

- Pattern matching

[1]: https://github.com/aviatesk/JET.jl

I'm sure there are some crates out there, but probably nothing very stable.

If there's one thing Rust is not, it's a good "glue" language. It seems to do best in large, densely coupled projects. This is where there's the least cost to defining all your own types, and also where a strong type system provides the most benefit. I think there will always be a place for more dynamic languages that tend to do better at interfaces.

As someone who dabbles in both Rust and Julia, I agree there's a lot Julia can learn from Rust. Rust has made a lot of good technical decisions, and I think many of these decisions came from having a team of experienced systems programmers. In comparison, Julia's decision making process seems much more informal, and snap decisions are sometimes made from the narrow perspective of academic programming rather than carefully considering the goals of the language, future uses, and forwards compatibility.

Speaking of Scott Alexander, this kind of thinking seems exactly like the kind of virtue signaling he writes about in "I Can Tolerate Anything Except the Outgroup". As the priest in the parable says:

>It seems to me that you only pardon the sins that you don’t really think sinful. You only forgive criminals when they commit what you don’t regard as crimes, but rather as conventions. You forgive a conventional duel just as you forgive a conventional divorce. You forgive because there isn’t anything to be forgiven.

And as Scott continues:

>Actual forgiveness, the kind the priest needs to cultivate to forgive evildoers, is really really hard. The fake forgiveness the townspeople use to forgive the people they like is really easy, so they get to boast not only of their forgiving nature, but of how much nicer they are than those mean old priests who find forgiveness difficult and want penance along with it.

I think about this a lot when I see the perennial discourse on canceling. Scott talks about this argument in terms of people being canceled by leftists, but I think it applies almost as well to people on the opposite side handwringing about cancellation. There are lots of great points to be made about the corrosive effects of cancellation mob rule, but I sometimes wonder if most of the left-right difference on this issue comes down to how strongly they feel about the infraction in question, rather than any level-headed consideration of what policy would lead to the best society.

I believe that's the goal of Cranelift [1] and rustc's cg_clif [2].

1: https://github.com/bytecodealliance/wasmtime/tree/main/crane...

2: https://github.com/rust-lang/rust/pull/77975

Can't this be applied to wide swaths of hard sciences as well? Lots of scientific work overlaps heavily with engineering, which is all about changing the world.

Also, I don't think ending poverty is a major stated goal of psychology research. . .

I love resistFingerprinting, but I really wish it had a whitelist for certain data on certain sites. Maybe I want my calendar app to know what time zone I'm in!

Is there a way to describe electrostatics as objects following inertial trajectories through curved space?

That makes sense as well. It's not unexpected that a one-off F1 car is faster than a mass-produced Mustang.

I think you and the parent comment actually agree quite a bit.

The parent comment is saying "profit is killing our planet", and you're basically saying "markets aren't killing our planet". The resolution, of course, is that non profit-motivated organizations can exist and participate in markets.