Faça parecer que estou trabalhando


278

Muitas vezes, vejo-me executando um script ou consulta que levará uma quantidade significativa de tempo para ser executado. Posso deixar esse script aberto e desfrutar de uma procrastinação sem culpa.

Agora, e se eu pudesse escrever um script que parece ser um dos scripts acima para qualquer espectador, mas apenas na aparência? Eu poderia colocá-lo na tela e desfrutar de dias de transmissão ao vivo de gatinhos antes que alguém percebesse que toda a complicada rigmarole na tela não tinha nada a ver com o meu trabalho real.

Seu desafio é escrever esse script para mim (sim, sou tão preguiçoso).

Uma boa resposta será:

  • Faça aparecer algo na tela que parece que um script está funcionando. "Tela" pode ser terminal, navegador, etc.
  • Seja bastante original (sim, todos nós vimos os intermináveis ​​programas de barra de progresso)
  • Sobreviver a exame superficial por uma pessoa técnica

Uma resposta ruim será:

  • Me demitir
  • Refazer algo que todos fomos encaminhados nos anos 90

Uma resposta estelar pode:

  • Transcenda um dos pontos de marcador incorretos acima ( por exemplo )
  • Sobreviver ao exame crítico
  • * suspiro * realmente faz algo que é útil ou ajuda no meu trabalho

A aceitação será baseada em votos, com bônus dos resultados da vida real. Na verdade, executarei esses scripts (Linux Mint 16) no trabalho quando minha tela estiver visível (reuniões e similares) para determinar a detecção. Se alguém perceber que está fingindo, você estará fora da corrida. Se alguém comentar o quanto estou trabalhando, +5 de bônus para você.

"Útil", neste caso, pode ser aplicado a qualquer codificador, mas se você procura um brilho extra na maçã ligada ao professor, sou um webdev de pilha completa que trabalha no código de acordo com minhas tags .

Pergunta parcialmente inspirada por isso .

Resultados

Infelizmente, não recebi nenhum comentário sobre essas entradas. Eles são todos incríveis, então vocês são todos vencedores no meu coração. No entanto, Loktar tem o maior número de votos por um tiro longo, então ele recebe os +15 do aceite. Parabéns!


6
Qual é o critério de vencimento, concurso de popularidade ?
precisa

36
Então ... o que acontece se você testar uma resposta e ela realmente for demitida?
Bob

54
Isso me dá uma idéia para outra pergunta sobre código de golfe. "Faça parecer que a minha pergunta não deve ser colocado em espera"
Twiz

9
Basta escrever um desses programas e compilar !
Ugoren

13
Eu vi um bom remake de sala de reuniões Tron Legacy no Github no outro dia: github.com/arscan/encom-boardroom
Paul Prestidge

Respostas:


291

Javascript

Então eu fiquei um pouco louco com isso. Fiz isso entre intervalos de trabalho na minha GUI para rastrear IPs usando o Visual Basic.

Você pode acessá-lo acessando o domínio super sério que eu criei hoje à noite, para que você possa ficar ocupado em qualquer lugar do Gui Hacker e bifurcar e criar o seu a partir das seguintes fontes

Basicamente, se você tem essa corrida, ninguém o incomodará porque eles sabem que você está fazendo coisas sérias.

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
Os caras da pintura / manutenção perceberam que eu sou um programador e não apenas um cara ouvindo música !! Gostaria de saber se isso iria sobreviver algum exame por uma tecnologia cara: P
sabithpocker

17
Quero-o como meu novo protetor de tela !! De fato, como você faria isso no ubuntu?

33
Sentei-me na Biblioteca Pública de Toronto com isso aberto e notei pessoas atrás de mim olhando para a minha tela. Isso parece bastante "assustador" para um cara não-técnico. Você pode fazer com que o guihacker.com nos permita alterar o título da página para o que quisermos, e se pudermos adicionar nossas próprias linhas que aparecerão no texto verde? Eu estava pensando em criar o título da página 'Acesso à Internet da Biblioteca Pública de Toronto' e digitar as linhas verdes 'Acessando o banco de dados de segurança da biblioteca pública de Toronto ..' 'Acessando nomes de usuário e senhas ...' 'Acesso concedido ..' me coloque em problemas, mas será divertido.
precisa saber é o seguinte

37
Tive isso funcionando por 30 segundos antes de meus colegas desenvolvedores virem perguntar o que eu estava invadindo. Eu acho que isso conta como um sucesso, então +1
MrTheWalrus

