🖥️...⌨️

The sun's activity could peak 2 years early, frying satellites and causing radio blackouts by the end of this year, experts say

Story by jorwig@businessinsider.com (Jessica Orwig,Morgan McFall-Johnsen) • Yesterday 5:19 PM

A solar plasma "waterfall" was spotted on the sun recently. More odd solar phenomena has been seen recently as the sun nears a peak of activity. Eduardo Schaberger Poupeau© Eduardo Schaberger Poupeau

• The sun is becoming more active and may reach peak activity sooner than expected.
•  Solar maximum was predicted to happen in 2025, but sunspot activity has changed that.
• An unusual burst of sunspots this year suggests solar maximum could hit by the end of 2023.

1 of 16 Photos in Gallery©NASA/SDO

13 times solar storms caused freak events on Earth, from detonating mines to crashing financial markets

• The sun is about to get more active, and it's likely to send more solar storms our way. 
• When it does, charged particles and radiation barrel toward Earth, causing bizarre events. 
• Here are 13 of the weirdest things that happened on Earth likely caused by solar eruptions. 

The sun is a huge ball of molten plasma, buzzing with magnetic fields that ebb and flow at its surface. 

Every so often, those fields collide, creating a massive explosion that spews charged sub-atomic particles into space that carry with them the potential to disrupt electric fields and cause radiation exposure.

As these particles barrel through space, they can run into Earth. Our sun is nearing its next peak of activity, and with it, more solar storms are likely to come our way. We look back at the 13 weirdest things likely or definitely caused by solar storms that have happened on our planet.

See More

The sun is growing more active, which is expected. Our sun has an 11-year cycle where it increases and decreases in activity. What's unexpected is how soon it will reach the solar maximum.

We're currently approaching solar maximum, when the sun reaches peak activity, which experts have previously predicted should happen in 2025.

But the sun's recent behavior suggests solar maximum will hit sooner than expected — by the end of this year.

It's "going to peak earlier and it's going to peak higher than expected," a solar physicist at the University of College London, Alex James, told Live Science.

Why solar maximum is a threat to Earth

The solar maximum is a time when the sun's magnetic field is extremely weak, and that's not great news for Earth. 

Normally, the solar magnetic field acts as a shield, constraining solar radiation and reducing the risk of potentially harmful events like solar flares and coronal mass ejections (CMEs). 

Solar flares and coronal mass ejections are examples of solar storms. When the storm breaks, it fires high-energy particles into space. On the off chance those particles strike Earth, they can cause a lot of damage.

An animation of the solar wind shows high-energy particles streaming from the sun towards Earth. NASA© NASA

For example, already this year a powerful solar flare caused widespread radio blackouts that disrupted high-frequency radio signals in North America, Central America, and South America.

Loaded: 100.00%

Play

Current Time 0:31

/

Duration 1:23

QualitySettings

Captions

Fullscreen

Space

X1.9 Solar Flare - Hyperactive Sunspot Eruption Seen By Spacecraft

Unmute

0

View on Watch

More videos

Space4K Time-Lapse Of Sunspot Crackling With Strong M Flares

1:05

DailymotionPredicting Sunspots

1:39

SpaceTime-Lapse Of New Sunspot Erupted With Strong M-Class Flares

1:06

X1.9 Solar Flare - Hyperactive Sunspot Eruption Seen By Spacecraft

Space

Auto-play

In the past, powerful solar storms have surged the Quebec power grid, causing blackouts that lasted up to eight hours. Solar storms have also been linked to exploding sea mines and destroyed Starlink satellites.

Why experts think solar maximum will hit soon

When the sun's magnetic field is weak, its surface gets a lot more interesting to look at.

For example, the solar surface develops temporary black blemishes called sunspots, which are regions where the magnetic field is especially strong in one area. This chokes the flow of hot fresh gas from the sun's interior to the surface, cooling that region and making it appear black. 

