The phone

No one wants a job with the phone in there, and if they wanted one, they go to the ppl just giving them a job without asking questions or long process

And telling you how much they pay

Leave a unhealthy relationship without thinking about money

To your country, your job, or a person

Like countries are fine their claim is the military and police

Whats left then is living

Its the renting situation

But i am sure ppl will find a solution then

And food

Then base needs are met

Without having to make deals with ppl for basics

Thats what i would like to see

Capitalism did great, in movin things away from

You have to make a deal with the old woman your family knows from wherever

And shes a bich not actually counting and just upping requirements

Like capitalism did a great one on that

Making everyone having to count

And in the same way we go a level up from that

Like if food and living are handled

Then money really is a play thing

The thing with renting is

The property was payed for, but rent is monthly

Is a abstraction of time where someone extracts value

Like the free market still exists

Its just not the measure for everything

The big difference

Between open source and normal companies is the money flowing threw the system

So lets run some money threw it

It has the amazing open source work conditions and you get payed

Like jobs currently have a monopoly

On the worker market

Thats not fair

Competition is good for the market

Like you can do the temporal abstraction which balances the random money flow into increments

The project itself can just sit on it

Like some ppl will still prefer where they can make the most money by performance

But most ppl dont care

They happy when they get payed

Money just becomes another metric

You still use it, but its not as life defining

You could quit your job and still be fine

Bc there is no gatekeeper stopping you from joining something else

visual updates xx

for redability and mocile

They just don’t like having someone to distribute money

Bc they like distuributed systems

So like this, everyone can just work on a project collectively

And the resources get distributed

Like what ppl dont like is resources getting funneled off

Either it goes to the project or the ppl working on it, but not 1 person disproportionately

Like if everyone decides that person should get more they can just send them some money

But not by default

Thinking about servers

That can be run local

,, ahh bc companies

Thats good

That means if someone has a server they have a security team

Everyone else can do it locally

Like thats the savest option

All the transaction stuff is handled externally by monero

They are quite invested in keeping their stuff up to date

, and private

The failure tolerance for that is quite low

Like we need at least user error detection on the same level

But for now its for internal use

Once its live

We connect it to the donation adress

Aah Server, bc of cron, i see

And it distributes

Like you can purely focus on doing stuff

Put your money in the box and everyone gets payed

The server can pay itself

No one holds the risk of having to pay things

Its does it

Like the users never encounter the money

Its a background process distributing it

They can focus on build whatever they build

You could have like a company structure, but also you don’t need to

No requirements to join, no requirements to leave

Like ppl will try to do that anyways and thats fine

But it should run just fine without that

Like ppl can test different levels of gatekeeping based on what they prefer, and i am sure they will

Like biggest issue i see

Is dead wallets

Like internally no issue

Publically

Idk just remove everything thats older than a year

Like even on fedi, you can just let ppl verify their domains or something

https://youtube.com/watch?v=IbZXgW2YSvk&si=r9PZw6ZKz1ZmUlD0

https://youtube.com/watch?v=WC8Et3ZCRgA&si=hGs-ong38nfkGtB8

Dont design mechanical systems like that tho

Running things into errors on purpose just works with code

is querry sucessfull under querry unlocked balance

ther e it says , nope adresses are fake, nope

i will looking into connecting to a open testnet node and then running a dry run to see if everything is working

The networking is giving me trouble

It installs, it makes wallet,

But it needs the rpc daemon with a opem node and a local wallet

, i will see

Maybe the port is not open~

Either it does not like me feeding it dummy adresses

, like i just wanna see if it fails at the right points

So the rpc is running, which explains why it can get the balance of 0

Yes, its complaining they are not real adresses

That is good, if it takes fake data its not live

https://youtube.com/watch?v=ed-DNgTcsBA&si=J9Ydeyj7VmNiC6jg

https://youtube.com/watch?v=OsB5jTfivkw&si=_HhM4mDepkJIly6M

https://youtube.com/watch?v=kDQcvIMbIAk&si=5pwjpUcL1HxPnMOu

https://youtube.com/watch?v=1KBWCe-YbUg&si=k4Brz9xgTXgDqCWL

