Souvent, je suis amené à exécuter un script ou une requête dont l’exécution prend beaucoup de temps. Je peux laisser ce script ouvert et profiter d'une procrastination sans culpabilité.

Maintenant, si je pouvais écrire un script qui semble être l’un des scripts ci-dessus pour les spectateurs, mais uniquement pour les looks? Je pouvais l'afficher sur un écran et profiter de plusieurs jours de flux de données pour les chaton avant que quiconque ne se rende compte que tous les tracas compliqués à l'écran n'avaient rien à voir avec mon travail actuel.

Votre défi est d'écrire ce script pour moi (oui, je suis aussi paresseux).

Une bonne réponse va:

• Faites apparaître à l'écran quelque chose qui ressemble à un script qui fonctionne. "Écran" peut être un terminal, un navigateur, etc.
• Soyez assez original (oui, nous avons tous vu les programmes de la barre de progression sans fin)
• Survivez à un examen rapide par une personne technique

Une mauvaise réponse va:

• Me faire virer
• Rehash quelque chose que nous avons tous été transférés dans les années 90

Une réponse stellaire pourrait:

• Transcend un des points critiques ci-dessus ( par exemple )
• Survivre à l'examen critique
• * * halètement fait faire quelque chose qui est utile ou des aides dans mon travail dérobade

L'acceptation sera basée sur les votes, avec en prime des résultats réels. En réalité, je vais exécuter ces scripts (Linux Mint 16) au travail lorsque mon écran est visible (réunions et autres) pour déterminer la détection. Si quelqu'un remarque qu'il fait semblant, vous êtes hors de la course. Si quelqu'un commente à quel point je travaille fort, +5 bonus de bonus pour vous.

"Utile" dans ce cas peut s'appliquer à n'importe quel codeur, mais si vous recherchez un surcroît d'éclat sur votre pomme liée au professeur, je suis un développeur Web complet qui travaille dans le code à peu près en fonction de mes balises .

Question partiellement inspirée par cela .

Résultats

Malheureusement, je n’ai reçu aucun commentaire sur ces entrées. Ils sont tous géniaux, alors vous êtes tous gagnants dans mon cœur. Cependant, Loktar a le plus de votes de loin, il obtient donc le +15 de l'accepter. Félicitations!

JavaScript

Alors je suis devenu un peu fou avec ça. Je l'ai fait entre les pauses de mon interface graphique pour suivre les adresses IP à l'aide de Visual Basic.

Vous pouvez y accéder en accédant au domaine extrêmement sérieux que j'ai créé pour ce soir afin de pouvoir paraître occupé n'importe où dans Gui Hacker et créer votre propre répertoire à partir des sources suivantes.

• Violon
• CodePen
• github

En gros, si vous courez ça, personne ne vous dérangera, car ils savent que vous faites des choses sérieuses.

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>

Bash / coreutils

Présentation du tout premier ... émulateur de compilation . Avec ce programme, vous pouvez avoir des combats d'épée de chaise de bureau épiques à tout moment, sans même écrire de code!

#!/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

Il utilise les données de /usr/includepour créer un journal de compilation réaliste. J'étais trop paresseux pour lancer des avertissements aléatoires, alors il n'y a qu'un -wdrapeau.