Sunspots, like the one shown here are cooler than their surroundings, which is why they appear black. But don't be misled, the typical temperature of a sunspot is 7600 degrees Fahrenheit. NASA Goddard on YouTube© NASA Goddard on YouTube

Meanwhile, the powerful magnetism behind the sunspot can brew eruptions.

So as the sun grows more active, and its magnetic fields throb and tangle more wildly, scientists expect more sunspots and more of the solar flares and CMEs that can erupt from them.

Therefore, by monitoring the number and frequency of sunspots, scientists can track the solar cycle and its progress toward maximum activity.

In 2020, a national panel of scientists issued a forecast that the sun's current cycle would reach its maximum in 2025 with a peak of roughly 115 sunspots.

The sun has more sunspots during solar maximum. NASA's Solar Dynamics Observatory/Joy Ng© NASA's Solar Dynamics Observatory/Joy Ng

But ever since then, sunspots have been outstripping those predictions. January saw over 140 sunspots, when no more than 92 were predicted, according to a database of the National Oceanic and Atmospheric Administration. May brought nearly 140 sunspots again.

Solar flares have also been growing more frequent and more powerful year by year. An unexpected "stealth" CME washed over Earth on March 24 and created a historically powerful geomagnetic storm, pushing the aurora borealis as far south as Arizona.

An array of other unusual solar phenomena also point to an early solar maximum: a vortex on the sun's north pole, a plasma "waterfall," a tornado-like twisting prominence, and giant "holes" forming in the sun's outer atmosphere.

🖥️...⌨️

With the advent of Selenite/ruby @ 4.2.1, everything about the current partitioned array's state is very good. Over the course of about 2 years, we have stomped out all possible known bugs of Selenite. Selenite is the ongoing name of LineDB/the partitioned array since lineDB is kind of taken.

Since Selenite is bug-free, we don't have to worry about potential bugs anymore; the last bug was stomped a couple or one day ago.

🖥️...⌨️

This is in regards to ArityWolf's algorithm, the partitioned array: Midscore-IO/partitioned_array: ArityWolf's Algorithm - The Partitioned Array (github.com)

🖥️...⌨️

It has become known that its not as easy as I think to convert Ruby code over to Rust, mostly because the AI in question doesn't fully understand the code, or conflates it with existing libraries ala Google Bard.

Since `emerald`, a Ruby interpreter is written in rust, I can make a great effort to have my partitioned array and linedb code lie in a compiled emerald binary that runs in the background on localhost, and rust sends get and post requests to store and pull data (from the LineDB database).

The new database will be called Selenite, and it will be a library that has code written in it, `artichoke`, which interacts with Rust via GET/POST requests and returns all data in a relevant JSON parser format.

Artichoke, the Ruby interpreter written in Rust: Midscore-IO/artichoke: 💎 Artichoke is a Ruby made with Rust (github.com)

The plan is to have the Selenite/ruby database fully implemented as a stand alone server that works in any kind of ruby environment, and the Selenite/rust server interacts with Selenite/ruby. 

We are still trying to figure out how to implement the data structure in Rust that interacts with the artichoke ruby Selenite server.

Also, I don't want to think of it as procrastination in the sense that I really do not want to port this code to Rust at the moment; if I get it fashioned into servers that send GET/POST requests between each other and i/o the corresponding json, I may not have much of a problem.

[Selenite/ruby] < i/o > [Selenite/rust]

But how will i/o work?

It will possibly work by rust having a certain data structure setup that can hold a json response and auto-parse to the array form

I want to keep on thinking about this further, and I really need a concrete battle plan with how I am going to tackle the problem of Rust's data structure that holds entries from the partitioned array, but it seems that at least implementing the basic partitioned array logic in rust and working from there will be the long-term solution.

UPDATE: I have looked around a bit more, and found 

magnus::embed::ruby_script 

Magnus is basically a standard library in rust, implemented to interact with any aspects of Ruby, and it is the inherent solution (also because its in the standard library)

