Alright, lets hear YOUR plans or ideas to Global Warming and Food Shortages Globally

[8Lou1]

im not well versed in arabic, but i have some interconnections who do and they post their spiritual witchcraft pics online somewhere. they are telling me that there are wise snakes who show themselves as houncy's, that which westerners might prob call the fates. these beings are able to eat tru the mist and help you become more, from your neutral centre, so you can have a moving centre aka a path. funny i typed ptah ( egyptian god ), so there you have it....

 

[Diluculo_DelFuego]

I did get rebuffed on quota regarding my idea of dumping ice slabs retrieved from gas and ice giants, the chemical composition would be the equivalent of dumping into the oceans a hydrogen or worse explosion. A lot of free seafood perks as the benefit.
Here was code I was working on regarding simulation of it:
Granted, this is skeletal at best and needs engineers to work on it.
#!/usr/bin/python
import net
import os
import math
import sys

'''C Program to calculate atmospheric conditions, compared to ideal model,
and returning differential results. A differential in this context are
essentially a handful of files, which has the most up to date data contained
in them, or in sections of them?'''

'''One light year is actually 9.5*10^15m == approx 63240 AU'''
LIGHT_YEAR_AU == 63240;
'''One Parsec is 3.26 Light Years'''
ONE_PARSEC == 3.26;


'''A linked list of vague data types, in order to fit single parameters or
multiple parameter pass to functions'''
'''typedef struct LIST {} list;list l;'''
'''Funtion Prototypes
Delta(d);
list FOfX(l)
FOfX(x);
differential();
calculate_differential();
compare_differential_sets();
create_diff_set ()
main ();
'''

'''
Function Declarations
'''
'''Delta(a1,a2,x,d)'''
def Delta (a1, a2, x, d):
a1 = y;
a2 = x;
d = (a2-a1);
return d;

'''
list FOfX(l):
FOfX()
return l;
'''

'''
Basic differential code. Equations based on circumstance. The maths definition of the derivative
begins with a difference approximation:
Eqtn: Delta / Delta(t) = (FOfX(t[1]) + Delta(t)) - FOfX(t[1]) / Delta(t))
'''
def FarenheitToCelcius ( deg, F, C, Temp ):
print "\nEnter F or C: "
read Temp;
if Temp = "F"
then TempF = Temp;
else TempC = Temp;
endif
print "\n\nEnter degrees: "
read deg;
TempC = ( (5 / 9) * ( TempF - 32 ) );
return Temp;

def loadArrayOfElements(AoE,a):
foreach a in ArrayOfElements:
idealAtmosphereModel(AoE);
a = AoE;
return a;

def differential (LHand, RHand, t, y, Differential):
""" void extern LHand, RHand; """
for (l=0; l < n; ++l):
LHand = ( Delta / Delta (t) );
RHand = ( (FOfX(t[1]) + Delta(t)) / ( Delta(t) ) );
return Differential;

def calculate_differential():
'''This calculates the difference between the atmosphere of celestial bodies'''

return calculatedDifferential;

def compare_differential_sets():
'''Compares two sets of atmospheric data and return differences'''
return diff_compare_set;

def create_diff_set ():
'''Creates a differential set'''
return differential_set;

'''The stage for the magic to happen awaits til now'''
main():
char* target;
float radius, mass, solDistance;
printf("\n\nAtmospheric Conditions of target Celestial Body\n\n");
printf("\nYou will be prompted by questions, if unknown or absent reply NA");
printf("\n\nEnter Name of Celestial target Body: ");
scanf("%s",&target);
printf("\n\nEnter Radius of Celestial Body %s: ",&target);
scanf("%f",&radius);
printf("\n\nEnter Sun distance of Celestial Body %s: ",&target);
scanf("%f",&solDistance);
scanf("%s",&target);
return 0;




#!/usr/bin/python
import sys
import os
import math
import chillbed.h
import dryicebed.h
import chassis.h
"""
/* C Program to calculate conditions of the chill bed and the dry ice bed, the Chill Bed is a device */
/* that sits insiode a sectrion of the chassis of the craft, that has the sole purpose to keep an ice */
/* slab chilled for up to fifty years, considering average fuel and fluids use. The Dry Ice Bed is an */
/* insert over the Chill Bed. A parachute easy open is attached with a belt around the ice slab, for */
/* easy ejection out of the craft into the Arctic Ocean. Uses several existing formulas from HVAC Union. */

/* STILL UNDER CONSTRUCTION ALONG WITH ALL ELSE. */

float capacity(c);
float net_refridgeration_effect(void);
float coefficient_of_performance(void);
float compressor_displacement(void);
float heat_of_compression(void);
float volumetric_efficiency(void);
float compression_ratio(float CR; float Ph, Ps);
float calculate_differential(void);
float compare_differential_sets(void);
float create_diff_set (void)
float compressor(void);
float compression_work(float W,h,q);
float compression_horsepower(float P,W,hp,btu_per_minute);
void compression_hp_per_ton(void);
void main (void);
"""

