Hey folks! I think this request is right up this comm’s alley. I’m sure that we all know bogo sort but, what other terrible/terribly inefficient algorithms, software architecture, or design choices have you been horrified/amused by?

I, sadly, lost a great page of competing terrible sorting algorithms, but I’ll lead with JDSL as a terrible (and terribly inefficient) software architecture and design. The TL;DR is that a fresh CS guy got an internship at a company that based its software offering around a custom, DSL based on JSON that used a svn repo to store all functions in different commits. The poor intern had a bad time due to attempting to add comments to the code, resulting in customer data loss.

  • sus@programming.dev
    link
    fedilink
    arrow-up
    11
    ·
    edit-2
    11 months ago

    slow inverse square root:

    float slowinvsqrt(float x)
    {
        const long accuracy = 100000000;    // larger number = better accuracy
        if (x <= 0.0f) {
            return NAN;
        }
        if (x == 1.0f) {
            return 1.0f;
        }
        if (x < 1.0f) {
            return 1.0f / slowinvsqrt(1.0f/x);
        }
    
        int max_power = log(accuracy) / log(x);
        long pow1 = pow(x, max_power - 1);
        long pow2 = pow(x, max_power);
        double current = 1.0;
        double previous = 1.0;
    
        for (long i = 0; i<10*accuracy; i++) {
            current = sin(current);
            if (i == pow1) {
                previous = current;
            }
            if (i == pow2) {
                return current / previous;
            }
        }
    }
    
  • Corbin@programming.dev
    link
    fedilink
    English
    arrow-up
    7
    arrow-down
    1
    ·
    11 months ago

    There are subfields of computer science dedicated to this question. A good starting point for the theory would be Pessimal algorithms and simplexity analysis, which lays out two concepts:

    • The time & space simplexity of an algorithm indicates best-case lower bounds on resource usage, and
    • An algorithm is pessimal if no equivalent algorithm wastes more time/space/etc.

    For example, common folklore is that sorting has O(n lg n) time complexity, depending on assumptions. In the paper, they give that sorting has Ω(n ** (lg n / 2)) time simplexity; any algorithm which takes more time, like bogosort, must do so through some sort of trickery like non-determinism or wasting time via do-nothing operations.

    • Mesa@programming.dev
      link
      fedilink
      arrow-up
      4
      ·
      11 months ago

      https://thedailywtf.com/articles/gotta-catch-em-all

      Dear God.

      try
      {
          /* ... some important code ... */
      } 
      catch (OutOfMemoryException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (OverflowException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (InvalidCastException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (NullReferenceException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (IndexOutOfRangeException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (ArgumentException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (InvalidOperationException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (XmlException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (IOException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (NotSupportedException exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      catch (Exception exception)
      {
          Global.Insert("App.GetSettings;", exception.Message);
      }
      
    • yogsototh@programming.dev
      link
      fedilink
      arrow-up
      2
      ·
      11 months ago

      Technically, sleep sort is O(n), so faster than the theoretical optimal sorting algorithm O(n.log n) … not so bad ;)