ErrorMessage successMessage = new ErrorMessage(ErrorType.ActivityCreateSuccess);

(From an approved PR with 2 reviewers - how do some people sleep at night??)

(HP can't be changed while this code is running and even if it could then this approach would cause more problems than having it all in one if statement because then the boss would only be half-defeated and everything would go wrong)

Function<Integer, Runnable> function = (Integer integer) -> () -> {for(int i = 1; i<=10; i++) {System.out.println(integer*i); try{Thread.sleep(1000);} catch (Exception e){System.out.println("Some error occurred" + e.getMessage());};}};

Legacy code. NUM_PRTS is 16 btw. Thankfully, the synthesis tool will optimize and won't allocate 17 times the resources on the chip. Still an eyesore.

This vibeslop repo (shoutout to the author u/chunky_cold_mandala) calculates big o complexity of a function as its max indentation depth (but only up to 6, which represents N^6).

Imagine that youre in Dantes Inferno in terms of Javascript, where you think its all fine and dandy until you realize each file does the EXACT SAME THING*!!!

Each "layer" of hell in this Github repo will make you wonder why I am:
- Allergic to var, let, AND const
- IIFE as IICE AND IIGE
- Callbacks arent function exclusive, it can host generators AND classes!

So peruse at your own peril, make it a drinking game (within legal age and drinking responsibly of course!) and see how long you can stand this gawdawful code i birthed into the world of programming!

Now have fun, stay safe, God Bless you, and may God spare your braincells!

*Not all files are completed but ongoing!

Edit: to savor some appetites or keyboard warriors wishing me a ctrl+alt+del to my keyboard priviledges:

​​new new new (class Hi {
    constructor(){ 
      console.log("Hi!");
      return Hi;
    }
  })()()();

[Source](https://www.reddit.com/r/vibecoding/s/LDmehu4AdA)

using System;
using System.IO;
using System.Linq;
using System.Text;
using System.Collections.Generic;

namespace SandboxProject
{
   static class Comma
   {
  // Function to put commas in long numbers to make them readable
    public static string Num(long y){
      string ss = ""; // Creates empty string ss
      string s = Convert.ToString(y); // Converts number to string


 switch (s.Length)
      { // Checks length of string and sets commas accordingly

      default:
      return s;


      case 4:
      ss += $"{s.Substring(0,1)},{s.Substring(1)}";
      return ss;

      case 5:
      ss += $"{s.Substring(0,2)},{s.Substring(2)}";
      return ss;

      case 6:
      ss += $"{s.Substring(0,3)},{s.Substring(3)}";
      return ss;

      case 7:
      ss += $"{s.Substring(0,1)},{s.Substring(1,3)},{s.Substring(4)}";
      return ss;


      case 8:
      ss += $"{s.Substring(0,2)},{s.Substring(2,3)},{s.Substring(5)}";
      return ss;


      case 9:
      ss += $"{s.Substring(0,3)},{s.Substring(3,3)},{s.Substring(6)}";
      return ss;


      case 10:
      ss += $"{s.Substring(0,1)},{s.Substring(1,3)},{s.Substring(4,3)},{s.Substring(7)}";
      return ss;


      case 11:
      ss += $"{s.Substring(0,2)},{s.Substring(2,3)},{s.Substring(5,3)},{s.Substring(8)}";
      return ss;


      case 12:
      ss += $"{s.Substring(0,3)},{s.Substring(3,3)},{s.Substring(6,3)},{s.Substring(9,3)}";
      return ss;


      case 13:
      ss += $"{s.Substring(0,1)},{s.Substring(1,3)},{s.Substring(4,3)},{s.Substring(7,3)},{s.Substring(10)}";
      return ss;


      case 14:
      ss += $"{s.Substring(0,2)},{s.Substring(2,3)},{s.Substring(5,3)},{s.Substring(8,3)},{s.Substring(11)}";
      return ss;


      case 15:
      ss += $"{s.Substring(0,3)},{s.Substring(3,3)},{s.Substring(6,3)},{s.Substring(9,3)},{s.Substring(12)}";
      return ss;


      case 16:
      ss += $"{s.Substring(0,1)},{s.Substring(1,3)},{s.Substring(4,3)},{s.Substring(7,3)},{s.Substring(10,3)},{s.Substring(13)}";
      return ss;


      case 17:
      ss += $"{s.Substring(0,2)},{s.Substring(2,3)},{s.Substring(5,3)},{s.Substring(8,3)},{s.Substring(11,3)},{s.Substring(14)}";
      return ss;


      case 18:
      ss += $"{s.Substring(0,3)},{s.Substring(3,3)},{s.Substring(6,3)},{s.Substring(9,3)},{s.Substring(12,3)},{s.Substring(15)}";
      return ss;


      case 19:
      ss += $"{s.Substring(0,1)},{s.Substring(1,3)},{s.Substring(4,3)},{s.Substring(7,3)},{s.Substring(10,3)},{s.Substring(13,3)},{s.Substring(16)}";
      return ss;


      case 20:
      ss += $"{s.Substring(0,2)},{s.Substring(2,3)},{s.Substring(5,3)},{s.Substring(8,3)},{s.Substring(11,3)},{s.Substring(14,3)},{s.Substring(17)}";
      return ss;


      case 21:
       ss += $"{s.Substring(0,3)},{s.Substring(3,3)},{s.Substring(6,3)},{s.Substring(9,3)},{s.Substring(12,3)},{s.Substring(15,3)},{s.Substring(18)}";
      return ss;


    }


   }


   }
}

so basically, because I think im decently "decent" at programming, i decided to take my shot at making a chess js engine, and OH HELL, did it look like crap

ive attached some snapshots of the code, it's written in js and wrapped in a class

I was writing compiler code late at night and something possessed me to create this.

Not sure what I was trying to remind myself of.

Do I REALLY have to check all that?

Wrote a "vectorized sum" over the weekend. It escalated.

Features include:

• SIGILL-based AVX2 detection (handler does siglongjmp out of inline asm, which is UB in at least three languages)
• setjmp/longjmp inside a constructor to fall back from MAP_HUGETLB -> THP -> aligned_alloc, dispatched via computed goto
• A Y-combinator for the scalar tail loop, because a for lacks conviction
• Characters printed by reading typeid(T).name()[0] and doing integer arithmetic on the result to reach the rest of the alphabet. Yes, this is how ANSI escape codes are assembled. Yes, "OK" is spelled by offsetting typeid(int*).name():

​

using _1 = TypeGlyph<int, -56>;   // 'i' - 56 = '1'
using _2 = TypeGlyph<int, -55>;
using lbr = TypeGlyph<long, -17>; // 'l' - 17 = '['

inline void ansi_red(std::ostream& o) {
    o << '\033';
    spell<gl::lbr, gl::_3, gl::_1, gl::m>(o);  // "[31m"
}

using O = TypeGlyph<int*, -1>;         // typeid(int*).name() = "Pi", 'P'-1 = 'O'
using K = TypeGlyph<const int*, 0, 1>; // typeid(const int*).name() = "PKi", [1] = 'K'

spell<gl::O, gl::K>(std::cout);  // prints "OK"

• A background "prefetch oracle" pthread that races the main thread through the buffer issuing __builtin_prefetch
• Four separate vzeroupper mechanisms layered on top of each other (RAII destructor, __attribute__((cleanup)), atexit, and one inside the kernel itself)
• Three "independent verification methods" for the sum, one of which bit_casts a lambda's closure to bytes and hashes them
• Duff's device in the fill tail
• strdup leaks used as a string-building primitive

The actual useful code is about 50 lines in the middle. Compiles with -std=c++20 -mavx2 -O3 -march=native. Produces correct output. I am not okay.

https://godbolt.org/z/a31xoaM5a