""" capacity, net refridgeration effect, q """
def capacity(c,NRE,q):
c = q*NRE;
return c;

""" net refrigeration effect, british thermal unit, pounds """
def net_refrigeration_effect(NRE,btu,lbs):
NRE=btu/lbs;
return nre;

""" coefficient of performance, net refrigeration effect, heat """
def coefficient_of_performance(cop,nre,h):
cop = nre/h;
return cop;

def compressor_displacement(cd,d,c,v):
cd = ((c*v)/(nre));
return cd;

def heat_of_compression(h,hlc,hec):
h = hlc-hec;
return h;

def volumetric_efficiency(ve,wa,wt):
ve = (100*w*a)/(w*t);
return ve;

def compression_ratio(CR, Ph, Ps):
CR = compression_rate;
Ph = head_pressure_absolute;
Ps = suction_pressure;
CR = Ph/Ps;
return CR;


def compressor(a):
a = 0;
return a;

def compression_work(W,h,q):
""" Calculate compression work units. Compressor work can be expressed as:"""
""" W = h * q """
""" Where, """
""" W = compression work, with units Btu min. """
""" h = heat of compression, with units Btu per pound (lbs). """
""" q = refridgerant circulated, units lbs per minute. """
btu_per_minute = 0.0/60
W = btu_per_minute;
""" /* calculate heat of compression */ """
btu_per_pound = 0.0/16
h = btu_per_pound;
""" /* refridgerant circulated */ """
pound_per_minute = 0.0;
q = pound_per_minute;
""" /* calculate return value of W */ """
W = h*q;
return W;


def compression_horsepower(P,W,hp,btu_per_minute):
""" Compression horsepower can be expressed as: P = W / 42.4 """
compression_rate=0.0;
btu_per_minute = 0.0/60;
btu_per_minute=compression_rate/60;
hp=P*compression_rate;
W=btu_per_minute;
P=W/hp;
return P;

def compression_hp_per_ton(compressionHpPerTon,p,cop):
p = 4.715/cop;
return compressionHpPerTon;

def calculate_differential():
dy = 0.0;
dx = 0.0;
f_X = 0.0;
differential = 0.0;
f_X = (dy/dx);
differential = f_X;
order = 1.0;
differential = ((d * d) * y) / (d * (x * x )) + y ;
if [ differential != 0 ]:
order = 1.0;
return order;
else:
yield
return differential;

infile = fopen("/home/jcameron/scripts/python_scripts/diffFile.txt","+r");
outfile = fopen("/home/jcameron/scripts/python_scripts","+r");
diff_setFile = fopen("/home/jcameron/scripts/python_scripts/diffFile.txt","+w");

def compare_differential_sets(differential,infile):
diff_compare_set = echo infile | grep differential >> outfile;
diff_compare_set = echo diff_setFile | grep differential >> outfile;
return diff_compare_set;

def create_diff_set (diff_set,infile,outfile):
diff_set = diff infile outfile >> diff_setFile
return differential_set;

