Duolingo kündigt die Einführung von KI als Ersatz für Vertragsarbeiter an

Als ich versuchte, eckige Räder rund zu machen, musste ich an die Worte meines Chefs denken, man solle das Rad nicht neu erfinden. Diese "Erfinde-das-Rad-nicht-neu"-Gespenster gibt es in unserem Umfeld immer noch viele.

Davon abgesehen ist es schon sehr kategorisch, menschliches Eingreifen überhaupt nicht zu berücksichtigen,
bei einfachen Zahlen- oder Nachrichtenänderungen wäre menschliches Eingreifen doch effizienter als ein LLM.

Soweit ich weiß, garantiert das Setzen der temperature-Option auf 0 bei derselben Eingabe dieselbe Ausgabe.

Bei dem Satz „quickSort gehört zu quickSort“ fasse ich mir an den Hinterkopf.

LLMs garantieren bei derselben Eingabe nicht dieselbe Ausgabe – funktioniert so eine Art von Konfigurationsmanagement dann überhaupt ...
Nutze ich das bisher einfach noch viel zu eindimensional?

Bitte achten Sie beim Lesen unbedingt auf den Kontext.

Ich prahle hier nicht mit meinen aktuellen Coding-Fähigkeiten. Ich weise darauf hin, dass mangelhafter Code wie das hier als Beispiel verwendete quickSort() bei GPT mit hoher Priorität ausgegeben wird.

Wenn man GPT mehrmals durchsucht, wird oft einfach nur das Ergebnis einer einzelnen quickSort()-Funktion geliefert, und quickSort() ist wiederum nur ein Beispiel. Wenn man GPT für Arbeitszwecke um Code bittet, wird sehr oft Code mit viel zu niedriger Qualität ausgegeben (das ist meine Erfahrung als zahlender Nutzer). Wenn es Entwicklern selbst an der Fähigkeit fehlt, so etwas zu unterscheiden, stimme ich der Meinung des Autors im Haupttext zu, dass ein Projekt mit hoher Wahrscheinlichkeit in eine Richtung läuft, in der es kaputtgeht — und so bin ich zu diesem Kontext gekommen.

In meinem Umfeld nehmen Projekte, die mit solcherart miserablen Code überzogen sind, bereits ständig zu.

YOLO-Modus...

Ist das so aufgebaut, dass man in jedem Feld einen Block auswählen kann und nur das Aussehen mit CSS gestaltet wurde? Wirklich beeindruckend.

In der GPT-Antwort kommen sowohl quickSort als auch quicSortInPlace vor, und da in den Kommentaren auf den Teil [...,quickSort(left), ...equal, ...quickSort(right)] hingewiesen wurde, hatte ich verstanden, dass man quickSort mit quickSort und quickSortInPlace mit quickSortInPlace vergleichen sollte, aber offenbar ist das nicht so.

Wenn die Behauptung in dem Kommentar stimmt, hilft Google dann nicht faktisch bei kriminellen Handlungen?

Der Text selbst ist unterhaltsam, aber ich bin langsam etwas müde davon, dass sich so viele Beiträge im Grunde auf „Es ist nicht die Lösung für alles, keine AI zu nutzen, aber es ist genauso wenig gut, ihr blind zu vertrauen und sich von ihr abhängig zu machen“ zusammenfassen lassen..

Ich lerne viel dazu.

Natürlich sollte man die Performance der beiden Funktionen quickSort() und quickSortInPlace() vergleichen........

Ah … jetzt verstehe ich, was gemeint ist. Sie haben wohl nicht verstanden, was man womit vergleichen sollte … Der Quicksort-Algorithmus hat nicht zwei Implementierungsarten, nämlich quicksort und in-place …

Worauf ich von Anfang an hinauswollte, ist, dass es problematisch ist, quickSortGPT() und quickSort() im obigen Code (beides von GPT ausgegebener Code) zu schreiben und sie dann AI-Nutzern bereitzustellen, obwohl die Array-Zusammenführung bereits eingebaut ist.