https://youtube.com/watch?v=AJQRigcfLKY&si=Bl0JGpOUEV4kvCoO

This girl

Never fails to amaze me

Shred a box

Certainly! To prevent the script from potentially affecting system components, you can add a safety check to ensure that the generated command doesn’t start with a critical system command (e.g., rm, mv, etc.). Here’s the modified script with this safety check:#!/bin/bash # Fetch command names from the /bin folder commands=($(ls /bin)) # File to store executed combinations executed_file="executed_combinations.txt" # Function to generate combinations and check execution generate_and_check_combinations() { local combination="$1" # Safety check to prevent affecting system components if [[ $combination =~ (^|\|)\s*(rm|mv|cp|chmod|chown|dd)\s* ]]; then echo "Unsafe combination detected: $combination" return fi local result=$(eval "$combination" 2>/dev/null) if [ $? -eq 0 ]; then # Check for duplicate before saving if ! grep -Fxq "$combination" "$executed_file"; then echo "Executing: $combination" echo "$combination" >> "$executed_file" echo "Combination executed and saved." else echo "Combination already executed: $combination" fi else echo "Combination failed: $combination" fi } # Infinite loop for continuous checking while true; do # Generate a random combination (replace this with your logic) random_combination="" for ((i=0; i<3; i++)); do if [ $((RANDOM % 2)) -eq 0 ]; then random_combination+=" /bin/${commands[$((RANDOM % ${#commands[@]}))]}" fi if [ $((RANDOM % 2)) -eq 0 ]; then random_combination+=" | " fi done # Check and save the combination generate_and_check_combinations "$random_combination" # Display the size of the executed_combinations.txt file file_size=$(du -h "$executed_file" | cut -f1) echo "Size of $executed_file: $file_size" # Adjust sleep duration based on your needs sleep 1 done

This safety check ensures that the generated command doesn’t contain certain critical system commands before attempting to execute it. Adjustments can be made based on your specific safety requirements.

#!/bin/bash

# Fetch command names from the /bin folder
commands=($(ls /bin))

# File to store executed combinations
executed_file=”executed_combinations.txt”

# Function to generate combinations and check execution
generate_and_check_combinations() {
    local combination=”$1″

    # Safety check to prevent affecting system components
    if [[ $combination =~ (^|\|)\s*(rm|mv|cp|chmod|chown|dd)\s* ]]; then
        echo “Unsafe combination detected: $combination”
        return
    fi

    local result=$(eval “$combination” 2>/dev/null)

    if [ $? -eq 0 ]; then
        # Check for duplicate before saving
        if ! grep -Fxq “$combination” “$executed_file”; then
            echo “Executing: $combination”
            echo “$combination” >> “$executed_file”
            echo “Combination executed and saved.”
        else
            echo “Combination already executed: $combination”
        fi
    else
        echo “Combination failed: $combination”
    fi
}

