Big Clodsire with Tiny Balloon @wallhackio@cat.family

@vaporeon_ the Java community also has a bad habit of what I'll call "Premature Generalization" where people where make a generic framework for something that is only used for a specific use case, making the API for it much more complicated than you want

You don't really see people using Spring for anything other than RESTful backends, and yet Spring is a generic application tool for using dependency injection in Java applications. It's so tedious to learn

@vaporeon_ once I use Java enough and get in the Java Zone I don't actually hate the language itself, but more the standard library and the excessive OOP people who use Java keep falling into (although I suppose it's fair to criticize a language if it incentivizes people to write bad code)

@vaporeon_ I find it extremely Uninteresting

@aescling @vaporeon_ oh this was an inefficient implementation of Dutch National Flag too, lol

@aescling @vaporeon_ if you are wondering this is using the Dutch National Flag partition, which is the actual real name for it, and I simulated recursion using a stack (a JavaScript array has methods on it that allow it to easily resemble a stack)

I used the ninther strategy for the pivot selection but that was not present in this snippet

@vaporeon_ and because OOP was all the rage in that time period (it wasn't around ~2010 that the software engineering world was like, maybe we shouldn't solve everything with OOP)

@aescling @vaporeon_ nope :)

@vaporeon_ I am currently not working there, I was laid off in June, but yes it was

This is actually extremely normal since Java was extremely popular during the dot.com boom of the late 90's/early 2000's and the most appealing alternative was C++, so obviously people used Java instead

An enormous amount of critical codebases run on Java

@vaporeon_ okay here's a bad one. i implemented a non-recursive quicksort using the variables gorp, norp, and sorp:

const partition = (arr, start, end, strategy) => {
  const q = [[start, end]];
  while (q.length > 0) {
    const [left, right] = q.pop();

    const p = strategy(arr, left, right);
    const pVal = arr[p];
    swap(arr, p, right);

    let gorp = 0;
    let norp = 0;
    let sorp = 0;

    const L = right - left + 1;

    for (let i = 0; i < L - 1; ++i) {
      const curr = left + gorp + sorp;
      if (arr[curr] === pVal) {
        swap(arr, left + sorp, curr);
        ++sorp;
      } else if (arr[curr] > pVal) {
        swap(arr, curr, right - norp - 1);
        ++norp;
      } else {
        ++gorp;
      }
    }

    for (let j = 0; j < gorp; ++j) {
      swap(arr, left + j, left + sorp + j);
    }
    swap(arr, left + gorp + sorp, right);

    if (gorp > 1) q.push([left, left + gorp - 1]);
    if (norp > 1) q.push([left + gorp + sorp + 1, right]);
  }
};

@vaporeon_ I know how this is gonna go. I will show it to you and then you'll be like, wait this is cool I like it :)

@vaporeon_ full-stack software eggineer ​

@coriander Aspartame, son of Stevia

@vaporeon_ I've done DS&A problems in JavaScript and written some nightmarish oneliners doing that

@monorail @vaporeon_ my worst code practices occur when i hack a solution to a challenging data structures/algorithms problem

@vaporeon_ it said she is cool in many ways

@vaporeon_ this is not a slight on Holly. i hope that is clear. she does code golf so you know she actually likes coding for the hell of it

:

When employing Object-Oriented Programming, never forget APIE. We use OOP so that our code is

Abstract,
Polymorphic,
full of Inheritance, and
Extremely dogshit