Work to Survive!

Work to Survive! is a type of esolang (as well as a language standard) that forces the user to waste CPU cycles to "work" in order not to get the main process killed.

Specifications (Work to Survive! 1.0)

The user can work in Work to Survive! by calling the obscure work_to_survive function and specifying the amount of work (usually represented by a duration of time) that they are willing to do.

The user starts with some remaining_time worth of time, and must complete works to gain more remaining_time. When a Work to survive! runtime environment detects that a program's remaining_time is equal to or less than 0ms, it must terminate the program immediately.

Tips for Work to Survive! implementation vendors:

• If you choose to use some units of time to represent the work amount (for this example: milliseconds), then completing the work is required to take at least work milliseconds. It doesn't matter how much more time it actually takes, so it is fine to write a work_to_survive function with considerable overhead.

• Regarding the time reward that the user gets for working, it is not specified in the standards. But the general recommendation is 1.5x the amount of work done in a fast language like C++ and 2x in a slower one like Python.

• In order to promote fair trade, the user is not allowed to hoard more than 1 second of remaining time. All implementations can freely define how to punish the user should this rule be violated.

• It is not allowed to use anything other than the main thread to do the works. However, what actually happens when the user violates this rule is implementation-defined.

Implementations

The following is a C++ implementation that anyone can include into their C++ source code to create a program that is accepted by the Work to Survive! 1.0 standards:

#include <chrono>
#include <future>
#include <iostream>
#include <thread>

////////////////////////// Work now or Die!! ///////////////////////////
// * You have to work to survive                                      //
// * You can only work in the main thread                             //
// * You start with 100ms of time                                     //
// * It is illegal to have more than 1000ms of time                   //
// * work >  0ms : Do work and get 1.5x the time you worked as reward //
// * work <= 0ms : See the remaining time                             //
////////////////////////////////////////////////////////////////////////
auto work_to_survive(std::chrono::milliseconds work = {}) -> std::chrono::milliseconds {
  using namespace std::chrono_literals;
  
  static std::thread::id           main_thread_id = std::this_thread::get_id();
  static std::mutex                time_mutex;
  static std::chrono::milliseconds remaining_time = 100ms;
  static std::chrono::time_point   prev_time = std::chrono::high_resolution_clock::now();
  
  //// Time is ticking
  time_mutex.lock();
  auto now = std::chrono::high_resolution_clock::now();
  // std::max punishes those who call the function too frequently
  remaining_time -= std::max(std::chrono::duration_cast<std::chrono::milliseconds>(now - prev_time), 1ms);
  prev_time = now;
  time_mutex.unlock();
  
  //// Return the remaining time if not working
  if (work <= 0ms || std::this_thread::get_id() != main_thread_id) return remaining_time;
  
  //// It's Working Time!
  std::this_thread::sleep_for(work); // Do work
  std::lock_guard lock(time_mutex);
  remaining_time += std::chrono::duration_cast<std::chrono::milliseconds>(work * 1.5); // Get your reward
  return remaining_time;
}

////// Set up a time bomb to punish those who don't work (or those who work too much!)
const volatile auto ____start_working_now_or_die = (work_to_survive(), std::async([]() {
  using namespace std::chrono_literals;
  
  while (true) {
    std::this_thread::sleep_for(10ms); // Check on the employee every 10ms 😈😈
    auto remaining_time = work_to_survive(0ms); // Check the time
    if (remaining_time <= 0ms || remaining_time > 1000ms) break;
  }
  
  std::terminate(); // Punish the lazy or overworking employee
}));