Und dann teilt man ein Ergebnis, bei dem der Output mehr als doppelt, sogar drei- bis viermal so stark abweicht, und sagt anschließend, es seien wohl doch keine 2x?

Schon heute platzt mir manchmal der Kragen, wenn ich mit Entwicklern in ihren 40ern oder 50ern zusammenarbeiten soll, weil es Leute gibt, die noch auf die Art entwickeln wollen, wie vor Jahrzehnten. Persönlich denke ich, dass eine gesündere Gesellschaft entstünde, wenn junge Menschen wie in Japan nicht in Nebenjobs oder prekäre Beschäftigung gedrängt würden, sondern feste Stellen bekommen könnten, während ältere Menschen eher in Tagesjobs und Aushilfstätigkeiten arbeiten. In Korea werden die Arbeitseinkommen in einer umgekehrten Pyramide verteilt, deshalb wird es immer schlimmer, dass Aufstiegschancen nach oben weggezogen werden.

> Pflegeplattformen prüfen über Datenbroker die Kreditwürdigkeit von Pflegekräften und bieten niedrigere Löhne an, je höher deren Verschuldung ist

Wie werden diese Daten eigentlich bereitgestellt?

Ich habe es selbst ausgeführt; es scheint etwas langsamer zu sein, aber ich glaube nicht, dass es bis zum Doppelten geht.

function quickSortInPlace(arr, left = 0, right = arr.length - 1) {  
    if (left >= right) return;  
  
    const pivotIndex = partition(arr, left, right);  
    quickSortInPlace(arr, left, pivotIndex - 1);  
    quickSortInPlace(arr, pivotIndex + 1, right);  
}  
  
function partition(arr, left, right) {  
    const pivot = arr[right];  
    let i = left;  
  
    for (let j = left; j < right; j++) {  
        if (arr[j] < pivot) {  
            [arr[i], arr[j]] = [arr[j], arr[i]];  
            i++;  
        }  
    }  
  
    [arr[i], arr[right]] = [arr[right], arr[i]];  
    return i;  
}  
  
function quickSort(arr) {  
    if (arr.length <= 1) return arr;  
  
    const pivot = arr[arr.length - 1];  
    const left = [];  
    const right = [];  
  
    for (let i = 0; i < arr.length - 1; i++) {  
        if (arr[i] < pivot) {  
            left.push(arr[i]);  
        } else {  
            right.push(arr[i]);  
        }  
    }  
  
    return [...quickSort(left), pivot, ...quickSort(right)];  
}  
  
// =============  
  
function quickSortGPT(arr) {  
    if (!Array.isArray(arr)) {  
        throw new TypeError('quickSort expects an array');  
    }  
    if (arr.length <= 1) return [...arr];  
  
    const pivot = arr[Math.floor(arr.length / 2)];  
    const left = [];  
    const equal = [];  
    const right = [];  
  
    for (const el of arr) {  
        if (el < pivot) left.push(el);  
        else if (el > pivot) right.push(el);  
        else equal.push(el);  
    }  
  
    return [...quickSortGPT(left), ...equal, ...quickSortGPT(right)];  
}  
  
function quickSortInPlaceGPT(arr) {  
    if (!Array.isArray(arr)) {  
        throw new TypeError('quickSortInPlace expects an array');  
    }  
  
    const stack = [[0, arr.length - 1]];  
  
    while (stack.length) {  
        const [lo, hi] = stack.pop();  
        if (lo >= hi) continue;  
  
        const pivotIndex = partitionGPT(arr, lo, hi);  
  
        // Tail‑recursion elimination: push larger partition first  
        if (pivotIndex - 1 - lo > hi - (pivotIndex + 1)) {  
            stack.push([lo, pivotIndex - 1]);  
            stack.push([pivotIndex + 1, hi]);  
        } else {  
            stack.push([pivotIndex + 1, hi]);  
            stack.push([lo, pivotIndex - 1]);  
        }  
    }  
    return arr;  
}  
  