Échantillon aléatoire:

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 / libiptc.o libiptc / libxtc.o libiptc / xtcshar.o. alors
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 /pice-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-1.0 / 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_REPOSANT_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-1.0 / 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 -ccairomm-1.0 / cairomm / quartz_font.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 -ccairomm-1.0 / cairomm / win32_font.c -o cairomm-1.0 / cairomm
gcc -w -O0 -pipe -m64 -msse -msse2 -msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -ccairomm-1.0 / cairomm / refptr.c -o cairomm-1.0 / cairomm-1.0 / cairomm-ref
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 / cairomm.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 -cairomm-1.0 / cairomm / contexte.c -o cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / 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 -ccairomm-1.0 / cairomm / enums.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 / win32_surface.c -o c commomm-g / v
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-1.0 / cairomm-1.0 / 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 / types.c -o cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / 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 / matrix.c -o cairomm-1.0 / cairomm-1.0 / 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 / quartz_surface.c -o cairomm-1.0 / cairomm-dialogue
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-1.0 / 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 / device.c -o cairomm-1.0 / cairomm-1.0 / 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 / surface.c -o cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / 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 / xlib_surface.c -o / e
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-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 / region.c -o cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / cairomm-1.0 / cairomm-1.0
gcc -w -O0 -pipe -m64 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -msse -msse2 -msse4 -msse4_1 -shared cairomm-1.0 / cairomm / cairomm.coairomm-1.0 / cairomm. /cairomm/service.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 / win3_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

Frapper

Affiche infiniment des valeurs hexadécimales aléatoires, certaines d'entre elles étant mises en évidence pour donner l'impression que vous effectuez une recherche complexe dans des données brutes.

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

Une très longue construction:

emerge openoffice

Rubis

Celui-ci va:

1. Obtenez un code aléatoire de ce site. révision du code (pour un code plus lisible et bien écrit)
2. Donnez l’impression que vous tapez ce code.

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

Voici ce script basé sur un code tiré d' ici :

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

Voici à quoi ça ressemble:

Partons avec un script bash simple qui donne une apparence hacker en imprimant le contenu de chaque fichier identifié comme texte dans / var / log / ligne par ligne, avec des retards aléatoires pour donner l’impression que des événements intenses se produisent. Selon les fichiers consultés, cela peut donner une sortie plutôt intéressante.

#/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

Assurez-vous que votre thème de terminal a l'air hackerish Voici quelques exemples de badass (aucune idée de ce que cela signifie, mais cela semble hacker):

Bash: Le commit sans fin git

L’un des problèmes actuels des ordinateurs est qu’ils sont assez rapides. Même les tâches de compilation finissent donc. En outre, si vous exécutez un script sur une longue période, vous pouvez faire valoir qu'il est en fait possible de continuer à travailler sur autre chose pendant l'exécution du script.

Pour résoudre cela, nous avons le programme suivant. Apprenez simplement à taper «y» ou «n» au hasard de temps en temps.

Bien sûr, vous avez besoin d’un dépôt git contenant du nouveau contenu, mais en supposant que vous fassiez un travail réel qui ne devrait pas poser de problème.

#!/bin/bash

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

Frapper

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

Cela ne fera que continuer à mettre à jour votre dépôt. Si quelqu'un le remarque, dites simplement que vous avez ajouté un nouveau dépôt pour un nouveau programme et que vous en testez différents. Ce n'est pas vraiment comme simuler un script, mais une commande.

NOTE: Je ne tolère pas l'improductivité au travail, mais j'aime bien les expériences. Par conséquent, je recommande que cette application soit utilisée pour être secrètement productive.

Réseau de neurones C ++

MODIFIER

Malheureusement, j'ai optimisé ce code :( je l'ai rendu 2000x plus rapide ... Le code hérité est toujours parfait pour perdre du temps!

Original

J'ai en fait démarré un projet dans les réseaux de neurones convolutionnels, parfait pour cela! Le code source et la documentation sont sur github . La première étape consiste à créer un nouveau réseau.

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>>());

Maintenant que nous avons un réseau de 300 neurones et 1 250 000 synapses, sauvegardons-le dans un fichier pour ne perdre aucun progrès avec le réseau.

neuralNetwork.SaveToFile("test2.cnn");

Cela a généré un fichier texte de 68 Mo et plus de quelques heures de travail détendu. Maintenant, amusons-nous à faire des choses avec! Je vais créer une entrée aléatoire et commencer à la discriminer.

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);