10
"Relatórios TPS" ... brilhante.
Dennis

111

Bash / coreutils

Apresentando o primeiro emulador de compilação de todos os tempos . Com este programa, você pode ter batalhas épicas de cadeira de escritório sempre que quiser, sem precisar escrever nenhum código!

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

Ele usa dados de /usr/includepara criar um log de compilação com aparência realista. Eu estava com preguiça de lançar avisos aleatórios, então há apenas uma -wbandeira.

Amostra aleatória:

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 -msse4_1 -msse4_2 -share compartilhado libiptc / ipt_kernel_headers.o libiptc / libip6tc.o libiptc / libiptc.o libiptc / libxtc.o libiptc / xtcshared.o -o libiptc. tão
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-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 / dispositivo-usb-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 / scaledfont.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 / 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 / quartz_font
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.0 / cairomm / win32_font
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 / refptr.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 / cairomm.c -o cairomm-1.0 / cairomm / cairomm.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 / 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 / cairomm / win32
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 / quartz
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 / x
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 / fontoptions.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 / 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-1.0 / cairomm / context.o cairomm /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 / caminho.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
Nada mal! Algo não parece certo sobre isso (será que o HD fica completamente quieto?), Mas para o espectador desconhecido, é muito improvável que se levante suspeitas. Embora ... o que, está compilando libdrm? And sys/wait.o?? What the ...
deixou de girar no sentido anti-horáriowis

27
@leftaroundabout Diga que você tem um SSD.
Mniip

36
Para torná-lo mais autêntico, você deve emitir avisos falsos do compilador várias vezes por linha gcc. :)
monocell

3
Você provavelmente poderia usar o pkg-config para criar flags gcc falsas mais realistas.
Brendan Long

3
@WChargin que não ativaria o HD.
Thorbjørn Ravn Andersen

106

Bater

Exibe infinitamente valores hexadecimais aleatórios, com alguns deles destacados para parecer que você está executando uma pesquisa complicada em dados brutos.

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, eu gosto deste!
precisa saber é o seguinte

4
(Urso comigo, novo para bash), mas ao executar esta linha, (Mac OSX, terminal) eu recebo esta saída em um loop:od: illegal option -- w usage: od [-aBbcDdeFfHhIiLlOosvXx] [-A base] [-j skip] [-N length] [-t type] [[+]offset[.][Bb]] [file ...]
Sterling Archer

2
Parece que sua versão do odnão suporta a -wopção. Você pode soltar essa opção, está aqui apenas para mostrar mais colunas de dados, para preencher a tela um pouco mais.
Barjak

8
Pessoalmente, prefiro isso com sleep 0.5alterado para sleep.$[$RANDOM % 10]. Isso o torna um pouco mais instável e mais como uma pesquisa real. Eu gosto disso!
Undergroundmonorail

4
Lembra-me da busca sem fim por "ca fe":cat /dev/random | hexdump | grep "ca fe"
daviewales

102

Uma compilação muito longa:

emerge openoffice

48
; _;
mniip

3
Mais tempo que o cromo?
precisa saber é o seguinte

6
O problema ao compilar um projeto real é que ele irá parar se ocorrer um erro. Provavelmente devemos colocar isso em um loop infinito.
Akira Yamamoto

3
Nós surgimos no Linux Mint?
Akira Yamamoto

3
Em sistemas .deb como Ubuntu e Mint, você quer sudo apt-get build-dep libreoffice; apt-get source libreoffice; cd libreoffice*; while :; do nice dpkg-buildpackage -rfakeroot; done(Você terá que tomar conta que em sua primeira corrida, pelo menos até que a compilação verdadeira começa execuções subseqüentes só precisa do. whileLoop.)
Adam Katz

55

Rubi

Este irá:

  1. Obtenha um código aleatório neste site. revisão de código (para código mais legível e bem escrito)
  2. Faça parecer que você está digitando esse código.
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

Aqui está este script baseado em um código extraído daqui :

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

Aqui está como fica: Code


11
E se o código obtido for em Brainf ** k, Golfscript ou J. Isso levantará alguma suspeita.
user80551

39
Finalmente minhas respostas cuidadosamente colocadas que agregam backdoors todo pagar
PlasmaHH

1
Talvez stackoverflow seria melhor?
PyRulez

3
A velocidade de digitação de cada uma parecerá mais realista se eu aleatoriamente a velocidade (e a tornar mais rápida) alterando a sleeplinha para sleep rand(10).to_f / 30.
Rory O'Kane