""" /* this is where all the magic happens */ """
def main():
CR = compression_rate;
Ph = head_pressure_absolute;
Ps = suction_pressure;
printf("\nPlease enter compression rate expected: ");
scanf("%f",&CR);
printf("\nPlease enter head pressure absolute: ");
scanf("%f",&head_pressure_absolute;
printf("\nPlease enter suction pressure expected: ");
scanf("%f",&suction_pressure);
compression_work();
float compression_rate=0.0;
float btu_per_minute = 0.0/60;
printf("\nPlease enter value of expected compression rate: ");
scanf("%f,&compression_rate);
printf("\nPlease enter value of expected compression work: ");
scanf("%f,&btu_per_minute);
compression_horsepower();
def init(self, file):
self.file = file
def interactive(self):
"""interactive deletion mode"""
input = raw_input("Do you really want to delete %s [N]/Y" % self.file)
if input.upper():
print "DELETING: %s" % self.file
status = os.remove(self.file)
else:
print "Skipping: %s" % self.file
return
def dryrun(self):
"""simulation mode for deletion"""
print "Dry Run: %s [NOT DELETED]" % self.file
""" return"""
"""if [ ! [ -e [ file.txt ]]]:"""
calculate_differential();
compare_diiferential_sets();
return differential_set();



#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "circuit.h"

void add_circuit (void);
void draw_circuit(void);
void del_circuit (void);
void create_circuit_img (void);
void write_circuit_img (void);
void main(void);

def isPowered(terminalIn, terminalOut, isPoweredResult):
if ((terminalIn == 1 ) && (terminalOut == 1)):
isPoweredResult = 'True';
elif ((terminalIn == 1) && (terminalOut == 0)):
isPoweredResult = 'True';
else:
isPoweredResult = 'False';
return isPoweredResult;

def add_circuit ():

return circuit_image;

def draw_circuit(circuit_image):

return circuit_image;

def del_circuit (circuit_image):

return 0;

def create_circuit_img (circuit_image):

return circuit_image;

def write_circuit_img (circuit_image,tempImage):

return circuit_image;

main():

return circuit_image;




This shows some thought trying to be put into a simulator to see if the idea has any merit whatsoever.
Im not impressed by billionaires circling the moon or a mars rover. Show me something that has merit, NASA.

 

[8Lou1]

i notice an energetic change when im reading your post, maybe i get more out of it later. i will post when that happens.

 

[Diluculo_DelFuego]

Here is the actual simulator code I think, I have like thirty programs and header files I was writing, in addition to the stattest program, which reports runaways over time as well as returns, motivational messages and help numbers to be put on billboards and LED displays.

#!/usr/bin/python
import os
import stdio
import sys
import stdlib
import math
import "circuit.h"
import "space.h"
import "chassis.h"
import "asm.h"

"""
void start_from_earth (void);
void calculate_distance(void);
void get_planet_choice(void);
void calc_distance_to_choice(void);
void set_firing_circuits(void);
void calc_mass(void);
void chassis_blastoff(void);
void arriving_at_choice(void);
void ice_slab_sniffer_send(void);
void ice_slab_sniffer_retrieve(void);
void choose_ice_slab_loop(void);
void extract_ice_slab_loop(void);
void store_ice_slab(void);
void return_to_earth(void);
void dump_slab_in_arctic_ocean(void);
void add_circuit (void);
void draw_circuit(void);
void del_circuit (void);
void create_circuit_img (void);
void write_circuit_img (void);
void transcript(void);
void main(void);
"""
def start_from_earth ():
""" /* set launch rail, read status of switch */
/* confirm goahead for throttle up from tower */
/* get atmospheric conditions, confirm with tower */
/* set all for fire up */
/* start fire up on thrusters */
/* disconnect from launch rail DPDT_OFF */
/* ready set go */
/* check stratosphere */
/* leave stratosphere */
/* tower radio check */ """
calculate_distance();
return 0;


def calculate_distance():
return 0;


def get_planet_choice():
return 0;


def calc_distance_to_choice():
return 0;


def set_firing_circuits():
''' /* from undeveloped circuit.h */ '''
RAIL_DPDT_ON();
CHECK_BAY_DOORS();
SC_THROTTLE_ON();
SC_THRUSTERS_ON();
LIQUID_TUBE_TEST();
if IS_OK( LIQUID_TUBE_TEST()):
then
{
FILL_HYDROGEN_TUBES();
}
else:
RADIO_CHECK();
PAUSE();
if IS_OK( RADIO_CHECK() ):
then
THRUST_CONFIRMED();
RAIL_DPDT_OFF();
FIRE_THRUSTER_ON();
BOOSTER_ON();
return 0;


def calc_mass():
return ice_slab_mass;


def chassis_blastoff():
return 0;


def arriving_at_choice(position, target):
position = target;
yield position;


def ice_slab_sniffer_send():
scalar position_distance, target_distance;
return 0;

def ice_slab_sniffer_retrieve():
return 0;


def choose_ice_slab_loop():
return 0;


def extract_ice_slab_loop():
return 0;


def store_ice_slab():
return 0;


def return_to_earth(craft_id, parsecs, lat, long, num_slabs):
return 0;

def dump_slab_in_arctic_ocean():
return 0;

''' /* circuit functions */ '''
def add_circuit (circuit):
yield circuit;


def draw_circuit(circuit):
yield circuit_image;


def del_circuit (circuit_img):
return (del(circuit_img));


def create_circuit_img (circuit_img):
return circuit_image;


def write_circuit_img (circuit):
return circuit_image;


def transcript():
return transcript;


def main()
transcript();
return 0;


def start_from_earth ():
'''set launch rail, read status of switch'''
'''confirm goahead for throttle up from tower'''
'''get atmospheric conditions, confirm with tower'''
'''set all for fire up'''
'''start fire up on thrusters'''
'''disconnect from launch rail DPDT_OFF'''
readySetGo()
checkStratosphere()
leaveStratosphere()
towerRadioCheck()
calculateDistance();
return 0;

def calculateDistance(d,Td,t):
Td = d/t;
return Td;

def get_planet_choice():
print"\n\nEnter jump (source) planet: "
''' Input jump (source) planet to target (destination) planet '''
''' scan answer '''
print "\nEnter target (destination) planet: "
calc_distance_to_choice;
calculateDistance(d,Td,t);
return planetList;

def calc_distance_to_choice():
a=0;
return a;

def set_firing_circuits()
''' from undeveloped circuit.h '''
RAIL_DPDT_ON = 1;
CHECK_BAY_DOORS = 1;
SC_THROTTLE_ON = 0;
SC_THRUSTERS_ON = 0;
LIQUID_TUBE_TEST();
RADIO_CHECK();
if IS_OK( LIQUID_TUBE_TEST() )
then:
FILL_HYDROGEN_TUBES();
else:
RADIO_CHECK();
PAUSE();
if IS_OK( RADIO_CHECK = 1 )
then:
FILL_HYDROGEN_TUBES();
EXTERNAL_TANK_ATTACHED = 1;
THRUST_CONFIRMED = 1;
RAIL_DPDT_ON = 0;
FIRE_THRUSTER_ON = 1;
BOOSTER_ON = 1;
SC_THROTTLE_ON = 1;
SC_THRUSTERS_ON = 1;
LIQUID_TUBE_TEST();
MAIN_ENGINE = 1;
TURBINES_ON = 1;
THUSTERS_ON = 1;
RADIO_CHECK();
else:
return 0;

calc_mass(M,d,a):
M = d/a;
iceSlabMass = M;
return M, ice_slab_mass;

def chassis_blastoff()
a=1;
return a;

def arriving_at_choice():
a=1;
return a;

def ice_slab_sniffer_send():
a=1
return a;

def ice_slab_sniffer_retrieve():
a=1;
return a;

def choose_ice_slab_loop():
a=1;
return a;

def extract_ice_slab_loop():
a=1;
return a;

def store_ice_slab():
a=1;
return a;

def return_to_earth():
a=1;
return a;

def dump_slab_in_arctic_ocean():
a=1;
return a;

def add_circuit ():
a=1;
return a;

def draw_circuit():
a=1;
circuit_image = a;
return circuit_image;

def del_circuit ():
a=0
return 1;

def create_circuit_img (void):
a=2
circuit_image=a;
return circuit_image;

def write_circuit_img (void):
a=0;
circuit_image = a;
return circuit_image;

def transcript():
a= 1;
transcript=a;
return transcript;

def menu():
a=a;
return a;

def main():
transcript();
menu();
return 0;


Probably my code would simply throw up errors everywhere, return garbage or do nothing. I reviewed a main function in one off the code samples that does IO but nothing else, for example. But the ideas behind the code are whats important, right?
Fact: Our world is heating up at an exponential rate nd needs immediate cooling.
Posit: Ice giants contain possible identical chemical compition.
Solution: Develop a spacecraft that can store multiple state sized slabs of ice. Retrieve ice slabs from ice giants, and dump in oceans.

Another possibility would be dumping it on mountain ridges or in deserts, which might yield interesting fruit.

Post automatically merged: Jan 14, 2023

Another idea is a space barge, which hauls trash close to the sun and slingshots "parcels" of flammable material casing into the sun.

Post automatically merged: Jan 14, 2023

Still yet is another idea, quit sucking tap water out of the natural lakes corporations, and deal with it.
We should work on converting saltwater to freshwater, considering the planet is what, 80% water?

 

[Crows&Ravens]

You can store seeds in freezers, seeds will last a minimum of 5 years, or even longer - 20+ years according to a source i found through a quick google search. It would be best to never open the freeze until it is time to harvest them. I wouldn't just store vegetable or fruits seeds but plants with medical properties as that would be one of the main issues in world disasters.

Having an indoor farm would be also great with UV lights, etc. I would also look into preserving food.

Post automatically merged: Jan 15, 2023

Develop a spacecraft that can store multiple state sized slabs of ice. Retrieve ice slabs from ice giants, and dump in oceans.

lol, i always thought about dumping a giant freezer.

Post automatically merged: Jan 15, 2023

II'm slightly still tired and i think i'm on a different subject, sorry.

 

[Diluculo_DelFuego]

I can say that this is, without the pro-militant dsurvivalist types, given the face of several United States weather disasters, it never hurts to be as fully prepared as possible.