FOG HORN

It’s been ages since we’ve had a shoot-the-shit, the challenge has been finding a topic, other than a rehash of the disastrous bullshit that inundates us today.

You might be asking what the hell is a shoot-the-shit, it is a social interaction during which any topic can be discussed. The great thing about a good shoot-the-shit is that participants don’t need to know anything about the subject being discussed, participants are free to make any unsupported comment, use uncensored profanity, insult anyone they wish or change the subject altogether. Shoot-the-shits have proven to be effective in mitigating the need to visit a psychologist, who is a jackass that majored in psychology so he or she could understand themselves. So without further delay, lets talk about artificial intelligence.

Artificial Intelligence, a.k.a. AI. AI’s potential is huge, but it also comes with a big set of challenges that ignite controversy and apprehension; much of which fueled by the media’s lackluster coverage of the topic. However, to be sure, there are a number of potential issues:

1. Bias: AI systems are trained on massive datasets, and if that data is biased, the AI can inherit that bias. This can lead to discriminatory outcomes in areas like loan approvals or criminal justice. For instance, an AI used in hiring decisions might favor resumes containing keywords associated with one gender over another.
2. Transparency: Sometimes, it’s hard to understand how AI reaches certain decisions. This “black box” effect makes it difficult to identify and fix biases, and can also raise concerns about accountability. For example, an AI used for loan approvals might reject someone’s application, but it wouldn’t be clear why.
3. Job displacement: As AI gets more sophisticated, there’s concern that it will automate many jobs currently done by humans. This could lead to unemployment and economic hardship. For instance, self-driving trucks could put a lot of truck drivers out of work.
4. Weaponization: Autonomous weapons systems raise serious ethical questions. These are weapons that can choose and attack targets without human intervention. Many experts worry about an arms race of such weapons, and the potential for unintended consequences.
5. Superintelligence: Some experts worry that very advanced AI could become uncontrollable and even a threat to humanity. This is a more speculative concern, but it raises important questions about the goals we set for AI development.

With full knowledge of the enumerated concerns the Department of Defense is moving aggressively towards integrating AI in its operations. Their goal? Shorten the kill chain.

Project Maven is a program by the U.S. Department of Defense that aims to integrate artificial intelligence (AI) into military operations. Here’s a breakdown of its goals and current status:

Goals:

Analyze imagery and video data from drones to identify potential targets . This could involve automatically detecting objects or people of interest.

Develop autonomous weapons systems like swarms of drones that can find and attack targets with minimal human input .

Current Status:

The National Geospatial-Intelligence Agency (NGA) now leads Project Maven].

AI systems are being tested on battlefields like Ukraine, but facing challenges in accuracy and real-world application.

The project is still under development, with ongoing debate about the ethics and effectiveness of AI in warfare.

I’m fortunate in that I have a technical background, so I decided to conduct my own test of an AI engine.

1. My initial test presented the engine with with the following task. (All Italics is AI generated)

• Task: generate a subroutine written in the BASIC computer language to calculate distance given rate and time. The AI engine generated the following

———————————————————————————————–

Here’s a BASIC program that calculates d = rxt:

INPUT "Enter the rate (r): "; r
INPUT "Enter the time (t): "; t

' Calculate the distance (d)
d = r * t

' Print the result
PRINT "The distance (d) is: "; d

END

This program first prompts the user to enter the rate (r) and time (t). Then, it calculates the distance (d) using the formula d = r * t. Finally, it prints the calculated distance to the console.

Here’s a breakdown of the code:

• • INPUT: This statement is used to get input from the user. The first line prompts the user to enter the rate and stores it in the variable r. The second line does the same for time and stores it in t.

• • d = r * t: This line calculates the distance d by multiplying the rate r and time t.

• • PRINT: This statement is used to output text to the console. The first line prints a message “The distance (d) is: “, and the second line prints the calculated value of d.

• END: This statement marks the end of the program.

Note: It not only wrote the subroutine in BASIC, it also explained the code, and yes it is executable code as written.

2.  I then tried a number of more challenging tasks. (All Italics is AI generated)

• Task: A target is moving East to West in a wind blowing out of the south. The target is moving at 12 mph at a distance of 300 meters. My projectile is traveling at 2650 feet per second and the barometric pressure is 30.02, how much of a lead do I need to give the target.

———————————————————————————————-

Calculating Lead for the Target

Here’s how to calculate the lead you need to give the target:

1. Convert units:

Target speed: We need the speed in meters per second.
12 mph * (5280 ft/mi) * (1 m / 3.28 ft) ≈ 5.4 m/s
Projectile speed: Convert feet per second to meters per second.
2650 ft/s * (1 m / 3.28 ft) ≈ 807 m/s

2. Wind effect (ignorable in this case):