C’était une petite contribution pour une image, mais nous prouvons seulement que le réseau peut faire quelque chose. La prochaine étape consiste à discriminer avec elle!

Layer output = neuralNetwork.Discriminate();

Cela n'a même pas encore fini pour moi et ça dure depuis plus de 2 jours! Ensuite, une fois que nous aurons obtenu cette sortie, répétons-la en sens inverse pour le plaisir.

Layer generatedOutput = neuralNetwork.Generate(output);

Ceci est juste pour prouver que l'API fonctionne, pas encore de plans pour cela. Cette étape n'a pas encore été franchie pour moi et cela fait longtemps que j'attends. Plus de 2 jours brûlés, c'est une estimation approximative de mes tests actuels. C'est assez compliqué, et vous allez travailler dur pendant un jour ou deux, mais après cela, vous ne serez peut-être plus jamais obligé de travailler!

Remarque: si vous ne voulez plus jamais travailler, essayez de former le réseau.

neuralNetwork.LearnCurrentInput();

Je n'ai même pas le temps à perdre pour celui-ci!

Si vous souhaitez afficher toutes les données en cours, ajoutez des appels dans les fonctions uniquement pour afficher ce qui se passe.

Nouveau constructeur

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);
}

Nouveau 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;
}
}

Vous obtiendrez beaucoup de sortie sur votre console maintenant.

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)

Il produit un tas de lignes de faux JS et HTML, avec de faux temps de "chargement" (délais) pour le rendre plus réaliste.

Cela peut et sera grandement développé! (le programme de base est là; je dois juste ajouter plus de contenu maintenant)

Voici un exemple de "page" qu'il génère (il s'agit en fait d'une ancienne version du code; je le mettrai à jour avec le nouveau code lorsque j'aurai terminé):

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>

Node.js + BDD

Ressemble à un flot incessant de tests de type BDD en cours d'exécution. Personne ne peut vous reprocher de lancer des tests!

    "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()

Mise à jour

Je me suis dit que si tous vos tests étaient réussis, cela aurait l'air suspecte. Je l'ai donc mis à jour afin d'inclure certains tests infructueux - complets avec Given-When-Thens.

Et oui, je sais que tous les échecs ont le même message. Vous devez vraiment réparer ce lien de déconnexion!

C # (Windows)

Je vous présente le tout nouveau simulateur Memtest86 2014 ! (Parce qu'exécuter Memtest86 sous Windows est tout à fait logique)

Complet avec barres de progression de travail et indicateur de motif!

Ce code utilise abondamment la classe Console, qui, autant que je sache, n'est disponible que sous Windows. En outre, je ne pouvais pas trouver un moyen d'afficher le nom / la fréquence réelle du processeur et la mémoire disponible, donc ceux-ci sont codés en dur.

Capture d'écran:

MODIFIER

Pour récupérer les informations sur le processeur, vous pouvez utiliser l'espace de noms Microsoft.Win32 et 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");
            }
        }

Code (moche, je sais):

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++;
        }
    }
}

Python, 36 caractères

print("Opening Internet Explorer...")

Python, 21 caractères

print("Opening IE...")

Essayer d'être drôle. : P

AHK

Vous prétendez taper pendant que le script génère un tas d’accesseurs et de mutateurs en JavaScript. Assurez-vous qu'un IDE (j'ai testé cela sur Notepad ++) est la fenêtre active.

Spécifiez la liste des variables et le nom de la classe si vous le souhaitez. Je viens d'utiliser ce qui était déjà dans window.location.

Appuyez sur esc pour sortir.

Appuyez sur 0 sur votre pavé numérique pour faire une pause lorsque quelqu'un essaie de vous parler.

Appuyez sur ctrl + w (w signifie travail) pour commencer

^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

Frapper