With all that in mind, the idea is to simply use magnus to implement ruby's partitioned array functions, making keenly aware that magnus::embed::ruby_script has a few nuances, as does this entire operation because working with any kind of Ruby code is labeled in general as unsafe--imagine trying to get an AI to successfully port all of this.

HOWEVER, I also have come up with some source code which clarifies the require method: main.rs - source (docs.rs) 

See render: https://thefieldtesters.net/blog/render/?id=5&user=the-field-testers

# SOURCE: https://docs.rs/magnus/latest/src/embed/main.rs.html#9


use magnus::{class, embed, prelude::*, require, Value};

mod word_sink;
mod word_source;

// run with `echo foo bar baz | cargo run --example embed`
fn main() {
    // start Ruby
    let _cleanup = unsafe { embed::init() };

    // effectivly `require`ing these modules, loading the classes in Ruby
    word_source::init().unwrap();
    word_sink::init().unwrap();

    // require our Ruby code
    // this example uses a relative path from the working directory
    require("./examples/embed/transform").unwrap();

    // get the class defined in Ruby and call a method on it
    class::object()
        .const_get::<_, Value>("Transform")
        .unwrap()
        .funcall::<_, _, Value>("run", ())
        .unwrap();
}

🖥️...⌨️

1. Draw every early morning, first thing
   1. gesture drawing class
   2. subject to draw sfw
   3. possible provocative drawings where they are scantily clad with giant buldges
2. Programming
   1. learn rust and webassembly
   2. work on partitioned array
      1. get ported to rust and other programming languages
   3. work on server backend development
      1. test out more partitioned array concepts

🖥️...⌨️

Introduction - Rust and WebAssembly (rustwasm.github.io) => rust and webassembly tutorial; you're getting a book on the same subject.

• USING WEBassembler without a bundler like npm: Without a Bundler - The `wasm-bindgen` Guide (rustwasm.github.io)

The Rust Programming Language - The Rust Programming Language (rust-lang.org) => primary book on the rust programming langage; buy the official book 

🖥️...⌨️

1. Read the webassembly + rust + game development book and get a game development environment going
2. Consider creating a database system in the rust implementation of ruby called emerald, to compile the database to a binary and use alongside the rust game

Recall that on top of all of this, you can use wasmtime, but I get the feeling that the first 2 sentences are the best combination, albeit there are a couple things that can be done

• Buy the official rust programming book and study rust further from that, albeit the rust + webassembly + game development book doesn't seem to have a pre-req of knowing rust
• Figure out how to bridge the gap between ruby database and rust implementations

In the end, port the partitioned array to rust, however tough that may be; use AI.

🖥️...⌨️ Here is a list of Ruby/Rust + Webassembly related articles and usages; for future reference

• Ruby Adds WebAssembly Support: what does it mean? (semaphoreci.com)
• Introduction - Rust and WebAssembly (rustwasm.github.io)
• Ruby in WebAssembly | Fermyon • Experience the next wave of cloud computing.
• getty104/ruby-wasm-vdom (github.com)
• ruby/ruby.wasm: ruby.wasm is a collection of WebAssembly ports of the CRuby. (github.com)
• Midscore-IO/wasmtime: A fast and secure runtime for WebAssembly (github.com)

🖥️...⌨️

• Art/Drawing
• Coding Freeimage
• Learning Linear Algebra
• Working The Server Backend
• Taking Our notes and converting it into something far better
• Formatting the time strings so they output a more readable value
• Ordering the right components
• Ordering second life premium on ArityWolf Resident (don't skimp)
• Ordering mom's computer

Drawing Priority

1. Leonardo/ArtRage
2. Clip Studio Paint (flat colors, inks)
3. Krita (32-bit colors)
4. Clip Studio Paint (perceptual brush)

Coding Priority

1. Create a library of vector and matrice functions for free-image, based on what you've learnt.