The wind is blowing from the south, which is perpendicular to the target’s movement (East-West). A crosswind would push the bullet off course, but a headwind or tailwind has minimal effect on lead for a moving target. Therefore, we can mostly ignore the wind in this case.

3. Lead calculation:

Lead = (Target speed * Time of flight)

Time of flight is the time it takes for the bullet to travel the distance to the target. We can calculate it using the following formula:

Time of flight = Distance / Projectile speed

Time of flight = 300 meters / 807 meters/second ≈ 0.37 seconds

Lead = 5.4 meters/second * 0.37 seconds ≈ 2 meters

Therefore, you need to aim approximately 2 meters ahead of the moving target to hit it.

Note: This is a simplified calculation and doesn’t account for factors like bullet drop due to gravity. For long-range shooting or high-precision applications, you might need to consider these additional factors.

(*I ran a number of these scenarios and the AI engine produced only one false result. It did that when it interpreted the projectile velocity of 2650 feet per second as 2650 meters per second.)

3.  I then tasked the AI engine to write a C++ subroutine to calculate target lead (All Italics is AI generated)

• Task: A target is moving East to West in a wind blowing out of the south. The target is moving at 12 mph at a distance of 300 meters. My projectile is traveling at 2650 feet per second and the barometric pressure is 30.02, how much of a lead do I need to give the target? Write a c++ program to calculate target lead.

—————————————————————————————————————-

A target is moving East to West in a wind blowing out of the south. The target is moving at 12 mph at a distance of 300 meters. My projectile is traveling at 2650 feet per second and the barometric pressure is 30.02, how much of a lead do I need to give the target? Write a c++ program to calculate lead

Here’s a C++ program that calculates the lead required to hit a moving target considering wind but ignoring air resistance:

C++

#include <iostream>
#include <cmath>

using namespace std;

const double PI = 3.141592653589793;

// Function to convert meters to feet
double metersToFeet(double meters) {
  return meters * 3.28084;
}

// Function to calculate lead distance
double calculateLead(double targetSpeed, double projectileSpeed, double distance) {
  // Convert distance to feet
  double distanceFeet = metersToFeet(distance);
  
  // Calculate time for projectile to travel the distance
  double time = distanceFeet / projectileSpeed;
  
  // Calculate wind drift in feet
  double windSpeed = 12 * 5280.0 / 3600.0; // Convert mph to ft/s
  double windDrift = windSpeed * time;
  
  // Lead distance is wind drift in the direction perpendicular to target movement
  return windDrift;
}

int main() {
  // Target speed (mph)
  double targetSpeed = 12;

  // Projectile speed (ft/s)
  double projectileSpeed = 2650;

  // Distance to target (meters)
  double distance = 300;

  // Calculate lead distance
  double leadDistance = calculateLead(targetSpeed, projectileSpeed, distance);

  // Convert lead distance to meters (optional)
  double leadDistanceMeters = leadDistance / 3.28084;

  cout << "Lead distance: " << leadDistance << " feet" << endl;
  // Uncomment to display lead in meters
  // cout << "Lead distance: " << leadDistanceMeters << " meters" << endl;

  return 0;
}

Explanation:

1. Includes: Includes necessary libraries like iostream for input/output and cmath for mathematical functions.
2. Constants: Defines PI and conversion factor from meters to feet.
3. metersToFeet function: Converts meters to feet.
4. calculateLead function:
   • Converts distance to feet using metersToFeet.
   • Calculates the time taken by the projectile to reach the target using distance and projectile speed.
   • Converts target speed from mph to ft/s.
   • Calculates wind drift by multiplying wind speed with the travel time.
   • Since the wind is blowing south (perpendicular to target movement), the lead distance is simply the wind drift.
5. main function:
   • Defines target speed, projectile speed, and distance.
   • Calls calculateLead to get the lead distance in feet.
   • Prints the lead distance in feet (you can uncomment the line to display it in meters).

This program assumes the wind is purely perpendicular to the target movement. In reality, wind might have both a headwind/tailwind and crosswind component. A more complex model would be needed to account for these additional factors.

Note: This program ignores air resistance, which can affect the trajectory of the projectile at long distances.

What I’ve attempted to do with this shoot-the-shit is give you a glimpse of AI’s capabilities as it exists circa 2024. AI development is accelerating at a logarithmic rate and will eventually be able to generate its own algorithms without direct human intervention. The greatest threat to mankind as I see it, at this point in time, is human blind acceptance of AI’s accuracy, it could have catastrophic consequences.

Have a great weekend and schedule your own shoot-the-shit!

Note:

In tasking the AI engine with task 2 and 3, I intentionally omitted  two important pieces of data: direction of fire and wind speed. The AI engine performed the task given the data provided with explanation. It also suggests that the comprehensiveness of the dataset and its integrity are critically import to AI’s reliability, a requirement that makes datasets a desirable target for cyber attacks, or what I’ll describe as counter AI operations.