3
Eu acho que usar o código Code Review no Code Golf é perfeito. Eu sempre pensei do Código Golf como o gêmeo do mal do Código Review, e eu te amo tanto ...
Trichoplax

52

Vamos usar um script bash simples que faz com que você pareça hacker, imprimindo o conteúdo de cada arquivo identificado como texto em / var / log / linha por linha, com atrasos aleatórios para parecer que coisas intensas estão acontecendo. Dependendo dos arquivos encontrados, pode fornecer uma saída bastante 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

Verifique se o tema do seu terminal parece hacker. Aqui estão alguns exemplos durões (não faço ideia do que isso significa, mas parece hacker):

image image


3
Bem feito. Exemplo de captura de tela é excelente
SomeKittens

37
Você está ciente de que suas chaves privadas estão nessas capturas de tela?
Hubert OG

27
Haha, peguei! ;-)
Hubert OG

4
(Mas, falando sério, eu não li essas screenshots então eu não sei o que está realmente lá.)
Hubert OG

3
@HubertOG Uau, você quase me deu um ataque cardíaco ...; PI não ver que em qualquer lugar, então eu pensei que eu estava ficando louco: O
Jwosty

49

Bash: O commit infinito do git

Um problema com os computadores hoje em dia é que eles são bastante rápidos, portanto, mesmo as tarefas de compilação acabam. Além disso, dado um script que é executado por um longo tempo, você pode argumentar que é realmente possível continuar trabalhando em outra coisa enquanto o script é executado.

Para resolver isso, temos o seguinte programa. Apenas aprenda a digitar 'y' ou 'n' aleatoriamente de vez em quando.

É claro que você precisa de um repositório Git com algum conteúdo novo, mas supondo que ocasionalmente faça um trabalho real que não deve ser um problema.

#!/bin/bash

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

12
Sinto-me gravemente perturbado com esta entrada do CG ... É +1 ou -1, mas ainda não sei qual!
precisa saber é o seguinte

37

Bater

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

Isso continuará atualizando seus repositórios. Se alguém perceber, basta dizer que você adicionou um novo repositório para um novo programa e está testando diferentes. Não é como fingir um script, mas um comando.

NOTA: Não tolero ser improdutivo no trabalho, mas gosto de experimentos. Portanto, eu recomendo que este aplicativo seja usado para ser secretamente produtivo.


5
Bom, mas cuidado com essa função recursiva.
Digital Trauma

1
parece bomba de garfo !!
precisa

2
@ AvinashR Não é bem assim, sem garfo.
precisa saber é o seguinte

43
Hosts espelho odeiam você agora.
Caleb

9
"Não exatamente, sem garfo." Então você diz, apenas bomba? :-)
celtschk 15/06

28

Rede Neural C ++

EDITAR

Infelizmente, eu otimizei esse código :( o tornei 2000x mais rápido ... O código legado ainda é perfeito para perder tempo!

Original

Na verdade, eu comecei um projeto em redes neurais convolucionais perfeitas para isso! O código fonte e a documentação estão no github . O primeiro passo é criar uma nova rede.

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

Agora que temos uma rede com 300 neurônios e 1.250.000 sinapses, vamos salvá-la em um arquivo para garantir que não perdemos nenhum progresso que fazemos com a rede.

neuralNetwork.SaveToFile("test2.cnn");

Isso gerou um arquivo de texto de 68 MB e mais de algumas horas de trabalho descontraído. Agora, vamos nos divertir fazendo coisas com isso! Vou criar uma entrada aleatória e começar a discriminá-la.

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

Essa foi uma pequena entrada para uma imagem, mas estamos apenas provando que a rede pode fazer algo. O próximo passo é discriminar com isso!

Layer output = neuralNetwork.Discriminate();

Isso ainda nem terminou para mim e está em execução há mais de 2 dias! Então, quando obtivermos essa saída, vamos analisá-la novamente ao contrário, apenas por diversão.

Layer generatedOutput = neuralNetwork.Generate(output);

Tudo isso é apenas para provar que a API funciona, ainda não há planos para isso. Esta etapa ainda não foi executada para mim e estou esperando há um tempo. Foram queimados mais de 2 dias bons, e essa é uma estimativa aproximada dos meus testes atuais. Isso é bastante complicado, e você trabalhará duro por um dia ou dois, mas depois disso você poderá nunca mais precisar trabalhar!

Nota: Se você nunca mais quiser trabalhar novamente, tente treinar a rede

neuralNetwork.LearnCurrentInput();

Eu nem tenho tempo a perder para este!

Se você deseja exibir todos os dados que estão acontecendo, adicione algumas chamadas nas funções apenas para exibir o que está acontecendo

Novo construtor

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

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

Você terá bastante saída no seu console agora.


4
+1 para o contexto da vida real também. Interessante :) #
George George

