Fai sembrare che sto lavorando


278

Spesso, mi ritrovo a eseguire uno script o una query che richiederà molto tempo per essere eseguito. Posso lasciare aperta quella sceneggiatura e godermi un po 'di procrastinazione senza sensi di colpa.

Ora, se potessi scrivere una sceneggiatura che sembra essere una delle scene sopra menzionate per tutti gli spettatori, ma solo negli sguardi? Potrei metterlo su uno schermo e godermi giorni di livestream di gattini prima che qualcuno si rendesse conto che tutto il complicato rigmarole sullo schermo non aveva nulla a che fare con il mio lavoro reale.

La tua sfida è quella di scrivere questo script per me (sì, sono così pigro).

Una buona risposta sarà:

  • Fai apparire qualcosa sullo schermo che sembra che una sceneggiatura stia funzionando. "Schermo" può essere terminale, browser, ecc.
  • Sii abbastanza originale (sì, abbiamo visto tutti i programmi infiniti dell'indicatore di stato)
  • Sopravvivere all'esame rapido di una persona tecnica

Una cattiva risposta sarà:

  • Fammi licenziare
  • Rehash qualcosa che siamo stati tutti inoltrati negli anni '90

Una risposta stellare potrebbe:

  • Trascendi uno dei punti elenco non validi sopra ( ad esempio )
  • Sopravvivere all'esame critico
  • * gasp * in realtà fa qualcosa che è utile o aiuta a evitare il mio lavoro

L'accettazione si baserà sui voti, con bonus dai risultati della vita reale. In realtà eseguirò questi script (Linux Mint 16) sul lavoro quando il mio schermo sarà visibile (riunioni e simili) per determinare il rilevamento. Se qualcuno nota che è falso, sei fuori dai giochi. Se qualcuno commenta quanto sto lavorando duramente, +5 voti bonus per te.

"Utile" in questo caso può applicarsi a qualsiasi programmatore, ma se stai cercando quel bagliore extra sulla tua mela associata all'insegnante, sono un webdev full-stack che lavora in codice approssimativamente secondo i miei tag .

Domanda parzialmente ispirata da questo .

risultati

Deludentemente, non ho ricevuto alcun commento in entrambi i modi su queste voci. Sono tutti fantastici, quindi siete tutti vincitori nel mio cuore. Tuttavia, Loktar ha il maggior numero di voti da un tiro lungo, quindi ottiene il +15 dall'accettazione. Congratulazioni!


6
Quali sono i criteri vincenti, il concorso di popolarità ?
Kyle Kanos,

36
Quindi ... cosa succede se si verifica una risposta e in realtà ti fa licenziare?
Bob,

54
Questo mi dà un'idea per un'altra domanda di golf del codice. "Fai sembrare che la mia domanda non debba essere messa in attesa"
twiz

9
Scrivi uno di questi programmi e compila !
ugoren,

13
L'altro giorno ho visto un ottimo remake della sala del consiglio di Tron Legacy su Github: github.com/arscan/encom-boardroom
Paul Prestidge,

Risposte:


291

JavaScript

Quindi sono diventato un po 'pazzo di questo. L'ho fatto tra una pausa e l'altra sul lavoro sulla mia GUI per tenere traccia degli IP usando Visual Basic.

Puoi accedervi andando al dominio super serio che ho creato stasera anche per poter guardare occupato ovunque Gui Hacker e fork e crearne uno tuo dalle seguenti fonti

Fondamentalmente, se hai questo in esecuzione nessuno ti disturberà perché sanno che stai facendo alcune cose serie.

var canvas = document.querySelector(".hacker-3d-shiz"),
  ctx = canvas.getContext("2d"),
  canvasBars = document.querySelector(".bars-and-stuff"),
  ctxBars = canvasBars.getContext("2d"),
  outputConsole = document.querySelector(".output-console");

canvas.width = (window.innerWidth / 3) * 2;
canvas.height = window.innerHeight / 3;

canvasBars.width = window.innerWidth / 3;
canvasBars.height = canvas.height;

outputConsole.style.height = (window.innerHeight / 3) * 2 + 'px';
outputConsole.style.top = window.innerHeight / 3 + 'px'


/* Graphics stuff */
function Square(z) {
  this.width = canvas.width / 2;
  this.height = canvas.height;
  z = z || 0;

  this.points = [
    new Point({
      x: (canvas.width / 2) - this.width,
      y: (canvas.height / 2) - this.height,
      z: z
    }),
    new Point({
      x: (canvas.width / 2) + this.width,
      y: (canvas.height / 2) - this.height,
      z: z
    }),
    new Point({
      x: (canvas.width / 2) + this.width,
      y: (canvas.height / 2) + this.height,
      z: z
    }),
    new Point({
      x: (canvas.width / 2) - this.width,
      y: (canvas.height / 2) + this.height,
      z: z
    })
  ];
  this.dist = 0;
}

Square.prototype.update = function() {
  for (var p = 0; p < this.points.length; p++) {
    this.points[p].rotateZ(0.001);
    this.points[p].z -= 3;
    if (this.points[p].z < -300) {
      this.points[p].z = 2700;
    }
    this.points[p].map2D();
  }
}

Square.prototype.render = function() {
  ctx.beginPath();
  ctx.moveTo(this.points[0].xPos, this.points[0].yPos);
  for (var p = 1; p < this.points.length; p++) {
    if (this.points[p].z > -(focal - 50)) {
      ctx.lineTo(this.points[p].xPos, this.points[p].yPos);
    }
  }

  ctx.closePath();
  ctx.stroke();

  this.dist = this.points[this.points.length - 1].z;

};

function Point(pos) {
  this.x = pos.x - canvas.width / 2 || 0;
  this.y = pos.y - canvas.height / 2 || 0;
  this.z = pos.z || 0;

  this.cX = 0;
  this.cY = 0;
  this.cZ = 0;

  this.xPos = 0;
  this.yPos = 0;
  this.map2D();
}

Point.prototype.rotateZ = function(angleZ) {
  var cosZ = Math.cos(angleZ),
    sinZ = Math.sin(angleZ),
    x1 = this.x * cosZ - this.y * sinZ,
    y1 = this.y * cosZ + this.x * sinZ;

  this.x = x1;
  this.y = y1;
}

Point.prototype.map2D = function() {
  var scaleX = focal / (focal + this.z + this.cZ),
    scaleY = focal / (focal + this.z + this.cZ);

  this.xPos = vpx + (this.cX + this.x) * scaleX;
  this.yPos = vpy + (this.cY + this.y) * scaleY;
};

// Init graphics stuff
var squares = [],
  focal = canvas.width / 2,
  vpx = canvas.width / 2,
  vpy = canvas.height / 2,
  barVals = [],
  sineVal = 0;

for (var i = 0; i < 15; i++) {
  squares.push(new Square(-300 + (i * 200)));
}

//ctx.lineWidth = 2;
ctx.strokeStyle = ctxBars.strokeStyle = ctxBars.fillStyle = '#00FF00';

/* fake console stuff */
var commandStart = ['Performing DNS Lookups for',
    'Searching ',
    'Analyzing ',
    'Estimating Approximate Location of ',
    'Compressing ',
    'Requesting Authorization From : ',
    'wget -a -t ',
    'tar -xzf ',
    'Entering Location ',
    'Compilation Started of ',
    'Downloading '
  ],
  commandParts = ['Data Structure',
    'http://wwjd.com?au&2',
    'Texture',
    'TPS Reports',
    ' .... Searching ... ',
    'http://zanb.se/?23&88&far=2',
    'http://ab.ret45-33/?timing=1ww'
  ],
  commandResponses = ['Authorizing ',
    'Authorized...',
    'Access Granted..',
    'Going Deeper....',
    'Compression Complete.',
    'Compilation of Data Structures Complete..',
    'Entering Security Console...',
    'Encryption Unsuccesful Attempting Retry...',
    'Waiting for response...',
    '....Searching...',
    'Calculating Space Requirements '
  ],
  isProcessing = false,
  processTime = 0,
  lastProcess = 0;


function render() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);

  squares.sort(function(a, b) {
    return b.dist - a.dist;
  });
  for (var i = 0, len = squares.length; i < len; i++) {
    squares[i].update();
    squares[i].render();
  }

  ctxBars.clearRect(0, 0, canvasBars.width, canvasBars.height);

  ctxBars.beginPath();
  var y = canvasBars.height / 6;
  ctxBars.moveTo(0, y);

  for (i = 0; i < canvasBars.width; i++) {
    var ran = (Math.random() * 20) - 10;
    if (Math.random() > 0.98) {
      ran = (Math.random() * 50) - 25
    }
    ctxBars.lineTo(i, y + ran);
  }

  ctxBars.stroke();

  for (i = 0; i < canvasBars.width; i += 20) {
    if (!barVals[i]) {
      barVals[i] = {
        val: Math.random() * (canvasBars.height / 2),
        freq: 0.1,
        sineVal: Math.random() * 100
      };
    }

    barVals[i].sineVal += barVals[i].freq;
    barVals[i].val += Math.sin(barVals[i].sineVal * Math.PI / 2) * 5;
    ctxBars.fillRect(i + 5, canvasBars.height, 15, -barVals[i].val);
  }

  requestAnimationFrame(render);
}

function consoleOutput() {
  var textEl = document.createElement('p');

  if (isProcessing) {
    textEl = document.createElement('span');
    textEl.textContent += Math.random() + " ";
    if (Date.now() > lastProcess + processTime) {
      isProcessing = false;
    }
  } else {
    var commandType = ~~(Math.random() * 4);
    switch (commandType) {
      case 0:
        textEl.textContent = commandStart[~~(Math.random() * commandStart.length)] + commandParts[~~(Math.random() * commandParts.length)];
        break;
      case 3:
        isProcessing = true;
        processTime = ~~(Math.random() * 5000);
        lastProcess = Date.now();
      default:
        textEl.textContent = commandResponses[~~(Math.random() * commandResponses.length)];
        break;
    }
  }

  outputConsole.scrollTop = outputConsole.scrollHeight;
  outputConsole.appendChild(textEl);

  if (outputConsole.scrollHeight > window.innerHeight) {
    var removeNodes = outputConsole.querySelectorAll('*');
    for (var n = 0; n < ~~(removeNodes.length / 3); n++) {
      outputConsole.removeChild(removeNodes[n]);
    }
  }

  setTimeout(consoleOutput, ~~(Math.random() * 200));
}

render();
consoleOutput();

