"while somehow finding room in the same breath to demonize wind and solar energy "
Did you ever consider that all the money spent on expensive renewables is money not spent on cheaper forms of power? Did you ever consider that they are correct and that spending on renewables drives up power costs? Because that's what the data says is happening. Now, I am aware that the amount of FUD on this topic is very different to get through. But if you learn about the differences between capacity and utilization costs and the other accounting games that are played with energy costs, you will learn how to see through the FUD. But I'm sure it is more psychologically comforting to just look down on them which is what you are actually doing.
I consider that I'm intertwined in the evolution of a very different friend's very local efforts, with their own hybrid battery-backed grid-tied offline-capable solar power system.
That rig is pretty sweet.
It pays for itself, and in present form and with their present use (wherein: they're not trying to live particularly-efficiently) it is almost entirely capable of keeping them with power even if the grid goes down for an indefinite period.
But, sure: We can talk about games, instead, if what you want to chat about is just games.
"entirely capable of keeping them with power even if the grid goes down for an indefinite period."
You do know that batteries have a capacity right? And powerplants have something called a capacity factor. That means for a given amount of capacity, you generate on average a certain amount of power. For nuclear that factor is .9. For renewables its .1. So 1 watt of nuclear provides the same power as 9 watts of renewables. That's why when you say that renewables have 1/3 the capacity cost, it really means its 3x more expensive than nuclear. That means higher bills for people, which is what we mean when we say utilization cost. That's the real cost that people pay and actually counts. And all this is before we talk about siting issues with renewables. Fun fact, most PV is sites (located) somewhere with an albino factor of less than .25. But since you connected a battery terminal to a PV panel, you must know what that means. Seriously, you are just spreading misinformation that transfers cost from the rich to the poor, such a hero you are.
It probably has more to do with the fact that solar that far north is a non-starter. Any PV installed there will actually make AGW and carbon emissions worse, not better. Basically, the amount of carbon emitted due to manufacturing is greater than the carbon savings over the lifetime of the panel in those locations.
There is sort of some truth to that but its still pretty disingenuous to phase it that way. The more honest way to say it is that the NIMBYists are (probably somewhat unintentionally) keeping FFs in use by opposing nuclear.
Also, you (and everyone else in the thread) are listing capacity costs. Nobody cares about capacity costs except the CFO of a utility. Utilization costs are what matters. And by that (honest) metric, nuclear is quite cheap if you exclude the extra costs due to scientifically illiterate eco-activists and regulators.
People like to say that "A diamond is forever" is the best marketing effort of all time. I disagree, the ability of FF extractors to get ecos to do their dirty work for them is far more "impressive" (from a POV lacking in ethics).
PS The number of outright falsehoods in just this thread about nuclear should prove my point. Just research about how nuclear pays for cleanup and compare that to some comments in this thread for an example.
This is completely wrong. The SQL spec isn't Turning complete but multiple DBs provide Turing complete extensions (like pgplsql) that make it so. Also, even without the extensions, it is still very much a programming language by any definition of the term. Like most takes on SQL, it is more about your understanding (or lack thereof) of SQL.
I was under the impression that recursive CTEs make the SQL spec Turing complete. Not that it makes any practical difference, it's still very difficult to use for "general purpose" programming, and still very practical to use for data processing / management.
Last year I read about some database researcher who implemented AoC in pretty standard SQL.
> Like January 6th and vaccines causing autism and climate change denial and election rigging and Haitians eating dogs and Venezuela drug boats?
That you categorize all of those things in the same boat is very partisan. And it is exactly why a government controlling access to information is a very bad idea. Some of those things aren't real phenomena, others are just over hyped and some are real and very much proven. The news sources you got those opinions from are highly partisan but you trust them implicitly even though you have access to the Internet and can cross check many of them. That you can make such blind mistakes is exactly why elected officials should never control the flow of information. And to give you an example of an opinion that very much matters, consider is nuclear power green or not? The wrong answer about that is doing more damage than your most hated official could ever do.
- January 6th was an attempted coup of the government coordinated by Republican interest groups and antagonized by Trump.
- Vaccines do not cause autism.
- Climate change is real and anthropological in origin.
- The 2020 election was not rigged for Biden and there exists no evidence of impropriety of any kind.
- Haitians did not eat people's pet dogs in the USA. This was just plain, out-in-the-open racism.
- The US military is using the WMD, sorry, I mean the "drug boat" excuse on vessels 1,200 miles away from US waters to execute a dozen people at a time. They are providing no evidence and performing no seizures or investigations. Then they are violating international law and their own documents on war crimes and service member's duty to refuse by having them execute shipwreck survivors.
Everything above is a fact. Not an opinion. Not partisan. A fact.
Many of the Scala projects got people fired. Something the Scala devs largely ignore. Plus Scala support is truly awful even by the low standards of an OpenSource project. Then there is the fact that the Scala specific libraries are largely dead.
Scala had/has a lot of promise. But how the language is marketed/managed/maintained really let a lot of people down and caused a lot of saltiness about it. And that is before we talk about the church of type-safety.
Scala is a more powerful language than Kotlin. But which do you want? A language with decent support that all your devs can use, or a language with more power but terrible support and only your very best devs can really take advantage of. And I say this as someone writing a compiler in Scala right now. Scala has its uses. But trying to get physicists used to Python to use it isn't one of them. Although that probably says more about the data science folks than Scala.
PS The GP is right, they should have focused on support and fixing the problems with the Scala compiler instead of changing the language. The original language spec is the best thing the Scala devs ever made.
Kotlin has become a pretty big and complex language on its own so I'm not sure this is a good counterexample.
The fundamental issue is that fixing Scala 2 warts warranted an entirely new compiler, TASTy, revamped macros... There was no way around most of the migration pains that we've witnessed. And at least the standard library got frozen for 6+ years.
However I agree that the syntax is a textbook case of trying to fix what ain't broke. Scala 3's syntax improvements should have stuck to the new given/using keywords, quiet if/then/else, and no more overloaded underscore abuse.
One impressive thing for us is that the changes to macros were hardly an issue. We'd been trending off macro-heavy libraries for a while, and our Scala 3 adoption has not really been harmed by the new macro system.
> The original language spec is the best thing the Scala devs ever made.
The overreaching majority thinks that Scala 3 is objectively much better than Scala 2 ever was. That's at least what you hear just everywhere, besides the occasional outlier by some Scala 2 die hards.
> Scala had/has a lot of promise. But how the language is marketed/managed/maintained really let a lot of people down and caused a lot of saltiness about it. And that is before we talk about the church of type-safety.
On the contrary, there was nothing wrong with Scala's marketing. What's damaged it is a decade of FUD and outright lies from the people marketing Kotlin.
Because the jit will let the unoptimized code run a few (hundred) times to take measurements to know what needs to be optimized and how it needs to be optimized. This is a good solution and makes hotspot very effective. The problem is that it happens randomly a few minutes/seconds into the operation of the service. So you randomly have a big pause with the performance hit everytime you run the service. The upside is that this only happens once. But you have to plan for a big performance hit to requests which are unlucky enough to be called at the wrong time.
Of course, but then you have to actually do this. It is just another complexity to add. Also, I was answering a question about the hows and whys of the jit. I wasn't saying it was impossible to work around.
Maybe the JVM team should listen to the market then and disable the jigsaw encapsulation that keeps devs on 1.8. Forcing a questionable security framework on everyone is why 1.8 is still used. Again, this is a problem because the PMs (and some devs) refuse to listen to what the market wants. So they are stuck keeping a 20 year old version of the code working. Serves them right to have to do this. It is their penance for being too arrogant to listen to the market.
PS Yes, I know, there is some weird way to disable it. Somehow that way changes every version and is about as non-intuitive as possible. And trying to actually support the encapsulation is by a wide margin more work than it is worth.
First, the number of projects still on 8 is low, and almost all of them are legacy projects with little to no evolution.
Second, modules' encapsulation is not what caused the migration difficulties from 8 to 9+, evidenced by the fact that it wasn't even turned on until JDK 16: https://openjdk.org/jeps/396. From JDK 9 through 15, all access remained the same as it was in 8. The reason a lot of stuff broke was the JDK 9 was the largest release ever, and it began changing internals after some years of stagnation. Many JDK 8 libraries had used those internals and had become dependent on them not changing - though there was no promise of backward compatibility - because there was no encapsulation.
Finally, the market clearly wants things like projects Loom and Panama and Valhalla, things that wouldn't have been possible without encapsulation (at least not without breaking programs that depend on internals over and over). It's like people complaining about the noise and dust that installing cable ducts causes and say, "nobody asked for this, we just asked for fast internet!"
I'm pretty sure that the majority of shops that aren't worrying about Android have moved on from Java 8. The JVM team only keep Java 8 working for customers paying them lots of money for extended support contracts. And that's only because they have this long-term extended support system for all LTS JVM releases (they are also still supporting 11 in a similar manner).
On the other hand, Android doesn't even support Java 8. It supports the long-dead Java 7 plus a subset of Java 8 features. Android essentially froze their core application runtime in amber over ten years ago and have just been adding layer upon layer of compiler-level sugar ever since. The effect is an increasing loss of the benefit of being on the Java platform, in terms of code sharing.
I never understood why they do not track the OpenJDK versions. I don't work on Android apps.. but it seems mildly insane to basically have a weird almost-Java where you aren't even sure if you can use a given Java lib.
> I never understood why they do not track the OpenJDK versions. I don't work on Android apps.. but it seems mildly insane to basically have a weird almost-Java where you aren't even sure if you can use a given Java lib.
NIH syndrome
> (and not a Dart chat app.. but something actually performant that uses the hardware to the full extent)
I used to work on Android, quit two years ago and have used Flutter since, it's a breath of fresh air. It does use the hardware to the full extent, imo it's significantly more performant: it does an end-around all the ossified Android nonsense.
Hmm, so if you wanted to make an AR app, or some audio processing app, would you do that in Flutter? All the projects I have in mind involve using the camera/microphone/gps etc. Looking at Dart sample projects it just seemed to be quite different from what they're aiming at
My caffeinated instinct is to say basically "yes I'd do anything in Flutter", I honestly would rather stop coding than go back to anything I've done before (ObjC/Swift/Java/Kotlin with side journeys in C++). It boggles my mind how much of a different job dev is with true hot reload.
More carefully, and dealing with what you're indicating more directly:
There's stuff that we just need every millisecond of performance from.
Generally, Dart's great, I don't notice any difference between iOS / Android standard UI platforms.
But...for example, Flutter's image decoding is actually using "native" code behind the scenes, i.e. calling into C or OS-level APIs or browser APIs as needed on each platform. And there's a Flutter package called "image" that's Dart-native but I abhor because I know it's going to be higher latency than going thru lower-level code. (now I'm wondering how Java does this...I wonder if its JNI...)
Let's do a scenario: I've been contracted to build a bus route app for the local gov't. They want an AR feature. What happens if I choose to build on Flutter, build out the basic features, then get to the AR, and I'm getting 5 fps?"
This might feel convoluted at first, it did to me, but really, all that's going on is: when things are slow, we write a Dart interface, then for each platform where we want to use native code, provide impls of that interface in native.
Yeah, I'm currently developing a Flutter app and also using flutter_rust_bridge to separate the business logic and I can hardly believe how enjoyable it is.
Other than the initial project setup which is a me and Nix flakes problem it all comes together pretty smoothly.
I have not done a Java 8 project in years, other than Android because the reasons we all know.
Maybe Google could finally support latest Java versions on Android, instead of begrudgingly update when Kotlin lags behind Maven Central most used versions.
Which by the way is a Java 17 subset, not Java 8, when supporting Android versions below Android 12 isn't required.
Nope, what I am asking for is disabling an on by default feature that maybe 1% of the market wants and/or needs and creates significant pain for the other 99%. By the time strong encapsulation meets an attacker, the battle is already lost most of the time.
That feature is necessary to enable future enhancements. It’s an important stepping stone. Just update your code. I’m doing it on 20 year old legacy billion dollar code base. It can be done.
It's not just for security, it's also for maintainability. Frankly being able to reflect across package boundaries has always seemed like a misfeature for maintainability to me. The code you have that is broken by Java 9 was already badly behaved, the JVM was just lenient about it.
Did you ever consider that all the money spent on expensive renewables is money not spent on cheaper forms of power? Did you ever consider that they are correct and that spending on renewables drives up power costs? Because that's what the data says is happening. Now, I am aware that the amount of FUD on this topic is very different to get through. But if you learn about the differences between capacity and utilization costs and the other accounting games that are played with energy costs, you will learn how to see through the FUD. But I'm sure it is more psychologically comforting to just look down on them which is what you are actually doing.
reply