1
Hahahaha as iniciais soletram "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)

Ele gera várias linhas de JS e HTML falsos, com tempos de "carregamento" falsos (atrasos) para torná-lo mais realista.

Isso pode e será expandido grandemente! (o programa básico está lá; só preciso adicionar mais conteúdo agora)


Aqui está um exemplo de "página" que ele gera (na verdade, é de uma versão antiga do código; atualizo-o com o novo código quando terminar):

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
Incrível, mal posso esperar para ver o que você adiciona a ele!
precisa saber é o seguinte

heh sim, este aqui é bonito. Minha mente está
cheia de

Não apenas python3, 2,7 é ok também
Hannes Karppila

1
Bom trabalho. Parece bem realista.
QWR

24

Node.js + BDD

Parece um fluxo interminável de testes no estilo BDD em execução. Ninguém pode culpar você por executar testes!

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

Atualizar

Ocorreu-me que pareceria suspeito se todos os seus testes passassem, portanto, eu o atualizei para incluir alguns testes com falha - completos com os dados de quando.

E sim, eu sei que todas as falhas têm a mesma mensagem. Você realmente precisa corrigir o link de logout!

insira a descrição da imagem aqui


2
Muito esperto, recebo pontos de bônus por garantir que meu código seja testado! Não é possível ter muito cuidado
SomeKittens

23

C # (Windows)

Apresento a vocês o novíssimo Memtest86 Simulator 2014 ! (Porque executar o Memtest86 no Windows faz todo sentido)

Completo com barras de progresso de trabalho e indicador de padrão!

Esse código usa extensivamente a classe Console, que, até onde eu sei, só está disponível no Windows. Além disso, não consegui encontrar uma maneira de mostrar o nome / frequência do processador real e a memória disponível, portanto esses são codificados.

Captura de tela: insira a descrição da imagem aqui

EDITAR

Para recuperar as informações do processador, você pode usar o namespace Microsoft.Win32 e a 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");
            }
        }

Código (feio, eu sei):

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
Por que não apenas executar o Memtest86? "Eu acho que tenho alguns problemas de hardware aqui, acho que vou precisar me divertir até terminar"
MadTux

20
@ MadTux Porque você precisa inicializar no Memtest, o que significa que não há fotos de gatos.
Schilcote

1
System.Console Funciona em Mono, eu acho que você só tem que ajustar o código para tamanho arbitrário janela do console
NothingsImpossible

8
Não foi possível executar o Memtest86 em uma VM?
Cole Johnson

3
Eu amo o Memtest em uma idéia de VM.
John


14

AHK

Você finge digitar enquanto o script gera vários acessadores e mutadores em JavaScript. Verifique se um IDE (testei no Notepad ++) é a janela ativa.

Especifique a lista de variáveis ​​e o nome da classe, se desejar. Eu apenas usei o que já estava em window.location.

Pressione esc para sair.

Pressione 0 no teclado numérico para pausar quando alguém tentar falar com você.

Pressione ctrl + w (w significa trabalho) para iniciar

^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

Bater

Despeja um bloco aleatório de memória física e examina o conteúdo. Vai precisar ser raiz para isso. Somente o primeiro 1 MB de memória está disponível por padrão. ddo tamanho padrão do bloco é 512 bytes, que pode ser alterado com a opção, ibs=bytesmas lembre-se da outra opção skip=$offsetque seleciona um bloco aleatoriamente. A saída de ddé enviada atravéstr para remover caracteres não ASCII; apenas resultados exclusivos com 2 caracteres ou mais são avaliados.

Cada string encontrada é comparada a um dicionário. Se nenhuma correspondência for encontrada, ele tentará decodificar como base64. Finalmente, todas as seqüências avaliadas são retornadas.

Existem várias outras opções dependentes da plataforma, como o local do arquivo do dicionário (/ usr / share / dict / words), se o sleep aceita entradas de ponto flutuante e se base64está disponível.