# Infinite loop for continuous checking
while true; do
    # Generate a random combination (replace this with your logic)
    random_combination=””

    for ((i=0; i<3; i++)); do
        if [ $((RANDOM % 2)) -eq 0 ]; then
            random_combination+=” /bin/${commands[$((RANDOM % ${#commands[@]}))]}”
        fi
        if [ $((RANDOM % 2)) -eq 0 ]; then
            random_combination+=” | “
        fi
    done
   
    # Check and save the combination
    generate_and_check_combinations “$random_combination”

    # Display the size of the executed_combinations.txt file
    file_size=$(du -h “$executed_file” | cut -f1)
    echo “Size of $executed_file: $file_size”

    # Adjust sleep duration based on your needs
    sleep 1
done

A distributing money

what i want, but a good start, now its possible to use tha math tools on the binary line, if its not doing something unexpectedxx

no, it doesnt, the input is wrong, its using the binary of the names instead of the file binatys , was worth a trytho

https://chat.openai.com/share/d328704e-2535-462d-baf0-ab0ca7845fee

The code does the following in simpler terms:

1. Turns Names into Numbers: It changes script names like “cat” or “ls” into numbers, making them easier to work with.
2. Predicts Future Numbers: Based on the pattern of the numbers, it guesses what the next few numbers could be.
3. Shows Predictions as Numbers and Lines: It draws a dark-themed chart showing both the original numbers and the guessed future numbers.
4. Saves the Chart: Finally, it saves this chart as an image file so you can see it anytime.

(new_venv) [lia@share ~]$ python3 grpx
python3 grpx
Original Program Name, Binary Number, Number Line Position:
ls, 0110110001110011, 27763.0
cat, 011000110110000101110100, 6513012.0
pwd, 011100000111011101100100, 7370596.0
echo, 01100101011000110110100001101111, 1701013615.0
grep, 01100111011100100110010101110000, 1735550320.0

Predicted Number Line Positions (Decimal and Binary):
Decimal: 2169430959.25, Binary: 10000001010011101110001110101111
Decimal: 2603311598.5, Binary: 10011011001010110110000111101110
Decimal: 3037192237.75, Binary: 10110101000001111110000000101101
Decimal: 3471072877.0, Binary: 11001110111001000101111001101101
Decimal: 3904953516.25, Binary: 11101000110000001101110010101100
/home/lia/grpx:78: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown
plt.show()
(new_venv) [lia@share ~]$ ^C

import matplotlib.pyplot as plt

def name_to_binary(name):
    """Convert a script name to its binary representation."""
    return ''.join(format(ord(c), '08b') for c in name)

def binary_to_decimal(binary_str):
    """Convert a binary string to a decimal (float) value."""
    return float(int(binary_str, 2))

def decimal_to_binary(decimal):
    """Convert a decimal (float) value to a binary string."""
    return format(int(decimal), 'b')

def linear_extrapolation(data_points, num_predictions=3):
    """Predict future values using linear extrapolation based on existing data points."""
    if len(data_points) < 2:
        raise ValueError("Need at least two data points for linear extrapolation.")
    steps = [data_points[i] - data_points[i-1] for i in range(1, len(data_points))]
    average_step = sum(steps) / len(steps)
    last_point = data_points[-1]
    predictions = [last_point + (i + 1) * average_step for i in range(num_predictions)]
    return predictions

# List of common script names
script_names = ["cat", "ls", "echo", "pwd", "grep"]

# Convert names to binary and map to decimal
mapped_values = []
name_binary_decimal_map = []  # Store tuples of (name, binary, decimal)
for name in script_names:
    binary_rep = name_to_binary(name)
    decimal_pos = binary_to_decimal(binary_rep)
    mapped_values.append(decimal_pos)
    name_binary_decimal_map.append((name, binary_rep, decimal_pos))

# Sort by decimal position
mapped_values.sort()
name_binary_decimal_map.sort(key=lambda x: x[2])  # Sort the mapping list by decimal values

# Echo the original program name, binary number, and number line position
print("Original Program Name, Binary Number, Number Line Position:")
for name, binary, decimal in name_binary_decimal_map:
    print(f"{name}, {binary}, {decimal}")

# Predict new number line positions
predicted_positions = linear_extrapolation(mapped_values, 5)

# Output the predictions in decimal and binary
print("\nPredicted Number Line Positions (Decimal and Binary):")
for position in predicted_positions:
    binary_rep = decimal_to_binary(position)
    print(f"Decimal: {position}, Binary: {binary_rep}")

# Prepare data for plotting
original_positions = range(1, len(mapped_values) + 1)  # Original positions for x-axis
predicted_positions_x = range(len(mapped_values) + 1, len(mapped_values) + 1 + len(predicted_positions))

# Setting the style to dark mode
plt.style.use('dark_background')

# Plotting original decimal values
plt.plot(original_positions, mapped_values, 'ro-', label='Original Values')

# Plotting predicted values
plt.plot(predicted_positions_x, predicted_positions, 'bo--', label='Predicted Values')

# Adding titles and labels
plt.title('Script Name Positions and Predictions')
plt.xlabel('Position')
plt.ylabel('Decimal Value')
plt.legend()

# Save the graph
plt.savefig('/mnt/data/script_positions_predictions_darkmode.png', dpi=300)

# Show the plot
plt.show()