function medianOfThreeGPT(a, b, c) {  
    return (a - b) * (c - a) >= 0 ? a  
        : (b - a) * (c - b) >= 0 ? b  
            : c;  
}  
  
function partitionGPT(arr, lo, hi) {  
    const mid = lo + ((hi - lo) >> 1);  
    const pivotValue = medianOfThreeGPT(arr[lo], arr[mid], arr[hi]);  
  
    while (true) {  
        while (arr[lo] < pivotValue) lo++;  
        while (arr[hi] > pivotValue) hi--;  
  
        if (lo >= hi) return hi;  
  
        [arr[lo], arr[hi]] = [arr[hi], arr[lo]];  
        lo++;  
        hi--;  
    }  
}  
  
function testQuicksort(qs, qsp) {  
    const repeat = 100;  
    const arrLength = 100000;  
    const unsortedArray = new Array();  
    for (let i = 0; i < arrLength; i++)  
        unsortedArray.push(Math.round(Math.random() * arrLength));  
  
    let sorted = [];  
  
    const qb = performance.now();  
    for (let i = 0; i < repeat; i++)  
        sorted = qs(unsortedArray);  
    const qe = performance.now();  
  
    const rqb = performance.now();  
    for (let i = 0; i < repeat; i++) {  
        let copied = [...unsortedArray];  
        qsp(copied);  
    }  
    const rqe = performance.now();  
  
    // Bis auf 2 Nachkommastellen  
    const p1 = ((qe - qb) / repeat).toFixed(2);  
    const p2 = ((rqe - rqb) / repeat).toFixed(2);  
    
    console.log(`Quicksort: ${p1} ms, In-place: ${p2} ms`);  
}  
  
function main() {  
    const useGPT = process.argv.includes('--gpt');  
    console.log(`Using ${useGPT ? 'GPT' : 'geekNews'} quicksort implementation.`);  
    if (useGPT) {  
        testQuicksort(quickSortGPT, quickSortInPlaceGPT);  
    } else {  
        testQuicksort(quickSort, quickSortInPlace);  
    }  
}  
  
main();  

===
node q.js
Using geekNews quicksort implementation.
Quicksort: 29.55 ms, In-place: 9.94 ms
node q.js
Using geekNews quicksort implementation.
Quicksort: 28.42 ms, In-place: 9.07 ms
node q.js
Using geekNews quicksort implementation.
Quicksort: 26.91 ms, In-place: 9.15 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 28.73 ms, In-place: 9.22 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 26.87 ms, In-place: 9.22 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 27.97 ms, In-place: 9.30 ms
node --version
v22.14.0

bun q.js
Using geekNews quicksort implementation.
Quicksort: 32.05 ms, In-place: 17.39 ms
bun q.js
Using geekNews quicksort implementation.
Quicksort: 30.97 ms, In-place: 17.82 ms
bun q.js
Using geekNews quicksort implementation.
Quicksort: 29.73 ms, In-place: 16.14 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 30.61 ms, In-place: 12.63 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 31.09 ms, In-place: 12.76 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 33.24 ms, In-place: 12.75 ms
bun --version
1.2.14

deno q.js
Using geekNews quicksort implementation.
Quicksort: 32.30 ms, In-place: 6.79 ms
deno q.js
Using geekNews quicksort implementation.
Quicksort: 26.79 ms, In-place: 6.86 ms
deno q.js
Using geekNews quicksort implementation.
Quicksort: 26.09 ms, In-place: 6.85 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 27.18 ms, In-place: 7.92 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 25.34 ms, In-place: 8.12 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 25.39 ms, In-place: 8.09 ms
deno --version
deno 2.3.3 (stable, release, x86_64-pc-windows-msvc)
v8 13.7.152.6-rusty
typescript 5.8.3

....Äh?