Além disso, esteja ciente de que ddgera estatísticas na operação executada no stderr, que é canalizada para / dev / null. Se algo der errado (você está acessando / dev / mem ...), a saída stderr não será visível.

No geral, não é muito útil, mas eu aprendi um pouco sobre memória linux e escrever esse script acabou sendo divertido.

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

Às vezes, não há saída interessante (todos os zeros). Às vezes, existem apenas algumas seqüências de caracteres:

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

Às vezes, há realmente algo legível por humanos na memória (antes de eu registrar o deslocamento do bloco):

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 uma última amostra de execução mostrando entrada grep malformada, ocorrências no dicionário e uma decodificação base64 bem-sucedida (antes de registrar novamente o deslocamento do bloco):

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

Como você executa isso? Eu joguei script.sh, joguei chmod +x, mas ele simplesmente sai. sudotambém não ajuda.
Octavia Togami

Parece que a mem=linha não está retornando nada. Você precisará verificar e certificar-se de que cada parte do comando entre tubulações esteja realmente retornando algo.

Ok, eu vou fazer isso.
Octavia Togami

Isso só funcionou por 5 segundos na primeira vez e impresso como 12 linhas, depois como 0,1 segundos a cada vez subseqüente sem saída.
Mike

13

Lote do 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%
)

Este é um script de piada que eu guardo comigo há anos para fazer parecer algo extraído de um filme de hackers dos anos 90. Eu costumo usá-lo enquanto conectado remotamente a um computador para assustar as pessoas.


2
Ele está baixando um vírus para todo o sistema!
QWR

12

Bater

A busca interminável por cafés.

Encontrei isso na web há muito tempo:

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

Tente usar o urandom.
Alice Ryhl

Ah ... Eu testei-o em um Mac, e Macs têm tanto randome urandom.
daviewales

5
/dev/randomexiste, mas pretende ser mais seguro do que /dev/urandomgerar números apenas se houver entropia disponível. Depois que você acabar, ele para. /dev/urandomnão faz isso e nem sempre para de produzir.
Undergroundmonorail

Por que isso nunca acaba? Eu me sinto idiota, pela segunda vez hoje.
Daniel W.

1
/dev/urandomé um 'arquivo' que alimenta continuamente números aleatórios cat. catentão os canaliza para hexdump, etc.
daviewales

11

Python 2.7

O Endless Test Suite

"Executa" um conjunto de "Testes de Unidade" em todos os arquivos em sua árvore de diretórios. Atravessa todos os subdiretórios. Começa quando chega ao fim.

Imprime um status de execução:

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

...

Recursos que o tornam mais complexo do que o necessário e, esperançosamente, mais realista:

  • O número de testes e o tempo de teste são proporcionais ao tamanho do arquivo.
  • Transforma extensões de arquivo sem código fonte em extensões conhecidas. ModificarCodeExtensions para adicionar tipos mais conhecidos.
    • Seleciona uma nova extensão com base na frequência dos arquivos de idioma reais vistos, para que você não seja visto testando o código Python se o seu disco rígido estiver cheio de Ruby.
  • Ignora arquivos com os principais . brindes, como "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
Você também pode executar os testes de regressão Python, que são incluídos na maioria das instalações do Python.
N11:

Mas esses acabam eventualmente.
AShelly

2
então você pode executá-los ... em um loop!
nneonneo

1
Também acho que é menos suspeito testar arquivos com nomes relacionados aos seus projetos do que testar a fonte do Python. Eu estou supondo que a maioria de nós não manter profissionalmente Python ...
AShelly

11

Java + Guava 16 (a goiaba não é super necessária, mas tornou algumas coisas um pouco menos chatas de se escrever).

Tudo bem, você deveria estar trabalhando? Que tal um programa que realmente escreve código Java real, que realmente compila (embora não faça muito).

É difícil demonstrar a animação, mas este programa grava um programa Java usando o dicionário padrão (250 palavras comuns em inglês) ou um arquivo delimitado por nova linha (usado como argumento de linha de comando) e digita-o no console, um caractere de cada vez. em velocidades aparentemente humanas . Certifique-se de executá-lo você mesmo, porque este post não faz justiça. Quando termina, aguarda 1 minuto, depois imprime muitas linhas em branco no console e inicia novamente. Tentei escrevê-lo para tornar vários parâmetros razoavelmente ajustáveis.

Além disso, normalmente eu colocaria isso em mais de um arquivo, mas para facilitar a execução, misturei todas as classes.

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

Exemplo de saída do programa (apenas um programa)

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