Vide un bloc aléatoire de mémoire physique et en examine le contenu. Va être nécessaire pour cela. Seul le premier Mo de mémoire est disponible par défaut. ddla taille de bloc par défaut est de 512 octets, cela peut être changé avec option, ibs=bytesmais gardez à l'esprit l'autre option skip=$offsetqui sélectionne un bloc au hasard. La sortie de ddest envoyée à travers trpour supprimer les caractères non ASCII; seuls les résultats uniques de 2 caractères ou plus sont évalués.

Chaque chaîne trouvée est comparée à un dictionnaire. Si aucune correspondance n'est trouvée, il tente de décoder en base64. Enfin, toutes les chaînes évaluées sont retournées.

Il existe plusieurs autres options dépendant de la plate-forme dont vous devez prendre connaissance, telles que l'emplacement du fichier de dictionnaire (/ usr / share / dict / words), si sleep accepte les entrées à virgule flottante et si base64est disponible.

Sachez également que les ddstatistiques de sortie de l’opération exécutée sur stderr sont acheminées vers / dev / null. Si quelque chose devait mal tourner (vous accédez à / dev / mem ...), la sortie stderr ne sera pas visible.

Globalement, ce n'est pas très utile, mais j'ai appris un peu sur la mémoire Linux et écrire ce script s'est avéré être amusant.

#!/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

Parfois, il n'y a pas de sortie intéressante (tous les zéros). Parfois, il n'y a que quelques chaînes:

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

Parfois, il y a en réalité quelque chose de lisible par l'homme dans la mémoire (avant que je n'enregistre le décalage de bloc):

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

Et un dernier exemple d’exécution montrant une entrée grep malformée, des occurrences du dictionnaire et un décodage en base64 réussi (avant de consigner à nouveau le décalage de bloc):

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

Lot Windows

@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%
)

Ceci est un script de blague que je garde avec moi depuis des années pour le faire ressembler à quelque chose d'un film de pirate informatique des années 90. Je l'utilise généralement lorsque je suis connecté à distance à un ordinateur pour effrayer les gens.

Frapper

La recherche sans fin de cafés.

J'ai trouvé cela sur le web il y a longtemps:

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

Python 2.7

La suite de tests sans fin

"Exécute" un ensemble de "tests unitaires" sur tous les fichiers de votre arborescence. Parcourt tous les sous-répertoires. Recommence à la fin.

Imprime un statut en cours d'exécution:

============================= 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 ===========================

...

Fonctions qui le rendent plus complexe que nécessaire et, espérons-le, plus réaliste:

• Le nombre de tests et la durée du test sont proportionnels à la taille du fichier.
• Transforme les extensions de fichier de code non source en extensions connues. Modifier CodeExtensionspour ajouter plus de types connus.
  • Sélectionne la nouvelle extension en fonction de la fréquence d'affichage des fichiers de langue. Vous ne serez donc pas vu en train de tester le code Python si votre disque dur est plein de Ruby.
• Ignore les fichiers contenant . aucun cadeau comme "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)

Java + Guava 16 (le goyave n'est pas super nécessaire, mais certaines choses sont un peu moins ennuyeuses à écrire).

Bon, tu es supposé travailler? Qu'en est-il d'un programme qui écrit réellement du code Java réel, qui compile réellement (même s'il ne fait pas grand chose).

Il est difficile de démontrer l'animation, mais ce programme écrit un programme Java en utilisant le dictionnaire par défaut (250 mots anglais courants) ou un fichier délimité par une nouvelle ligne (pris comme argument de ligne de commande), et le tape dans la console caractère par caractère. à des vitesses apparemment humaines . Assurez-vous de le faire vous-même, car ce message ne le rend pas justice. Quand il a fini, il attend 1 minute, puis imprime beaucoup de lignes vierges sur la console et recommence. J'ai essayé de l'écrire pour modifier divers paramètres de manière raisonnable.

En outre, normalement, je mettrais cela dans plusieurs fichiers, mais pour faciliter l’exécution, j’ai masqué toutes les classes ensemble.

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;
        }
    }
}