window.addEventListener('resize', function() {
  canvas.width = (window.innerWidth / 3) * 2;
  canvas.height = window.innerHeight / 3;

  canvasBars.width = window.innerWidth / 3;
  canvasBars.height = canvas.height;

  outputConsole.style.height = (window.innerHeight / 3) * 2 + 'px';
  outputConsole.style.top = window.innerHeight / 3 + 'px';

  focal = canvas.width / 2;
  vpx = canvas.width / 2;
  vpy = canvas.height / 2;
  ctx.strokeStyle = ctxBars.strokeStyle = ctxBars.fillStyle = '#00FF00';
});
@font-face {
  font-family: 'Source Code Pro';
  font-style: normal;
  font-weight: 400;
  src: local('Source Code Pro'), local('SourceCodePro-Regular'), url(http://themes.googleusercontent.com/static/fonts/sourcecodepro/v4/mrl8jkM18OlOQN8JLgasDxM0YzuT7MdOe03otPbuUS0.woff) format('woff');
}
body {
  font-family: 'Source Code Pro';
  background: #000;
  color: #00FF00;
  margin: 0;
  font-size: 13px;
}
canvas {
  position: absolute;
  top: 0;
  left: 0;
}
.bars-and-stuff {
  left: 66.6%;
}
.output-console {
  position: fixed;
  overflow: hidden;
}
p {
  margin: 0
}
<canvas class='hacker-3d-shiz'></canvas>
<canvas class='bars-and-stuff'></canvas>
<div class="output-console"></div>


47
I ragazzi della pittura / manutenzione hanno capito che sono un programmatore e non solo un ragazzo che ascolta la musica !! Mi chiedo se questo sopravviverebbe ad un esame da parte di un tecnico: P
sabithpocker,

17
Lo voglio come nuovo salvaschermo !! In effetti, come lo faresti in Ubuntu?

33
Mi sono seduto nella biblioteca pubblica di Toronto con questo open e ho notato persone dietro di me che guardavano il mio schermo. Sembra piuttosto "spaventoso" a un ragazzo non esperto. Puoi fare in modo che guihacker.com ci consenta di 2 cambiare il titolo della pagina come preferiamo e se possiamo aggiungere nelle nostre righe che appariranno nel testo verde? Stavo pensando di creare il titolo della pagina "Accesso a Internet della Biblioteca pubblica di Toronto" e di pronunciare le righe verdi "Accesso al database di sicurezza della Biblioteca pubblica di Toronto ..." "Accesso a nomi utente e password ..." "Accesso concesso ..." mettimi nei guai ma sarà divertente.
user2719875

37
Ho funzionato per tutti e 30 i secondi prima che i miei colleghi sviluppatori venissero a chiedermi cosa stavo hackerando. Io penso che conta come un successo, in modo da +1
MrTheWalrus

10
"Rapporti TPS" ... geniale.
Dennis,

111

Bash / coreutils

Ti presentiamo il primo ... emulatore di compilation . Con questo programma, puoi avere epiche battaglie con la spada da ufficio ogni volta che vuoi, senza nemmeno scrivere alcun codice!

#!/bin/bash
collect()
{
    while read line;do
        if [ -d "$line" ];then
            (for i in "$line"/*;do echo $i;done)|sort -R|collect
            echo $line
        elif [[ "$line" == *".h" ]];then
            echo $line
        fi
    done
}

sse="$(awk '/flags/{print;exit}' </proc/cpuinfo|grep -o 'sse\S*'|sed 's/^/-m/'|xargs)"

flags=""
pd="\\"

while true;do
    collect <<< /usr/include|cut -d/ -f4-|
    (
        while read line;do
            if [ "$(dirname "$line")" != "$pd" ];then
                x=$((RANDOM%8-3))
                if [[ "$x" != "-"* ]];then
                    ssef="$(sed 's/\( *\S\S*\)\{'"$x,$x"'\}$//' <<< "$sse")"
                fi
                pd="$(dirname "$line")"
                opt="-O$((RANDOM%4))"
                if [[ "$((RANDOM%2))" == 0 ]];then
                    pipe=-pipe
                fi
                case $((RANDOM%4)) in
                    0) arch=-m32;;
                    1) arch="";;
                    *) arch=-m64;;
                esac
                if [[ "$((RANDOM%3))" == 0 ]];then
                    gnu="-D_GNU_SOURCE=1 -D_REENTRANT -D_POSIX_C_SOURCE=200112L "
                fi
                flags="gcc -w $(xargs -n1 <<< "opt pipe gnu ssef arch"|sort -R|(while read line;do eval echo \$$line;done))"
            fi
            if [ -d "/usr/include/$line" ];then
                echo $flags -shared $(for i in /usr/include/$line/*.h;do cut -d/ -f4- <<< "$i"|sed 's/h$/o/';done) -o "$line"".so"
                sleep $((RANDOM%2+1))
            else
                line=$(sed 's/h$//' <<< "$line")
                echo $flags -c $line"c" -o $line"o"
                sleep 0.$((RANDOM%4))
            fi
        done
    )
done

Utilizza i dati da /usr/includeper creare un registro di compilazione dall'aspetto realistico. Ero troppo pigro per lanciare avvisi casuali, quindi c'è solo una -wbandiera.

Campione casuale:

gcc -w -m64 -pipe -msse -msse2 -msse3 -O1 -c libiptc / xtcshared.c -o libiptc / xtcshared.o
gcc -w -m64 -pipe -msse -msse2 -msse3 -O1 -c libiptc / libip6tc.c -o libiptc / libip6tc.o
gcc -w -m64 -pipe -msse -msse2 -msse3 -O1 -c libiptc / libxtc.c -o libiptc / libxtc.o
gcc -w -m64 -pipe -msse -msse2 -msse3 -O1 -c libiptc / ipt_kernel_headers.c -o libiptc / ipt_kernel_headers.o
gcc -w -m64 -pipe -msse -msse2 -msse3 -O1 -c libiptc / libiptc.c -o libiptc / libiptc.o
gcc -w -O2 -m64 -pipe -msse -msse2 -msse3 -msse4_1 -msse4_2 -shared libiptc / ipt_kernel_headers.o libiptc / libip6tc.o libiptc / libiptc.o libiptc / libxtc.o libiptc / xtcshared.o -o. così
gcc -w -m64 -pipe -O0 -msse -msse2 -msse3 -msse4_1 -c e2p / e2p.c -o e2p / e2p.o
gcc -w -msse -msse2 -msse3 -msse4_1 -m64 -pipe -O1 -shared e2p / e2p.o -o e2p.so
gcc -w -pipe -O0 -msse -msse2 -m64 -c spice-client-gtk-2.0 / spice-widget-enums.c -o spice-client-gtk-2.0 / spice-widget-enums.o
gcc -w -pipe -O0 -msse -msse2 -m64 -c spice-client-gtk-2.0 / spice-grabsequence.c -o spice-client-gtk-2.0 / spice-grabsequence.o
gcc -w -pipe -O0 -msse -msse2 -m64 -c spice-client-gtk-2.0 / spice-gtk-session.c -o spice-client-gtk-2.0 / spice-gtk-session.o
gcc -w -pipe -O0 -msse -msse2 -m64 -c spice-client-gtk-2.0 / spice-widget.c -o spice-client-gtk-2.0 / spice-widget.o
gcc -w -pipe -O0 -msse -msse2 -m64 -c spice-client-gtk-2.0 / usb-device-widget.c -o spice-client-gtk-2.0 / usb-device-widget.o
gcc -w -pipe -m64 -msse -msse2 -O1 -shared spice-client-gtk-2.0 / spice-grabsequence.o spice-client-gtk-2.0 / spice-gtk-session.o spice-client-gtk-2.0 /spice-widget-enums.o spice-client-gtk-2.0 / spice-widget.o spice-client-gtk-2.0 / usb-device-widget.o -o spice-client-gtk-2.0.so
gcc -w -pipe -m64 -msse -msse2 -O1 -c search.c -o search.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / path.c -o cairomm-1.0 / cairomm / path.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / scaledfont.c -o cairomm-1.0 / cairomm / 1.0
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / fontface.c -o cairomm-1.0 / cairomm / fontface.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / quartz_font.c -o cairomm / 1.0 / cairomm / 1.0
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / win32_font.c -o cairomm / 1.032
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / refptr.c -o cairomm-1.0 / cairomm / refptro
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / cairomm.c -o cairomm-1.0 / cairomm / cairomm / 1.0
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / context.c -o cairomm-1.0 / cairomm / context.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / enums.c -o cairomm-1.0 / cairomm / enums.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / win32_surface.c -o cairomm-1.0 / cairomms / ca32
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / pattern.c -o cairomm-1.0 / cairomm / pattern.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / types.c -o cairomm-1.0 / cairomm / types.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / matrix.c -o cairomm-1.0 / cairomm / matrix.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / quartz_surface.c -o cairomm-1.0 / cairomm. 1.0 / cairomm. 1.0
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / exception.c -o cairomm-1.0 / cairomm / exception.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / device.c -o cairomm-1.0 / cairomm / device.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / surface.c -o cairomm-1.0 / cairomm / surface.o
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / xlib_surface.c -o cairomm-1.0 / cairomm. 1.0 / cairomm. 1.0 / cairomm. 1.0 / cairomm. 1.0
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / fontoptions.c -o cairomm-1.0 / cairomm / fontop.-
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / region.c -o cairomm-1.0 / cairomm / region.o
gcc -w -O0 -pipe -m64 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -msse -msse2 -msse3 -msse4_1 -shared cairomm-1.0 / cairomm / cairomm.o cairomm-context / cairomm-context. /cairomm/device.o cairomm-1.0 / cairomm / enums.o cairomm-1.0 / cairomm / exception.o cairomm-1.0 / cairomm / fontface.o cairomm-1.0 / cairomm / fontoptions.o cairomm-1.0 / cairomm / matrix. o cairomm-1.0 / cairomm / path.o cairomm-1.0 / cairomm / pattern.o cairomm-1.0 / cairomm / quartz_font.o cairomm-1.0 / cairomm / quartz_surface.o cairomm-1.0 / cairomm / refptr.o cairomm-1.0 / cairomm / region.o cairomm-1.0 / cairomm / scaledfont.o cairomm-1.0 / cairomm / surface.o cairomm-1.0 / cairomm / types.o cairomm-1.0 / cairomm / win32_font.o cairomm-1.0 / cairomm / win32_surface.o cairomm-1.0 / cairomm / xlib_surface.o -o cairomm-1.0 / cairomm.so
gcc -w -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -msse -O1 -pipe -shared cairomm-1.0 / *. o -o cairomm-1.0.so
gcc -w -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -msse -O1 -pipe -c ulockmgr.c -o ulockmgr.o
gcc -w -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -msse -O1 -pipe -c gshadow.c -o gshadow.o
gcc -w -O2 -msse -msse2 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -pipe -c dpkg / string.c -o dpkg / string.o
gcc -w -O2 -msse -msse2 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -pipe -c dpkg / fdio.c -o dpkg / fdio.o
gcc -w -O2 -msse -msse2 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -pipe -c dpkg / namevalue.c -o dpkg / namevalue.o
gcc -w -O2 -msse -msse2 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -pipe -c dpkg / macros.c -o dpkg / macros.o

4
Non è affatto male! Qualcosa non sembra del tutto corretto (è che l'HD è completamente silenzioso?) Ma per lo spettatore inconsapevole è molto improbabile che susciti sospetti. Anche se ... cosa, si sta compilando libdrm? E sys/wait.o?? Ciò che il ...
smesso di girare in senso antiorario è l'

27
@leftaroundabout Supponi di avere un SSD.
mniip,

36
Per renderlo più autentico, dovresti generare più volte avvisi falsi sul compilatore per riga gcc. :)
monocell

3
Probabilmente potresti usare pkg-config per inventare flag gcc falsi più realistici.
Brendan Long,

3
@WChargin che non attiverebbe l'HD.
Thorbjørn Ravn Andersen,

106

bash

Visualizza all'infinito valori casuali esadecimali, con alcuni di essi evidenziati per far sembrare che tu stia eseguendo una ricerca complicata nei dati grezzi.

while true; do head -c200 /dev/urandom | od -An -w50 -x | grep -E --color "([[:alpha:]][[:digit:]]){2}"; sleep 0.5; done

enter image description here


6
Oooh, mi piace questo!
SomeKittens,

4
(Bear with me, new to bash) ma quando eseguo questa linea, (mac osx, terminal) ottengo questo output su un loop:od: illegal option -- w usage: od [-aBbcDdeFfHhIiLlOosvXx] [-A base] [-j skip] [-N length] [-t type] [[+]offset[.][Bb]] [file ...]
Sterling Archer

2
Sembra che la tua versione di odnon supporti l' -wopzione. Puoi rilasciare questa opzione, è qui solo per mostrare più colonne di dati, per riempire un po 'di più lo schermo.
Barjak,

8
Personalmente, preferisco questo con sleep 0.5cambiato in sleep.$[$RANDOM % 10]. Lo rende un po 'più nervoso e più simile a una vera ricerca. Mi piace, però!
undergroundmonorail,

4
Mi ricorda la ricerca infinita di "ca fe":cat /dev/random | hexdump | grep "ca fe"
daviewales l'

102

Una build molto lunga:

emerge openoffice

48
; _;
mniip

3
Più lungo del cromo?
nyuszika7h

6
Il problema con la compilazione di un progetto reale è che si fermerà se si verifica un errore. Probabilmente dovremmo metterlo in un ciclo infinito.
Akira Yamamoto,

3
Siamo emersi in Linux Mint?
Akira Yamamoto,

3
Su sistemi .deb come Ubuntu e Mint, vuoi sudo apt-get build-dep libreoffice; apt-get source libreoffice; cd libreoffice*; while :; do nice dpkg-buildpackage -rfakeroot; done(Dovrai fare da babysitter al suo primo avvio, almeno fino all'inizio della compilazione vera e propria. Le esecuzioni successive richiedono solo il whileciclo.)
Adam Katz

55

Rubino

Questo sarà:

  1. Ottieni un codice casuale da questo sito.revisione del codice (per un codice più leggibile e ben scritto)
  2. Fai sembrare che stai scrivendo questo codice.
require 'open-uri'
require 'nokogiri'
site = "http://codereview.stackexchange.com/"
system 'cls'
system("color 0a")
5.times do
    begin
        id = rand(1..6000)
        url = "#{site}/a/#{id}"
        page = Nokogiri::HTML(open(url))
        code = page.css('code')[0].text
    end until code

    code.each_char  do |char|
        print char
        sleep rand(10) / 30.0
    end
end

Ecco questo script basato su un codice preso da qui :

require 'open-uri'
code = open("http://hackertyper.com/code.txt")
system 'cls'
system("color 0a")

code.each_char  do |char|
    print char
    sleep rand(10) / 30.0
 end

Ecco come appare: Code


11
E se il codice che ottiene è in Brainf ** k, Golfscript o J. Ciò solleverà qualche sospetto.
user80551

39
Finalmente le mie risposte accuratamente posizionate che aggiungono backdoor tutto intorno pagano
PlasmaHH

1
Forse StackOverflow sarebbe meglio?
PyRulez,

3
La velocità di battitura di ciascuna sembra più realistica se randomizzo la velocità (e la faccio più veloce) cambiando la sleeplinea in sleep rand(10).to_f / 30.
Rory O'Kane,

3
Penso che usare il codice Code Review su Code Golf sia perfetto. Ho sempre pensato a Code Golf come il gemello malvagio di Code Review, e adoro entrambi ...
trichoplax,

52

Andiamo con un semplice script bash che ti fa sembrare hacker stampando il contenuto di ogni file identificato come testo in / var / log / riga per riga, con ritardi casuali per far sembrare che stiano accadendo cose intense. A seconda dei file che colpisce, può dare un output piuttosto interessante.

#/bin/bash
# this script helps you do hackerish stuff

if [ "$EUID" -ne 0 ]
then
  echo "Please run as root to be hackerish."
  exit
fi

# turn off globbing
set -f
# split on newlines only for for loops
IFS='
'
for log in $(find /var/log -type f); do
  # only use the log if it's a text file; we _will_ encounter some archived logs
  if [ `file $log | grep -e text | wc -l` -ne 0 ]
  then
    echo $log
    for line in $(cat $log); do
      echo $line
      # sleep for a random duration between 0 and 1/4 seconds to indicate hard hackerish work
      bc -l <<< $(bc <<< "$RANDOM % 10")" / 40" | xargs sleep
    done
  fi
done

Assicurati che il tema del tuo terminale appaia hacker. Ecco alcuni esempi tosti (non ho idea di cosa significhi nulla di tutto ciò, ma sembra un hacker):

image image


3
Ben fatto. Lo screenshot di esempio è fantastico
SomeKittens,

37
Sei consapevole che le tue chiavi private sono su questi screenshot?
Hubert OG,

27
Ah ah, capito! ;-)
Hubert OG

4
(Ma seriamente, non ho letto quegli screenshot quindi non so cosa ci sia realmente.)
Hubert OG

3
@HubertOG Wow, mi hai quasi fatto venire un infarto ...; PI non l'ho visto da nessuna parte, quindi ho pensato che sarei
diventato

49

Bash: il commit git infinito

Un problema con i computer oggi è che sono piuttosto veloci, quindi anche le attività di compilazione alla fine finiscono. Inoltre, dato uno script che viene eseguito a lungo, potresti sostenere che in realtà è possibile continuare a lavorare su qualcos'altro mentre lo script viene eseguito.

Per risolvere questo abbiamo il seguente programma. Impara a digitare 'y' o 'n' in modo casuale di tanto in tanto.

Ovviamente hai bisogno di un repository git con alcuni nuovi contenuti, ma supponendo che occasionalmente fai un vero lavoro che non dovrebbe essere un problema.

#!/bin/bash

while [ 1 ]; do
  git add -p
  git reset
done

12
Mi sento gravemente disturbato da questa voce CG ... È +1 o -1, ma non so ancora quale!
vaxquis,

37

bash

#!/bin/bash
function lazy {
    sudo apt-get update
    lazy
    }
lazy

Questo continuerà ad aggiornare i tuoi repository. Se qualcuno lo nota, dì solo che hai aggiunto un nuovo repository per un nuovo programma e ne stai testando di diversi. Non è proprio come simulare una sceneggiatura, ma un comando.

NOTA: non perdono di essere improduttivo sul lavoro, ma mi piacciono gli esperimenti. Pertanto, consiglio di utilizzare questa app per essere segretamente produttiva.


5
Bene, ma fai attenzione a quella funzione ricorsiva.
Digital Trauma,

1
sembra bomba a forcella !!
Avinash R,

2
@AvinashR Non proprio, niente fork.
PyRulez,

43
Gli host Mirror ti odiano ora.
Caleb,

9
"Non proprio, niente forchetta." Quindi dici solo bomba? :-)
celtschk,

28

Rete neurale C ++

MODIFICARE

Purtroppo ho ottimizzato questo codice :( l'ho reso 2000 volte più veloce ... Il codice legacy è comunque perfetto per perdere tempo!

Originale

In realtà ho avviato un progetto in reti neurali convoluzionali perfette per questo! Il codice sorgente e la documentazione sono su github . Il primo passo è creare una nuova rete.

std::vector<int> numNeurons = { 500, 500, 2000, 10 };
std::vector<int> numMaps = { 1, 1, 1, 1 };

ConvolutionalNeuralNetwork neuralNetwork(numNeurons, numMaps, numNeurons, 
    std::vector<std::vector<int>>(), std::vector<std::vector<int>>());

Ora che abbiamo una rete con 300 neuroni e 1.250.000 sinapsi, salviamola in un file per assicurarci di non perdere alcun progresso che facciamo con la rete.

neuralNetwork.SaveToFile("test2.cnn");

Ciò ha generato un file di testo da 68 MB e più di poche ore di lavoro rilassato. Adesso divertiamoci a fare le cose con esso! Creerò un input casuale e inizierò a discriminarlo.

std::vector<std::vector<float>> input;
for (int i = 0; i < 2; ++i)
    input.push_back(std::vector<float>{});

for (int i = 0; i < 2; ++i)
    for (int j = 0; j < 3; ++j)
        input[i].push_back(rand() % 100);
neuralNetwork.SetInput(input);

È stato un input piuttosto piccolo per un'immagine, ma stiamo solo dimostrando che la rete può fare qualcosa. Il prossimo passo è discriminarlo!

Layer output = neuralNetwork.Discriminate();

Questo non è ancora finito per me ed è in corso da oltre 2 giorni! Quindi, una volta ottenuto questo output, eseguiamolo di nuovo al contrario solo per divertimento.

Layer generatedOutput = neuralNetwork.Generate(output);

Questo è tutto per dimostrare che l'API funziona, non ci sono ancora piani per questo. Questo passaggio non è ancora stato eseguito per me e sto aspettando da un po '. Sono stati bruciati 2+ giorni buoni, e questa è una stima approssimativa dei miei test attuali. Questo è piuttosto complicato e lavorerai sodo per un giorno o due facendolo, ma dopo non potresti mai dover lavorare di nuovo!

Nota: se non vuoi mai più lavorare di nuovo, prova a formare la rete

neuralNetwork.LearnCurrentInput();

Non ho nemmeno il tempo da perdere per questo!

Se vuoi mostrare tutti i dati che stanno accadendo, aggiungi alcune chiamate nelle funzioni solo per visualizzare ciò che sta accadendo

Nuovo costruttore

ConvolutionalNeuralNetwork::ConvolutionalNeuralNetwork(std::vector<int> neuronCountPerLayer, std::vector<int> featureMapsPerLayer, std::vector<int> featureMapDimensions, std::vector<std::vector<int>> featureMapConnections, std::vector<std::vector<int>> featureMapStartIndex)
{
std::map<SimpleNeuron, std::vector<Synapse>> childrenOf;
for (unsigned int i = 0; i < neuronCountPerLayer.size() - 1; ++i)
{
    Layer currentLayer;

    for (int j = 0; j < neuronCountPerLayer[i]; ++j)
    {
        std::vector<Synapse> parentOf;

        if (featureMapsPerLayer[i] == 1)
        {
            for (int n = 0; n < neuronCountPerLayer[i + 1]; ++n)
            {
                std::cout << "Adding new synapse, data: " << std::endl;

                SimpleNeuron current = SimpleNeuron(i + 1, j + 1);
                SimpleNeuron destination = SimpleNeuron(i + 2, n + 1);

                std::cout << "Origin: " << i + 1 << ", " << j + 1 << "; Destination: " << i + 2 << ", " << n + 1 << std::endl;

                Synapse currentParentSynapse = Synapse(current, current);
                Synapse currentChildSynapse = Synapse(destination, destination);

                currentChildSynapse.SetWeightDiscriminate(currentParentSynapse.GetWeightDiscriminate());
                currentChildSynapse.SetWeightGenerative(currentParentSynapse.GetWeightGenerative());

                std::cout << "Weights: Discriminative: " << currentChildSynapse.GetWeightDiscriminate() << "; Generative: " << currentChildSynapse.GetWeightGenerative() << std::endl;

                parentOf.push_back(currentParentSynapse);

                if (childrenOf.find(destination) != childrenOf.end())
                    childrenOf.at(destination).push_back(currentChildSynapse);
                else
                    childrenOf.insert(std::pair<SimpleNeuron, std::vector<Synapse>>(destination,
                    std::vector<Synapse>{ currentChildSynapse }));
            }
        }

        else
        {
            int featureMapsUp = featureMapsPerLayer[i + 1];
            int inFeatureMap = featureMapsPerLayer[i] / j;
            int connections = featureMapConnections[i][inFeatureMap];
            int startIndex = (neuronCountPerLayer[i + 1] / featureMapsUp) * featureMapStartIndex[i][inFeatureMap];
            int destinationIndex = startIndex + (neuronCountPerLayer[i + 1] / featureMapsUp) * connections;

            for (int n = startIndex; n < destinationIndex; ++n)
            {
                SimpleNeuron current = SimpleNeuron(i + 1, j + 1);
                SimpleNeuron destination = SimpleNeuron(i + 2, n + 1);

                std::cout << "Origin: " << i + 1 << ", " << j + 1 << "; Destination: " << i + 2 << ", " << n + 1 << std::endl;

                Synapse currentParentSynapse = Synapse(current, current);
                Synapse currentChildSynapse = Synapse(destination, destination);

                currentChildSynapse.SetWeightDiscriminate(currentParentSynapse.GetWeightDiscriminate());
                currentChildSynapse.SetWeightGenerative(currentParentSynapse.GetWeightGenerative());

                std::cout << "Weights: Discriminative: " << currentChildSynapse.GetWeightDiscriminate() << "; Generative: " << currentChildSynapse.GetWeightGenerative() << std::endl;

                parentOf.push_back(currentParentSynapse);

                if (childrenOf.find(destination) != childrenOf.end())
                    childrenOf.at(destination).push_back(currentChildSynapse);
                else
                    childrenOf.insert(std::pair<SimpleNeuron, std::vector<Synapse>>(destination,
                    std::vector<Synapse>{ currentChildSynapse }));
            }
        }

        std::cout << "Adding neuron" << std::endl << std::endl;

        if (childrenOf.find(SimpleNeuron(i + 1, j + 1)) != childrenOf.end())
            currentLayer.AddNeuron(Neuron(parentOf, childrenOf.at(SimpleNeuron(i + 1, j + 1))));
        else
            currentLayer.AddNeuron(Neuron(parentOf, std::vector<Synapse>{}));
    }

    std::cout << "Adding layer" << std::endl << std::endl << std::endl;

    AddLayer(currentLayer);
}

Layer output;

std::cout << "Adding final layer" << std::endl;

for (int i = 0; i < neuronCountPerLayer[neuronCountPerLayer.size() - 1]; ++i)
    output.AddNeuron(Neuron(std::vector<Synapse>(), childrenOf.at(SimpleNeuron(neuronCountPerLayer.size(), i + 1))));
AddLayer(output);
}

Nuovo FireSynapse

float Neuron::FireSynapse()
{
float sum = 0.0f;

std::cout << "Firing Synapse!" << std::endl;

for (std::vector<Synapse>::iterator it = m_ChildOfSynapses.begin(); it != m_ChildOfSynapses.end(); ++it)
    sum += ((*it).GetWeightDiscriminate() * (*it).GetParent().GetValue());

std::cout << "Total sum: " << sum << std::endl;

float probability = (1 / (1 + pow(e, -sum)));

std::cout << "Probably of firing: " << probability << std::endl;

if (probability > 0.9f)
    return 1.0f;

else if (probability < 0.1f)
    return 0.0f;

else
{
    std::cout << "Using stochastic processing to determine firing" << std::endl;
    float random = ((rand() % 100) / 100);
    if (random <= probability)
        return 1.0f;
    else
        return 0.0f;
}
}

Ora avrai un sacco di output sulla tua console.


4
+1 anche per il contesto di vita reale. Interessante :)
George,

1
Hahahaha l'incantesimo iniziale "CNN"
Nic Hartley,

26

Python 3

#!/usr/bin/python3

import random
import time

first_level_dirs = ['main', 'home', 'usr', 'root', 'html', 'assets', 'files']
title_descs = ['page', 'script', 'interface', 'popup']
id_names = ['container', 'main', 'textbox', 'popup']
tag_names = ['div', 'textarea', 'span', 'strong', 'article', 'summary', 'blockquote', 'b']
autoclosing_tags = ['br', 'input']

def random_js_line():
    return random.choice([
        '      $("#%s").html("<b>" + $("#%s").text() + "</b>");' % (random.choice(id_names), random.choice(id_names)),
        '      $.get("t_%i.txt", function(resp) {\n        callback(resp);\n      });' % (int(random.random() * 50)),
        '      $("%s>%s").css({width: %i + "px", height: %i + "px"});' % (random.choice(tag_names), random.choice(tag_names), int(random.random() * 75), int(random.random() * 75)),
        '      for (var i = 0; i < count; i++) {\n        $("<div>").appendTo("#%s");\n      }' % (random.choice(id_names))
    ])

def random_js_lines():
    lines = [random_js_line() for _ in range(int(random.random() * 14) + 1)]
    return '\n'.join(lines)

def random_html_line():
    tag_name = random.choice(tag_names)
    return random.choice([
        '    <%s>id: %i</%s>' % (tag_name, int(random.random() * 1000), tag_name),
        '    <%s class="%s">\n      <%s/>\n    </%s>' % (tag_name, random.choice(first_level_dirs), random.choice(autoclosing_tags), tag_name),
        '    <div id="%s"></div>' % (random.choice(first_level_dirs))
    ])

def random_html_lines():
    lines = [random_html_line() for _ in range(int(random.random() * 9) + 1)]
    return '\n'.join(lines)

while True:
    print('creating /%s/%i.html' % (random.choice(first_level_dirs), int(random.random() * 1000)))
    time.sleep(random.random())
    lines = [
        '<!DOCTYPE html>',
        '<html lang="en">',
        '  <head>',
        '    <title>%s #%i</title>' % (random.choice(title_descs), int(random.random() * 100)),
        '    <script type="text/javascript" src="/js/assets/jquery.min.js"></script>',
        '    <script type="text/javascript">',
        random_js_lines(),
        '    </script>',
        '  </head>',
        '  <body>',
        random_html_lines(),
        '  </body>',
        '</html>'
    ]
    lines = [single_line for linegroup in lines for single_line in linegroup.split('\n')]
    for line in lines:
        print(line)
        time.sleep(random.random() / 10)
    print()
    time.sleep(random.random() / 2)

Produce un sacco di righe di JS e HTML falsi, con tempi di "caricamento" (ritardi) falsi per renderlo più realistico.

Questo può e sarà ampliato notevolmente! (il programma di base è lì; devo solo aggiungere più contenuti ora)


Ecco una "pagina" di esempio che genera (in realtà proviene da una vecchia versione del codice; al termine, lo aggiornerò con il nuovo codice):

creating /assets/809.html
<!DOCTYPE html>
<html lang="en">
  <head>
    <title>script #32</title>
    <script type="text/javascript" src="/js/assets/jquery.min.js"></script>
    <script type="text/javascript">
      $("#main").html("<b>" + $("#main").text() + "</b>");
      $("#textbox").html("<b>" + $("#container").text() + "</b>");
      $("#popup").html("<b>" + $("#textbox").text() + "</b>");
      $("#container").html("<b>" + $("#textbox").text() + "</b>");
      $.get("t_11.txt", function(resp) {
        callback(resp);
      });
      $("#main").html("<b>" + $("#textbox").text() + "</b>");
      $.get("t_14.txt", function(resp) {
        callback(resp);
      });
      $.get("t_1.txt", function(resp) {
        callback(resp);
      });
      $.get("t_34.txt", function(resp) {
        callback(resp);
      });
    </script>
  </head>
  <body>
    <span>id: 462</span>
    <textarea>id: 117</textarea>
  </body>
</html>

3
Fantastico, non vedo l'ora di vedere cosa ci aggiungi!
SomeKittens

eh sì, questo è un bel culo da sballo. La mia mente si
scatena

Non solo python3, 2.7 è anche ok
Hannes Karppila,

1
Ottimo lavoro. Sembra piuttosto realistico.
qwr

24

Node.js + BDD

Sembra un flusso infinito di test in stile BDD in esecuzione. Nessuno può biasimarti per l'esecuzione di test!

    "use strict"
var colors = require("colors"),
    features = ["User", "Request", "Response", "Cache", "Preference", "Token", "Profile", "Application", "Security"],
    patterns = ["Factory", "Observer", "Manager", "Repository", "Impl", "Dao", "Service", "Delegate", "Activity"],
    requirements = ["return HTTP 403 to unauthorized users",
                    "accept UTF-8 input",
                    "return HTTP 400 for invalid input",
                    "correctly escape SQL",
                    "validate redirects",
                    "provide online documentation",
                    "select internationalized strings, based on locale",
                    "support localized date formats",
                    "work in IE6",
                    "pass W3C validation",
                    "produce valid JSON",
                    "work with screen readers",
                    "use HTML5 canvas where available",
                    "blink"],
    minTimeout = 100,
    maxTimeout = 1000,
    minRequirements = 2,
    maxRequirements = 6,
    skipThreshold = 0.1,
    failThreshold = 0.2


function randBetween(l, u) {
  return Math.floor(Math.random() * (u - l) + l) 
}

function choose(l) {
  return l[randBetween(0, l.length)]
}

function timeout() {
  return randBetween(minTimeout, maxTimeout)
}

function printFeature() {
  console.log("")
  var feature = choose(features) + choose(patterns)
  var article = /^[AEIOU]/.test(feature) ? "An " : "A "
  console.log(article + feature + " should")
  setTimeout(function() {
    var reqs = randBetween(minRequirements, maxRequirements)
    printRequirements(reqs)
  }, timeout())
}

function printRequirements(i) {
  if (i > 0) {
    var skipFailOrPass = Math.random()
    if (skipFailOrPass < skipThreshold) {
      console.log(("- " + choose(requirements) + " (SKIPPED)").cyan)
    } else if (skipFailOrPass < failThreshold) {
      console.log(("x " + choose(requirements) + " (FAILED)").red)
      console.log(("  - Given I am on the " + choose(features) + " page").green)
      console.log(("  - When I click on the " + choose(features) + " link").green)
      console.log(("  x Then the Log Out link should be visible in the top right hand corner").red)
    } else {
      console.log(("+ " + choose(requirements)).green)
    }
    setTimeout(function() {printRequirements(i - 1)}, timeout())
  } else {
    printFeature()
  }
}

printFeature()

Aggiornare

Mi è venuto in mente che sarebbe sembrato sospetto se tutti i test fossero stati superati, quindi l'ho aggiornato per includere alcuni test non riusciti, completi di Given-When-Thens.

E sì, so che tutti gli errori hanno lo stesso messaggio. Devi davvero correggere quel link di logout!

inserisci qui la descrizione dell'immagine


2
Molto intelligente, ottengo punti bonus per aver testato il mio codice! Non
posso

23

C # (Windows)

Vi presento il nuovissimo Memtest86 Simulator 2014 ! (Perché eseguire Memtest86 su Windows ha un senso totale)

Completo di barre di avanzamento di lavoro e indicatore modello!

Questo codice utilizza ampiamente la classe Console, che per quanto ne so, è disponibile solo su Windows. Inoltre, non sono riuscito a trovare un modo per mostrare il nome / frequenza del processore reale e la memoria disponibile, quindi quelli sono hardcoded.

Immagine dello schermo: inserisci qui la descrizione dell'immagine

MODIFICARE

Per recuperare le informazioni sul processore, è possibile utilizzare lo spazio dei nomi Microsoft.Win32 e la classe RegistryKey.

 // Processor information, add 'using Microsoft.Win32';
string processor = "";
RegistryKey processor_name = Registry.LocalMachine.OpenSubKey(@"Hardware\Description\System\CentralProcessor\0", RegistryKeyPermissionCheck.ReadSubTree);
        if (processor_name != null)
        {
            if (processor_name.GetValue("ProcessorNameString") != null)
            {
                processor = (string)processor_name.GetValue("ProcessorNameString");
            }
        }

Codice (brutto, lo so):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

class MemTestSim
{
    static void Main(string[] args)
    {
        Random r = new Random();
        int seconds = 0;
        int pass = 0;
        int test = 0;
        int testNumber = 0;

        string[] testNames = { "Address test, own Adress", "Moving inversions, ones & zeros", "Moving inversions, 8 bit pattern" };
        string[] pattern = { "80808080", "7f7f7f7f", "40404040", "bfbfbfbf", "20202020", "dfdfdfdf", "10101010", "efefefef", "08080808", "f7f7f7f7", "8f8f8f8f" };

        // Trick to stop the console from scrolling
        Console.SetWindowSize(80, 40);

        Console.Title = "Memtest86+ v2.11";
        Console.CursorVisible = false;

        // Dark Blue Background Color
        Console.BackgroundColor = ConsoleColor.DarkBlue;
        Console.Clear();

        // Green Title Text
        Console.BackgroundColor = ConsoleColor.DarkGreen;
        Console.ForegroundColor = ConsoleColor.Black;
        Console.Write("      Memtest86+ v2.11     ");

        // Gray on Blue Text and main window structure
        Console.BackgroundColor = ConsoleColor.DarkBlue;
        Console.ForegroundColor = ConsoleColor.Gray;
        Console.Write("| Pass " + pass + "%\n");
        Console.WriteLine("Intel Core i5 2290 MHz     | Test ");
        Console.WriteLine("L1 Cache:  128K   1058MB/s | Test #" + testNumber + "  [" + testNames[0] + "]");
        Console.WriteLine("L2 Cache:  512K   1112MB/s | Testing:  132K - 8192M  8192M");
        Console.WriteLine("L3 Cache: 3072K   1034MB/s | Pattern: ");
        Console.WriteLine("Memory  : 8192M            |---------------------------------------------------");
        Console.WriteLine("Chipset :  Intel i440FX");
        Console.WriteLine();
        Console.WriteLine();
        Console.WriteLine(" WallTime   Cached  RsvdMem   MemMap   Cache  ECC  Test  Pass  Errors  ECC Errs");
        Console.WriteLine(" ---------  ------  -------  --------  -----  ---  ----  ----  ------  --------");
        Console.WriteLine("   0:00:26   8192M      64K  e820-Std    on   off   Std     0       0");

        // Bottom Bar
        Console.SetCursorPosition(0, 24);
        Console.BackgroundColor = ConsoleColor.Gray;
        Console.ForegroundColor = ConsoleColor.DarkBlue;
        Console.WriteLine("(ESC)Reboot  (c)configuration  (SP)scroll_lock  (CR)scroll_unlock               ");


        Console.SetWindowSize(80, 25);

        // Reset text color
        Console.BackgroundColor = ConsoleColor.DarkBlue;
        Console.ForegroundColor = ConsoleColor.Gray;

        // FOREVER
        while (true)
        {
            TimeSpan time = TimeSpan.FromSeconds(seconds);

            // Running Time (WallTime)
            Console.SetCursorPosition(3, 11);
            string min = (time.Minutes < 10 ? "0" + time.Minutes : "" + time.Minutes);
            string sec = (time.Seconds < 10 ? "0" + time.Seconds : "" + time.Seconds);
            Console.Write(time.Hours + ":" + min + ":" + sec);

            // Test percentage
            Console.SetCursorPosition(34, 1);
            Console.Write((int)test + "%");

            // Test Progress Bar
            Console.SetCursorPosition(38, 1);
            for (int i = 0; i < test / 3; i++)
                Console.Write("#");

            Console.SetCursorPosition(38, 0);
            for (int i = 0; i < pass / 3; i++)
                Console.Write("#");

            // Test Number
            Console.SetCursorPosition(35, 2);
            Console.Write(testNumber + "  [" + testNames[testNumber] + "]        ");

            if (testNumber != 0)
            {
                Console.SetCursorPosition(38, 4);
                Console.Write(pattern[test / 10]);
            }
            else
            {
                Console.SetCursorPosition(38, 4);
                Console.Write("         ");
            }

            if (test >= 100)
            {
                test = 0;

                Console.SetCursorPosition(34, 0);
                Console.Write(pass + "%");

                Console.SetCursorPosition(34, 1);
                Console.Write("                                      ");
                testNumber++;
                pass += 2;

                if (testNumber == 2)
                    testNumber = 0;
            }

            Thread.Sleep(1000);
            test += r.Next(0, 3);
            seconds++;
        }
    }
}

7
Perché non eseguire semplicemente Memtest86? "Penso di avere alcuni problemi hardware qui, immagino che dovrò solo scherzare fino a quando non sarà fatto"
MadTux,

20
@MadTux 'Perché devi avviare Memtest, il che significa che non ci sono immagini di gatti.
Schilcote,

1
System.Console Funziona su Mono, penso che devi solo ottimizzare il codice per le dimensioni arbitrarie della finestra della console
NothingsImpossible

8
Non potresti eseguire Memtest86 in una macchina virtuale?
Cole Johnson,

3
ADORO il Memtest in un'idea VM.
John,


14

AHK

Fai finta di digitare mentre lo script genera un gruppo di accessor e mutatori in JavaScript. Assicurati che un IDE (l'ho provato su Notepad ++) sia la finestra attiva.

Se lo desideri, specifica l'elenco di variabili e il nome della classe. Ho appena usato ciò che era già inwindow.location .

Premere esc per uscire.

Premi 0 sul tuo tastierino numerico per mettere in pausa quando qualcuno prova a parlare con te.

Premi ctrl + w (w sta per lavoro) per iniziare

^w::
    loop{
        variable_names  :=  "hash|host|hostname|href|origin|pathname|port|protocol|search"
        class_name  :=  "location"

        StringSplit, variable_names_array, variable_names, "|"

        loop, %variable_names_array0%{
            Random, delay, 80, 120
            SetKeyDelay, %delay%
            current :=  variable_names_array%a_index%
            Send, %class_name%.prototype.
            Random, r, 800, 1300
            Sleep, %r%
            Send, get_
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current%
            Random, r, 800, 1300
            Sleep, %r%
            Send, {space}={space}
            Random, r, 800, 1300
            Sleep, %r%
            Send, function(){{}{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {tab}
            Random, r, 800, 1300
            Sleep, %r%
            Send, return this.
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current%;{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {BackSpace}{}}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {enter}{enter}
            Random, r, 800, 1300
            Sleep, %r%

            Send, %class_name%.prototype.
            Random, r, 800, 1300
            Sleep, %r%
            Send, set_
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current%
            Random, r, 800, 1300
            Sleep, %r%
            Send, {space}={space}
            Random, r, 800, 1300
            Sleep, %r%
            Send, function(%current%){{}{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {tab}
            Random, r, 800, 1300
            Sleep, %r%
            Send, this.
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current% ={space}
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current%;{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, return this;{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {BackSpace}{}}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {enter}{enter}
            Random, r, 800, 1300
            Sleep, %r%
        }
    }
return

esc::
    ExitApp
    return

numpad0::
    Pause, toggle
    return

14

bash

Scarica un blocco casuale di memoria fisica e osserva il contenuto. Sarà necessario essere root per questo. Solo i primi 1 MB di memoria sono disponibili per impostazione predefinita. ddla dimensione del blocco predefinita è 512 byte, che può essere modificata con l'opzione, ibs=bytesma tenere presente l'altra opzione skip=$offsetche seleziona un blocco a caso. L'output da ddviene inviato trper rimuovere i caratteri non ASCII; vengono valutati solo risultati unici di almeno 2 caratteri.

Ogni stringa trovata viene confrontata con un dizionario. Se non viene trovata alcuna corrispondenza, tenta di decodificare come base64. Infine, vengono restituite tutte le stringhe valutate.

Esistono diverse altre opzioni dipendenti dalla piattaforma di cui tenere conto, come la posizione del file del dizionario (/ usr / share / dict / words), se sleep accetta input in virgola mobile e se base64 è disponibile.

Inoltre, tenere presente che ddrestituisce le statistiche sull'operazione eseguita su stderr, che viene reindirizzato a / dev / null. Se qualcosa dovesse andare terribilmente storto (stai accedendo a / dev / mem ...) l'output stderr non sarà visibile.

Nel complesso, non molto utile, ma ho imparato qualcosa sulla memoria di Linux e scrivere questo script si è rivelato divertente.

#!/bin/bash

offset=`expr $RANDOM % 512`
mem=`dd if=/dev/mem skip=$offset count=1 2>/dev/null| tr '[\000-\040]' '\n' | tr '[\177-\377'] '\n' | sort -u | grep '.\{2,\}'`

results=""

for line in $mem
do
    echo "Evaluating $line"
    greps=`grep "^$line" /usr/share/dict/words | head`

    if [ -n "$greps" ]
    then
        echo "Found matches."
        echo $greps
    else
        #echo "No matches in dictionary. Attempting to decode."
        decode=`echo "$line" | base64 -d 2>/dev/null`
        if [ $? -ne 1 ]
        then
            echo "Decode is good: $decode"
        #else
            #echo "Not a valid base64 encoded string."
        fi
    fi

    results+=" $line"

    # make it look like this takes a while to process
    sleep 0.5

done 

if (( ${#results} > 1 ))
then
    echo "Done processing input at block $offset: $results"
fi

A volte non c'è output interessante (tutti gli zero). A volte ci sono solo alcune stringhe:

codegolf/work# ./s 
Evaluating @~
Evaluating 0~
Evaluating ne
Found matches.
ne nea neal neallotype neanic neanthropic neap neaped nearable nearabout
Done processing input at block 319:  @~ 0~ ne

A volte in realtà c'è qualcosa di leggibile dall'uomo in memoria (prima che registrassi l'offset del blocco):

codegolf/work# ./s 
Evaluating grub_memset
Evaluating grub_millisleep
Evaluating grub_mm_base
Evaluating grub_modbase
Evaluating grub_named_list_find
Evaluating grub_net_open
Evaluating grub_net_poll_cards_idle
Evaluating grub_parser_cmdline_state
Evaluating grub_parser_split_cmdline
Evaluating grub_partition_get_name
Evaluating grub_partition_iterate
Evaluating grub_partition_map_list
Evaluating grub_partition_probe
Evaluating grub_pc_net_config
Evaluating grub_pit_wait
Evaluating grub_print_error
Evaluating grub_printf
Evaluating grub_printf_
Evaluating grub_puts_
Evaluating grub_pxe_call
Evaluating grub_real_dprintf
Evaluating grub_realidt
Evaluating grub_realloc
Evaluating grub_refresh
Evaluating grub_register_command_prio
Evaluating grub_register_variable_hook
Evaluating grub_snprintf
Evaluating grub_st
Evaluating grub_strchr
Evaluating _memmove
Done processing input:  grub_memset grub_millisleep grub_mm_base 
    grub_modbase grub_named_list_find grub_net_open grub_net_poll_cards_idle
    grub_parser_cmdline_state grub_parser_split_cmdline 
    grub_partition_get_name grub_partition_iterate grub_partition_map_list 
    grub_partition_probe grub_pc_net_config grub_pit_wait grub_print_error 
    grub_printf grub_printf_ grub_puts_ grub_pxe_call grub_real_dprintf 
    grub_realidt grub_realloc grub_refresh grub_register_command_prio 
    grub_register_variable_hook grub_snprintf grub_st grub_strchr _memmove

E un'ultima esecuzione di esempio che mostra l'input grep non valido, i risultati del dizionario e una decodifica base64 riuscita (prima di registrare nuovamente l'offset del blocco):

codegolf/work# ./s 
Evaluating <!
Evaluating !(
Evaluating @)
Evaluating @@
Evaluating $;
Evaluating '0@
Evaluating `1
Evaluating 1P$#4
Evaluating )$2
Evaluating -3
Evaluating 3HA
Evaluating 3N
Evaluating @@9
Evaluating 9@
Evaluating 9Jh
Evaluating \9UK
grep: Invalid back reference
Evaluating a#
Evaluating CX
Evaluating ?F
Evaluating !H(
Evaluating +%I
Evaluating Io
Found matches.
Io Iodamoeba Ione Ioni Ionian Ionic Ionicism Ionicization Ionicize Ionidium
Evaluating Kj
Found matches.
Kjeldahl
Evaluating l#
Evaluating L6qh
Decode is good: /��
Evaluating O%
Evaluating OX
Evaluating PR
Evaluating .Q
Evaluating Q4!
Evaluating qQ
Evaluating )u
Evaluating Ua
Found matches.
Uaraycu Uarekena Uaupe
Evaluating $v
Evaluating )V
Evaluating V8
Evaluating V,B~
Evaluating wIH
Evaluating xU
Evaluating y@
Evaluating @z
Evaluating Z0
Evaluating zI
Evaluating Z@!QK
Done processing input:  <! !( @) @@ $; '0@ `1 1P$#4 )$2 -3 3HA 3N
    @@9 9@ 9Jh \9UK a# CX ?F !H( +%I Io Kj l# L6qh O% OX PR .Q Q4!
    qQ )u Ua $v )V V8 V,B~ wIH xU y@ @z Z0 zI Z@!QK

Come si esegue questo? L'ho scaricato script.sh, l'ho chmod +xfatto, ma esce. sudonon aiuta neanche.
Octavia Togami,

Sembra che la mem=linea non stia restituendo nulla. Dovrai controllare e assicurarti che ogni parte del comando tra pipe stia effettivamente restituendo qualcosa.

Va bene, lo farò.
Octavia Togami,

Questo ha funzionato solo per circa 5 secondi la prima volta e stampato come 12 righe, quindi come 0,1 secondi ogni volta successiva senza output.
Mike,

13

Windows Batch

@echo off

set /p hax="How much haxx0rz: " %=%
set /p haxx="How quick haxx0rz (seconds): " %=%

FOR /L %%I IN (1, 1, %hax%) DO (
START cmd /k "COLOR A&&tree C:\"
timeout %haxx%
)

Questa è una sceneggiatura scherzosa che ho tenuto con me per anni per far sembrare qualcosa tratto da un film di hacker degli anni '90. Di solito lo uso mentre sono collegato in remoto a un computer per dare di matto alla gente.


2
Sta scaricando un virus su tutto il sistema!
qwr

12

bash

La ricerca infinita di caffè.

L'ho trovato sul web molto tempo fa:

cat /dev/urandom | hexdump | grep "ca fe"

Prova invece a usare urandom.
Alice Ryhl,

Ah ... l'ho provato su un Mac e i Mac hanno entrambi randome urandom.
daviewales,

5
/dev/randomesiste, ma è destinato ad essere più sicuro rispetto /dev/urandomalla generazione di numeri solo se è disponibile entropia. Una volta esaurito, si ferma. /dev/urandomnon lo fa e non smetterà mai di emettere.
undergroundmonorail

Perché non finisce mai? Mi sento stupido, la seconda volta oggi.
Daniel W.

1
/dev/urandomè un 'file' che fornisce continuamente numeri casuali a cat. catquindi li convoglia a hexdump, ecc.
daviewales,

11

Python 2.7

The Endless Test Suite

"Esegue" una serie di "Test unità" su tutti i file nella struttura della directory. Attraversa tutte le sottodirectory. Ricomincia quando arriva alla fine.

Stampa uno stato in esecuzione:

============================= entering . =============================
------------------------ test_line_numbers.py ------------------------
Ran 18 tests in 3.23707662572 seconds, 0 errors
---------------------------- test_main.c ----------------------------
Ran 26 tests in 1.3365194929 seconds, 0 errors
--------------------------- test_parser.c ---------------------------
Ran 8 tests in 1.61633904378 seconds, 0 errors
--------------------------- test_README.c ---------------------------
Ran 12 tests in 2.27466813182 seconds, 0 errors
4 modules OK (0 failed)
=========================== entering ./lib ===========================

...

Funzionalità che lo rendono più complesso del necessario e, auspicabilmente, più realistico:

  • Il numero di test e il tempo di test è proporzionale alla dimensione del file.
  • Trasforma le estensioni di file non in codice sorgente in note. ModificareCodeExtensions per aggiungere tipi più noti.
    • Seleziona una nuova estensione in base alla frequenza dei file di lingua effettiva visualizzati, quindi non sarai visto testare il codice Python se il tuo disco rigido è pieno di Ruby.
  • Salta i file con i principali . omaggi come "test_.bashrc.js"
import os,random,time,collections

CodeExtensions = ('.py', '.c','.cpp','.rb','.js','.pl','.cs','.el')
last_exts = collections.deque(CodeExtensions[:1],100)
maxlen=0

def maketestname(filename):
    root,ext = os.path.splitext(filename)
    if ext in CodeExtensions:
        last_exts.append(ext)
    else:
        ext = random.choice(last_exts)
    return 'test_'+root+ext

def banner(char,text,width=70):
    bar = char*((width-len(text)-2)/2)
    return "{} {} {}".format(bar,text,bar)

def scaledrand(scale,offset):
    return random.random()*scale+random.randrange(offset)

while True:
    for dirname, subdirs, files in os.walk('.'):
        print banner('=',"entering {}".format(dirname))
        skipped = 0
        for filename in files:
            if filename[0] is not '.':
                testfilename = maketestname(filename)
                print banner('-',testfilename)
                filelen = os.path.getsize(os.path.join(dirname,filename))
                maxlen = max(maxlen,filelen)
                ntests = int(scaledrand(20*filelen/maxlen,10))
            testtime = scaledrand(ntests/5.0,2)
            time.sleep(testtime)                
            else:
                skipped+=1
                continue

            print "Ran {} tests in {} seconds, {} errors".format(ntests,testtime,0)
        print "{} modules OK ({} failed)\n".format(len(files)-skipped,0)

1
Potresti anche semplicemente eseguire i test di regressione di Python, che sono in bundle con la maggior parte delle installazioni di Python.
nneonneo,

Ma quelli finiscono alla fine.
AShelly,

2
allora potresti eseguirli ... in un ciclo!
nneonneo,

1
Sto anche pensando che sia meno sospetto testare i file con nomi relativi ai tuoi progetti che testare la fonte Python. Immagino che la maggior parte di noi non mantenga professionalmente Python ...
AShelly,

11

Java + Guava 16 (Guava non è super necessario, ma ha reso alcune cose un po 'meno fastidiose da scrivere).

Va bene, dovresti lavorare? Che ne dici di un programma che scrive effettivamente il vero codice Java, che in realtà si compila (anche se non fa molto).

È difficile dimostrare l'animazione, ma questo programma scrive un programma Java utilizzando il dizionario predefinito (250 parole inglesi comuni) o un file delimitato da nuova riga (preso come argomento della riga di comando) e lo digita sulla console un carattere alla volta a velocità apparentemente umane . Assicurati di eseguirlo da solo perché questo post non rende giustizia. Al termine, attende 1 minuto, quindi stampa molte righe vuote sulla console e ricomincia da capo. Ho provato a scriverlo per rendere ragionevolmente modificabili vari parametri.

Inoltre, normalmente lo metterei in più di un file, ma per rendere più semplice l'esecuzione ho distrutto tutte le classi insieme.

package org.stackoverflow.ppcg;

import java.io.*;
import java.util.*;

import com.google.common.base.CaseFormat;
import com.google.common.base.Converter;
import com.google.common.collect.Lists;

public class CodeGenerator {
    public static final Converter<String, String> TOUPPER =
            CaseFormat.LOWER_CAMEL.converterTo(CaseFormat.UPPER_CAMEL);
    public static final Converter<String, String> TOLOWER =
            CaseFormat.UPPER_CAMEL.converterTo(CaseFormat.LOWER_CAMEL);

    public static final String[] TYPES = new String[]{
        "int", "long", "double", "String"
    };

    public static final List<String> DEFAULT_LIST = Arrays.asList(new String[]{
            "the", "and", "for", "you", "say", "but", "his", "not", "she", "can",
            "who", "get", "her", "all", "one", "out", "see", "him", "now", "how",
            "its", "our", "two", "way", "new", "day", "use", "man", "one", "her",
            "any", "may", "try", "ask", "too", "own", "out", "put", "old", "why",
            "let", "big", "few", "run", "off", "all", "lot", "eye", "job", "far",
            "have", "that", "with", "this", "they", "from", "that", "what", "make", "know",
            "will", "time", "year", "when", "them", "some", "take", "into", "just", "your",
            "come", "than", "like", "then", "more", "want", "look", "also", "more", "find",
            "here", "give", "many", "well", "only", "tell", "very", "even", "back", "good",
            "life", "work", "down", "call", "over", "last", "need", "feel", "when", "high",
            "their", "would", "about", "there", "think", "which", "could", "other", "these", "first",
            "thing", "those", "woman", "child", "there", "after", "world", "still", "three", "state",
            "never", "leave", "while", "great", "group", "begin", "where", "every", "start", "might",
            "about", "place", "again", "where", "right", "small", "night", "point", "today", "bring",
            "large", "under", "water", "write", "money", "story", "young", "month", "right", "study",
            "people", "should", "school", "become", "really", "family", "system", "during", "number", "always",
            "happen", "before", "mother", "though", "little", "around", "friend", "father", "member", "almost",
            "change", "minute", "social", "follow", "around", "parent", "create", "others", "office", "health",
            "person", "within", "result", "change", "reason", "before", "moment", "enough", "across", "second",
            "toward", "policy", "appear", "market", "expect", "nation", "course", "behind", "remain", "effect",
            "because", "through", "between", "another", "student", "country", "problem", "against", "company", "program",
            "believe", "without", "million", "provide", "service", "however", "include", "several", "nothing", "whether",
            "already", "history", "morning", "himself", "teacher", "process", "college", "someone", "suggest", "control",
            "perhaps", "require", "finally", "explain", "develop", "federal", "receive", "society", "because", "special",
            "support", "project", "produce", "picture", "product", "patient", "certain", "support", "century", "culture"
    });

    private static final int CLASS_NAME_LENGTH = 2;

    private final WordList wordList;
    private final Appendable out;
    private final Random r = new Random();

    private CodeGenerator(WordList wordList, Appendable out) {
        this.wordList = wordList;
        this.out = out;
    }

    public static void main(String... args) throws Exception {
        List<?> wordSource = getWords(args);
        WordList list = new WordList(wordSource);
        SleepingAppendable out = new SleepingAppendable(System.out);
        CodeGenerator generator = new CodeGenerator(list, out);
        while(!Thread.interrupted()) {
            generator.generate();
            try {
                Thread.sleep(60000);
            } catch (InterruptedException e) {
                break;
            }
            out.setSleeping(false);
            for(int i = 0; i < 100; i++) {
                out.append(System.lineSeparator());
            }
            out.setSleeping(true);
        }
    }

    private static List<?> getWords(String[] args) {
        if(args.length > 0) {
            try {
                return getListFromFile(args[0]);
            } catch(IOException e) { }
        }
        return DEFAULT_LIST;
    }

    private static List<Object> getListFromFile(String string) throws IOException {
        List<Object> newList = Lists.newArrayList();

        File f = new File(string);
        Scanner s = new Scanner(f);

        while(s.hasNext()) {
            newList.add(s.nextLine());
        }

        return newList;
    }

    private void generate() throws IOException {
        String className = beginClass();
        List<Field> finalFields = generateFields(true);
        printFields(finalFields);
        out.append(System.lineSeparator());
        List<Field> mutableFields = generateFields(false);
        printFields(mutableFields);
        out.append(System.lineSeparator());
        printConstructor(className, finalFields);
        printGetters(finalFields);
        printGetters(mutableFields);
        printSetters(mutableFields);
        endClass();
    }

    private void printGetters(List<Field> fields) throws IOException {
        for(Field f : fields) {
            out.append(System.lineSeparator());
            f.printGetter(out);
        }
    }

    private void printSetters(List<Field> fields) throws IOException {
        for(Field f : fields) {
            out.append(System.lineSeparator());
            f.printSetter(out);
        }
    }

    private void printConstructor(String className, List<Field> finalFields) throws IOException {
        out.append("\tpublic ").append(className).append('(');
        printArgs(finalFields);
        out.append(") {").append(System.lineSeparator());
        for(Field f : finalFields) {
            f.printAssignment(out);
        }
        out.append("\t}").append(System.lineSeparator());
    }

    private void printArgs(List<Field> finalFields) throws IOException {
        if(finalFields.size() == 0) return;

        Iterator<Field> iter = finalFields.iterator();

        while(true) {
            Field next = iter.next();
            next.printTypeAndName(out);
            if(!iter.hasNext()) break;
            out.append(", ");
        }
    }

    private List<Field> generateFields(boolean isfinal) {
        int numFields = r.nextInt(3) + 2;
        List<Field> newFields = Lists.newArrayListWithCapacity(numFields);
        for(int i = 0; i < numFields; i++) {
            String type = TYPES[r.nextInt(4)];
            newFields.add(new Field(type, wordList.makeLower(r.nextInt(2) + 1), isfinal));
        }
        return newFields;
    }

    private void printFields(List<Field> finalFields) throws IOException {
        for(Field f : finalFields) {
            f.printFieldDeclaration(out);
        }
    }

    private String beginClass() throws IOException {
        out.append("public class ");
        String className = wordList.nextClassName(CLASS_NAME_LENGTH);
        out.append(className).append(" {").append(System.lineSeparator());

        return className;
    }

    private void endClass() throws IOException {
        out.append("}");
    }

    private static class WordList {
        private final Random r = new Random();

        private final List<?> source;

        private WordList(List<?> source) {
            this.source = source;
        }

        private String makeUpper(int length) {
            StringBuilder sb = new StringBuilder();
            for(int i = 0; i < length; i++) {
                sb.append(randomWord());
            }
            return sb.toString();
        }

        private String makeLower(int length) {
            return TOLOWER.convert(makeUpper(length));
        }

        private String randomWord() {
            int sourceIndex = r.nextInt(source.size());
            return TOUPPER.convert(source.get(sourceIndex).toString().toLowerCase());
        }

        public String nextClassName(int length) {
            return makeUpper(length);
        }
    }

    private static class Field {
        private final String type;
        private final String fieldName;
        private final boolean isfinal;

        Field(String type, String fieldName, boolean isfinal) {
            this.type = type;
            this.fieldName = fieldName;
            this.isfinal = isfinal;
        }

        void printFieldDeclaration(Appendable appendable) throws IOException {
            appendable.append("\tprivate ");
            if(isfinal) appendable.append("final ");
            printTypeAndName(appendable);
            appendable.append(';').append(System.lineSeparator());
        }

        void printTypeAndName(Appendable appendable) throws IOException {
            appendable.append(type).append(' ').append(fieldName);
        }

        void printGetter(Appendable appendable) throws IOException {
            appendable.append("\tpublic ");
            appendable.append(type).append(" get").append(TOUPPER.convert(fieldName));
            appendable.append("() {").append(System.lineSeparator());
            appendable.append("\t\treturn ").append(fieldName).append(';');
            appendable.append(System.lineSeparator()).append("\t}").append(System.lineSeparator());
        }

        void printSetter(Appendable appendable) throws IOException {
            appendable.append("\tpublic void set");
            appendable.append(TOUPPER.convert(fieldName));
            appendable.append("(").append(type).append(' ').append(fieldName);
            appendable.append(") {").append(System.lineSeparator());
            printAssignment(appendable);
            appendable.append("\t}").append(System.lineSeparator());            
        }

        void printAssignment(Appendable appendable) throws IOException {
            appendable.append("\t\tthis.").append(fieldName).append(" = ").append(fieldName);
            appendable.append(';').append(System.lineSeparator());
        }
    }

    private static class SleepingAppendable implements Appendable {
        private Random r = new Random();
        private Appendable backing;

        private boolean sleeping = true;

        public SleepingAppendable(Appendable backing) {
            this.backing = backing;
        }

        @Override
        public Appendable append(CharSequence csq) throws IOException {
            return append(csq, 0, csq.length());
        }

        @Override
        public Appendable append(CharSequence csq, int start, int end)
                throws IOException {
            for(int i = start; i < end; i++) {
                append(csq.charAt(i));
            }

            sleep(100, 300);

            return this;
        }

        @Override
        public Appendable append(char c) throws IOException {
            sleep(170, 80);

            backing.append(c);

            return this;
        }


        private void sleep(int base, int variation) {
            if(!sleeping) return;
            try {
                Thread.sleep((long) (r.nextInt(80) + 70));
            } catch (InterruptedException e) {
            }
        }

        public boolean isSleeping() {
            return sleeping;
        }

        public void setSleeping(boolean sleeping) {
            this.sleeping = sleeping;
        }
    }
}

Esempio di output del programma (solo un programma)

public class GetGroup {
    private final double thoughRight;
    private final double socialYear;
    private final double manOne;
    private final int appear;

    private double man;
    private double comeHis;
    private double certain;

    public GetGroup(double thoughRight, double socialYear, double manOne, int appear) {
        this.thoughRight = thoughRight;
        this.socialYear = socialYear;
        this.manOne = manOne;
        this.appear = appear;
    }

    public double getThoughRight() {
        return thoughRight;
    }

    public double getSocialYear() {
        return socialYear;
    }

    public double getManOne() {
        return manOne;
    }

    public int getAppear() {
        return appear;
    }

    public double getMan() {
        return man;
    }

    public double getComeHis() {
        return comeHis;
    }

    public double getCertain() {
        return certain;
    }

    public void setMan(double man) {
        this.man = man;
    }

    public void setComeHis(double comeHis) {
        this.comeHis = comeHis;
    }

    public void setCertain(double certain) {
        this.certain = certain;
    }
}

Un altro output di esempio:

public class TryControl {
    private final int over;
    private final double thatState;
    private final long jobInto;
    private final long canPut;

    private int policy;
    private int neverWhile;

    public TryControl(int over, double thatState, long jobInto, long canPut) {
        this.over = over;
        this.thatState = thatState;
        this.jobInto = jobInto;
        this.canPut = canPut;
    }

    public int getOver() {
        return over;
    }

    public double getThatState() {
        return thatState;
    }

    public long getJobInto() {
        return jobInto;
    }

    public long getCanPut() {
        return canPut;
    }

    public int getPolicy() {
        return policy;
    }

    public int getNeverWhile() {
        return neverWhile;
    }

    public void setPolicy(int policy) {
        this.policy = policy;
    }

    public void setNeverWhile(int neverWhile) {
        this.neverWhile = neverWhile;
    }
}

9
Hai creato una macchina da stampa automatica per tutti coloro che sono ancora pagati con righe di codice - ottimo lavoro!
Philipp

9

bash

Emette alcuni commenti da file sorgente casuali a intervalli casuali, seguiti da una barra di avanzamento del nulla generata casualmente.

#!/bin/bash

# The directory to extract source comments from
srcdir=~/src/php-src/

# Generate a status bar that lasts a random amount of time.
# The actual amount of time is somewhere between 1.5 and 30
# seconds... I think. I fudged this around so much it's hard to tell.
function randstatus() {
    bsize=4096
    r_rate=$(echo "$RANDOM/32767 * $bsize * 1.5 + $bsize / 4" | bc -l | sed 's/\..*$//')
    r_min=3
    r_max=15
    r_val=$(($r_min + $RANDOM % $(($r_max - $r_min)) ))
    i=0
    dd if=/dev/urandom bs=$bsize count=$r_val 2> /dev/null | pv -L $bsize -s $(($r_val * bsize)) > /dev/null
}

# Picks a random .c file from the given directory, parses
# out one-line comments, and outputs them one by one with a
# random delay between each line.
function randout() {
    r_file=$(find $1 -name '*.c' | sort -R | head -n 1)
    echo "# $r_file"
    grep '^\s*/\*.*\*/\s*$' $r_file | sed 's:[/\*]::g' | sed -e 's:^\s\+::' -e 's:\s\+$::' | sed -e 's:^\W\+::' | grep -v '^$' | while read line; do
        echo $line
        sleep $(printf "%0.2f" $(echo "$((($RANDOM%4)+1))/4" | bc -l))
    done
}

while true; do
    randout $srcdir
    randstatus
    # sleep here to make it easier to break out of the 'while read' loop
    sleep 2
done

Produzione:

# /home/jerkface/src/php-src/sapi/fpm/fpm/fpm_shm.c
Id: fpm_shm.c,v 1.3 20080524 17:38:47 anight Exp $
c) 2007,2008 Andrei Nigmatulin, Jerome Loyet
MAP_ANON is deprecated, but not in macosx
  32kB 0:00:08 [3.97kB/s] [====================================================================>] 100%
# /home/jerkface/src/php-src/ext/mbstring/mb_gpc.c
Id$
includes
mbfl_no_encoding _php_mb_encoding_handler_ex()
split and decode the query
initialize converter
auto detect
convert encoding
we need val to be emalloc()ed
add variable to symbol table
SAPI_POST_HANDLER_FUNC(php_mb_post_handler)
  12kB 0:00:03 [4.02kB/s] [===============>                                                      ] 24% ETA 0:00:09

1
Intelligente! È un po 'tardi per ricevere più attenzione, ma prendi il cinque da me.
SomeKittens,

@SomeKittens Il vero genio di questa sceneggiatura è che lavorarci su sembra ancora più un vero lavoro. ; D
Sammitch,

7

Modulo Rsync BASH

 rsync -n -avrIc --verbose  ~ ~ | sed s/"(DRY RUN)"/""/g    
# Note the space at the beginning of the above line,

rsync - uno strumento di copia dei file veloce, versatile, remoto (e locale) ... che con -n esegue una corsa a secco , prova solo a fare, non lo fa davvero, e mostra cosa succede.
In questo caso prova a controllare se aggiornare tutti i file della tua home directory (e delle sottocartelle ).
Se hai ovviamente l'accesso root puoi eseguirlo su una parte più grande del tuo filesystem.

Appunti:

  1. Se HISTCONTROL=ignoreboth o almeno HISTCONTROL=ignorespacenella tua sessione di bash la tua storia di bash non ricorderà quel comando se lo scrivevi con uno spazio prima. (Non è possibile spingere verso l'alto e vederlo sullo schermo, né nel registro della cronologia ).
  2. | sed s/"(DRY RUN)"/""/greindirizzerà l'output sedche cancellerà il (DRY RUN)testo alla fine dell'output rsync. Se un esperto controlla puoi dire che lo stai facendo davvero, non solo test.
  3. -avrIcpuoi modificare queste opzioni, controllare man rsync, ma non rimuovere mai-n , altrimenti dovresti avere seri problemi, ancora di più se corri come root ... 8-O!

6

Maven sotto bash

Maven è semplicemente perfetto per questo tipo di attività ;-)

while true;
do mvn -X archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false;
done

6

Cobra

Questo apre una finestra della console che scorre attraverso vari oggetti falsi e cose assortite, aumentando in passaggi e progressi per ogni passaggio. Attende un piccolo tempo casuale ogni incremento, per simulare i ritardi di calcolo effettivi.

class Does_Nothing_Useful
    var _rng as Random = Random()
    var _hash
    var _pass
    var _names as String[] = @['Vector', 'Object', 'File', 'Index', 'Report', 'Library', 'Entry', 'Log', 'Resource', 'Directory']
    def main
        while true
            .refresh
            name as String = _names[_rng.next(_names.length)] + ' ' + _hash.toString
            for i in _pass
                progress as decimal = 0
                while progress < 100000
                    progress += _rng.next(1000)
                    print name + '; pass', i, ' : ', progress/1000
                    wait as int = 0
                    for n in _rng.next(50), wait += _rng.next(1,100)
                    System.Threading.Thread.sleep(wait)
                print name + '; pass', i, '--FINISHED--'
                print ''
                System.Threading.Thread.sleep(_rng.next(1000,17500))
            print name, '--EVAL COMPLETE--'
            print ''
            System.Threading.Thread.sleep(_rng.next(12500,30000))
    def refresh
        _hash = _rng.next.getHashCode
        _pass = _rng.next(256)
        print '--LOADING NEXT TARGET--'
        print ''
        System.Threading.Thread.sleep(_rng.next(12500,30000))

1
Hai tutto il fine settimana per lavorare su questo, quindi prenditi il ​​tuo tempo.
SomeKittens,

1
Cos'è questo linguaggio Cobra, sembra il figlio bastardo di Python e C #, ahah (guardando in alto sembra avere alcune caratteristiche interessanti), +1
Thomas

1
@Thomas Per la maggior parte, è C # (attualmente senza LINQ) usando la sintassi di Python-esque. E uno dei compilatori predefiniti più utili con cui abbia mai avuto il piacere di lavorare.
Οurous

Quindi hai mai finito di completare questo codice?
Rayryeng,

4

Ho scritto una stupida sceneggiatura in pitone per farlo una volta. Chiamato "ProgramAboutNothing" ... Non sono sicuro che sia così convincente ma mi ci sono voluti solo circa 10 minuti. Emette solo frasi casuali che descrivono ciò che sta presumibilmente facendo ... Probabilmente avrei potuto scegliere parole migliori per questo che potrebbero sembrare più convincenti ma non l'ho mai usato correttamente. Immagino che se qualcuno vuole usarlo, può modificarlo e aggiungere le proprie parole negli elenchi ... I fan di Sim City potrebbero notare qualcosa di familiare, però. : P

from random import randrange
from time import sleep

nouns = ["bridge", "interface", "artifact", "spline"]
verbs = ["building", "articulating", "reticulating", "compiling", "analyzing"]
adjectives = ["mix", "abstract", "essential"]

while True:
    one = randrange(0,5)
    two = randrange(0,4)
    print "%s %s" % (verbs[one], nouns[two]),
    sleep(randrange(0,500)/100)
    print ".",
    sleep(randrange(0,500)/100)
    print ".",
    sleep(randrange(0,500)/100)
    print ".\n",
    loop = randrange(0,50)
    one = randrange(0,5)
    for i in range(loop):
        two = randrange(0,4)
        three = randrange(0,3)
        print "%s %s %s" % (verbs[one], nouns[two], adjectives[three]),
        sleep(randrange(0,250)/100)
        print ".",
        sleep(randrange(0,250)/100)
        print ".",
        sleep(randrange(0,250)/100)
        print ".\n",

1
Forse stai usando Python 3? Prova ad aggiungere parentesi attorno alle dichiarazioni di stampa in questo modo: print( ... ).
daviewales,

1
@daviewales ninja'd: P
Luca,

1
@ Luca Ho appena installato Python 3.4.1per Windows. Non posso programmare in Python, ma sono interessato al tuo piccolo programma ...
Mathlight,

1
@Mathlight si prepara a essere deludente. : P
Luca,

1
@luke, ora funziona. E sono rimasto colpito ^ _ ^
Mathlight l'

4

Che ne dici di questo? Scaricherà i dati HTML di codegolf ogni 1 secondo. Pertanto, i dati continueranno a cambiare fino a quando arrivano le domande più recenti. Allo stesso tempo, sembrerà anche che si stiano scaricando alcuni dati critici da un sito Web.

while true; do     
sleep 1;     
curl "codegolf.stackexchange.com" -s |  w3m -dump -T text/html; 
done

3

bash

L'elenco delle directory ricorsive:

ll -R /

2

Questa è una simulazione del compilatore C ++ (scritta in C #):

using System;
using System.Collections.Generic;
using System.Management;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.IO;
using System.Reflection;

class FakeCompiler {
    static void DoPrint(string txt) {
        Console.WriteLine("Compiling " + txt);
        Thread.Sleep(1000);
    }
    static string Extract(string TypeName) {
        string rt = TypeName.Split(new Char[] {'.'})[ TypeName.Split(new Char[] {'.'}).Length - 1 ];
        if (rt.Contains("+")) {
            rt = rt.Split(new char[] { '+' })[1];
        }
        if (rt.Contains("[")) {
            rt = rt.Split(new char[] { '[' })[0];
        }
        return rt;
    }
    static void DoCompileSingleFile(string _Type_Name) {
        string print = Extract(_Type_Name);
        DoPrint(print + ".h");
        DoPrint(print + ".cpp");
    }
    static Type[] DoFakeCompile_Assembly(string _AssemblyFileName) {
        System.Reflection.Assembly _asm = System.Reflection.Assembly.Load(_AssemblyFileName);
        Type[] _ts = _asm.GetTypes();
        for (int h = 0; h < 15; ++h) {
            DoCompileSingleFile(_ts[h].ToString());
        }
        return _ts;
    }
    static void DoFakeLinkErrors(Type[] t) {
        Console.WriteLine("linking..");
        Thread.Sleep(2000);
        MethodInfo[] mi;
        for (int i = 0; i < t.Length; ++i) {
            mi = t[i].GetMethods();
            for (int j = 0; j < mi.Length; ++j) {
                Console.WriteLine("Link Error: The object {@!" + mi[j].ToString().Split(new char[] {' '})[0] + "#$? is already defined in " + Extract(t[i].ToString()) + ".obj");
                Thread.Sleep(200);
            }
        }
    }
    static void Main(string[] args) {
        Console.WriteLine("Fictional C/C++ Optimizing Command-line Compiler Version 103.33.0");
        DoFakeLinkErrors(DoFakeCompile_Assembly("mscorlib.dll"));
    }
}


2

Lotto

Metti in una cartella con molti file. Se scorre abbastanza velocemente, nessuno sospetterà nulla.

:l
dir/s
echo %RANDOM%
echo %RANDOM%
echo %RANDOM% 
goto l

2
emerge @world

ricompilazione completa su gentoo


Sono abbastanza sicuro che la disponibilità di questa prima scusa sia la ragione principale per eseguire Gentoo.
Caleb,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.