Outra saída de amostra:

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
Você criou uma máquina de impressão de dinheiro totalmente automática para quem ainda é pago por linhas de código - ótimo trabalho!
Philipp

9

bater

Envie alguns comentários de arquivos de origem aleatórios em intervalos aleatórios, seguidos por uma barra de progresso do-nothing gerada aleatoriamente.

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

Resultado:

# /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
Esperto! É um pouco tarde para receber mais atenção, mas tire um máximo de mim.
SomeKittens

@SomeKittens O verdadeiro gênio desse script é que trabalhar nele parece ainda mais um trabalho real. ; D
Sammitch

7

Rsync form BASH

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

rsync - uma ferramenta rápida, versátil, de cópia de arquivos remota (e local) ... que com -n executa uma execução a seco , apenas tenta fazer, realmente não faz e mostra o que acontece.
Nesse caso, tente verificar se deseja atualizar todos os arquivos do seu diretório pessoal (e subpastas ).
Se você possui o acesso root, é claro, pode executá-lo em uma parte maior do seu sistema de arquivos.

Notas:

  1. Se, HISTCONTROL=ignorebothou pelo menos HISTCONTROL=ignorespacena sua sessão do bash, seu histórico do bash não se lembrará desse comando se você o escrever com um espaço antes. (Você não pode visualizá-lo na tela nem no registro do histórico ).
  2. | sed s/"(DRY RUN)"/""/gcanalizará a saída sedque apagará o (DRY RUN)texto no final da saída do rsync. Se um especialista verificar, você pode dizer que realmente está fazendo isso, não apenas testando.
  3. -avrIcvocê pode alterar essas opções, verificar man rsync, mas nunca remover a-n , caso contrário, você deve ter um problema sério, ainda mais se executar como root ... 8-O!

6

Maven sob bash

Maven é perfeito para esse tipo de tarefa ;-)

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

6

Cobra

Isso abre uma janela do console que percorre vários objetos falsos e itens variados, aumentando as passagens e o progresso de cada passagem. Espera um pequeno tempo aleatório a cada incremento, para simular os atrasos reais da computação.

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
Você tem o fim de semana inteiro para trabalhar nisso, então não se apresse.
precisa saber é o seguinte

1
O que é este idioma Cobra, parece que o filho bastardo de Python e C #, haha (olhando-o que parece ter algumas características interessantes embora), +1
Thomas

1
@ Thomas Na maioria das vezes, é C # (atualmente sem LINQ) usando a sintaxe do Python. E um dos compiladores padrão mais úteis que já tive o prazer de trabalhar.
Οurous

Então, você acabou de completar esse código?
rayryeng

4

Eu escrevi um script python estúpido para fazer isso uma vez. Chamado "ProgramAboutNothing" ... Não sei se é tão convincente, mas demorei apenas 10 minutos. Ele apenas gera frases aleatórias descrevendo o que está supostamente fazendo ... Eu provavelmente poderia ter escolhido palavras melhores para isso, que podem parecer mais convincentes, mas eu nunca as usei corretamente. Acho que se alguém quiser usá-lo, pode editá-lo e adicionar suas próprias palavras nas listas ... Os fãs de Sim City podem notar algo familiar. : 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
Talvez você esteja usando Python 3? Tente adicionar parênteses em torno das declarações de impressão como este: print( ... ).
daviewales

1
@daviewales ninja'd: P
Luke

1
@ Lucas Acabei de instalar o Python 3.4.1Windows. Eu não posso programar em Python, mas eu estou interessado em seu programa pouco ...
Mathlight

1
@ Mathlight prepare-se para ficar desapontado. : P
Luke

1
@luke, está funcionando agora. E eu estou impressionado ^ _ ^
Mathlight

4

Que tal este? Ele fará o download dos dados HTML do codegolf a cada 1 segundo. Portanto, os dados continuarão mudando enquanto as perguntas mais recentes surgirem. Ao mesmo tempo, também parecerá que você está baixando alguns dados críticos de um site.

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

3

Bater

A lista de diretórios recursivos:

ll -R /

2

Esta é uma simulação do compilador C ++ (escrita em 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

Lote

Coloque em uma pasta com muitos arquivos. Se rolar rápido o suficiente, ninguém suspeitará de nada.

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

2
emerge @world

recompilar completamente no gentoo


Tenho certeza de que a disponibilidade dessa desculpa primo é o principal motivo para executar o Gentoo.
Caleb
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.