Blagues métiers

Le chauffard qui écrase la poule

C’est l’histoire d’un chauffard qui arrive en trombe dans un village de campagne et pas de chance, une brave dame était en train de traverser la route, il fait un écart de volant pour l’éviter et écrase une poule.

Très embêté, le pov’gars va voir le paysan :
– Je suis désolé, j’ai écrasé une de vos poules, pour éviter cette brave dame. Je vais vous rembourser…
– Alors vous, les bêtises vous les accumulez : vous écrasez ma meilleure pondeuse pour éviter ma belle-mère…

Le style ordurier c’est sordide

Un éditeur dit au jeune écrivain qui lui a soumis sa première œuvre.
– Votre roman est écrit dans un style ordurier qui fait encore ressortir le côté sordide de l’histoire. Je pense qu’il a les meilleurs atouts pour atteindre les cent mille. Cher auteur, voici votre contrat.

L’évolution d’un programmeur

humour, blague programmeur, blague évolution, blague métier, blague langages de programmation, blague programmation, blague informatique, blague technologie, humour programmé

Le but de la manipulation est d’écrire un programme qui affichera « HELLO WORLD » à l’écran.

TERMINALE

10 PRINT « HELLO WORLD »
20 END

DUT 1ERE ANNEE

program HELLO(input, output)
begin
writeln(‘HELLO WORLD’)
end.

DUT 2EME ANNEE

(defun HELLO
(print
(cons ‘HELLO (list ‘WORLD))
)
)

FRAICHEMENT SORTI DE L’ECOLE

    #include <stdio.h>

void main(void)
{
char *message[] = {« HELLO « , « WORLD »};
int i;

       for(i = 0; i < 2; ++i)
  printf("%s", message[i]);
printf("\n");

}

PROFESSIONNEL TRES EXPERIMENTE

    #include <iostream.h>
    #include <string.h>
    class string

{
private:
int size;
char *ptr;
public:
string() : size(0), ptr(new char(‘\0’)) {}
string(const string &s) : size(s.size)
{
ptr = new char[size + 1];
strcpy(ptr, s.ptr);
}
~string()
{
delete [] ptr;
}
friend ostream &operator <<(ostream &, const string &);
string &operator=(const char *);
};
ostream &operator<<(ostream &stream, const string &s)
{
return(stream << s.ptr);
}
string &string::operator=(const char chrs) { if (this != &chrs) { delete [] ptr; size = strlen(chrs); ptr = new char[size + 1]; strcpy(ptr, chrs); } return(this);
}
int main()
{
string str;
str = « HELLO WORLD »;
cout << str << endl;
return(0);
}

PROFESSIONNEL VRAIMENT TRES TRES EXPERIMENTE

[
uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
]
library LHello
{
// bring in the master library
importlib(« actimp.tlb »);
importlib(« actexp.tlb »);

 // bring in my interfaces
 #include "pshlo.idl"

 [
 uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
 ]
 cotype THello

{
interface IHello;
interface IPersistFile;
};
};

[
exe,
uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
]
module CHelloLib
{

 // some code related header files
 importheader();
 importheader();
 importheader();
 importheader("pshlo.h");
 importheader("shlo.hxx");
 importheader("mycls.hxx");

 // needed typelibs
 importlib("actimp.tlb");
 importlib("actexp.tlb");
 importlib("thlo.tlb");

 [
 uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
 aggregatable
 ]
 coclass CHello

{
cotype THello;
};
};

#include « ipfix.hxx »

extern HANDLE hEvent;

class CHello : public CHelloBase
{
public:
IPFIX(CLSID_CHello);

 CHello(IUnknown *pUnk);
 ~CHello();

 HRESULT  __stdcall PrintSz(LPWSTR pwszString);

private:
static int cObjRef;
};

#include
#include
#include
#include
#include « thlo.h »
#include « pshlo.h »
#include « shlo.hxx »
#include « mycls.hxx »

int CHello::cObjRef = 0;

CHello::CHello(IUnknown *pUnk) : CHelloBase(pUnk)
{
cObjRef++;
return;
}

HRESULT __stdcall CHello::PrintSz(LPWSTR pwszString)
{
printf(« %ws\n », pwszString);
return(ResultFromScode(S_OK));
}

CHello::~CHello(void)
{

// when the object count goes to zero, stop the server
cObjRef–;
if( cObjRef == 0 )
PulseEvent(hEvent);

return;
}

#include
#include
#include « pshlo.h »
#include « shlo.hxx »
#include « mycls.hxx »

HANDLE hEvent;

int _cdecl main(
int argc,
char * argv[]
) {
ULONG ulRef;
DWORD dwRegistration;
CHelloCF *pCF = new CHelloCF();

hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

// Initialize the OLE libraries
CoInitializeEx(NULL, COINIT_MULTITHREADED);

CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
REGCLS_MULTIPLEUSE, &dwRegistration);

// wait on an event to stop
WaitForSingleObject(hEvent, INFINITE);

// revoke and release the class object
CoRevokeClassObject(dwRegistration);
ulRef = pCF->Release();

// Tell OLE we are going away.
CoUninitialize();

return(0); }

extern CLSID CLSID_CHello;
extern UUID LIBID_CHelloLib;

CLSID CLSID_CHello = { /* 2573F891-CFEE-101A-9A9F-00AA00342820 */
0x2573F891,
0xCFEE,
0x101A,
{ 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
};

UUID LIBID_CHelloLib = { /* 2573F890-CFEE-101A-9A9F-00AA00342820 */
0x2573F890,
0xCFEE,
0x101A,
{ 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
};

#include
#include
#include
#include
#include
#include « pshlo.h »
#include « shlo.hxx »
#include « clsid.h »

int _cdecl main(
int argc,
char * argv[]
) {
HRESULT hRslt;
IHello *pHello;
ULONG ulCnt;
IMoniker * pmk;
WCHAR wcsT[_MAX_PATH];
WCHAR wcsPath[2 * _MAX_PATH];

// get object path
wcsPath[0] = ‘\0’;
wcsT[0] = ‘\0’;
if( argc > 1) {
mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
wcsupr(wcsPath);
}
else {
fprintf(stderr, « Object path must be specified\n »);
return(1);
}

// get print string
if(argc > 2)
mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
else
wcscpy(wcsT, L »Hello World »);

printf(« Linking to object %ws\n », wcsPath);
printf(« Text String %ws\n », wcsT);

// Initialize the OLE libraries
hRslt = CoInitializeEx(NULL, COINIT_MULTITHREADED);

if(SUCCEEDED(hRslt)) {

 hRslt = CreateFileMoniker(wcsPath, &pmk);
 if(SUCCEEDED(hRslt))

hRslt = BindMoniker(pmk, 0, IID_IHello, (void **)&pHello);

 if(SUCCEEDED(hRslt)) {

// print a string out
pHello->PrintSz(wcsT);

Sleep(2000);
ulCnt = pHello->Release();
}
else
printf(« Failure to connect, status: %lx », hRslt);

 // Tell OLE we are going away.
 CoUninitialize();
 }

return(0);
}

ADMINISTRATEUR SYSTEME

    #include <stdio.h>
    main()
    {
      char *tmp;
      int i=0;
      /* on y va bourin */
      tmp=(char *)malloc(1024*sizeof(char));
      while (tmp[i]="HELLO WORLD"[i++]);
      /* Ooopps y'a une infusion ! */
      i=(int)tmp[8];
      tmp[8]=tmp[9];
      tmp[9]=(char)i;
      printf("%s\n",tmp);
    }

APPRENTI HACKER

     #!/usr/local/bin/perl
     $msg="HELLO, WORLD.\n";
     if ($#ARGV >= 0) {
       while(defined($arg=shift(@ARGV))) {
         $outfilename = $arg;
         open(FILE, ">" . $outfilename) || die "Can't write $arg: $!\n";
         print (FILE $msg);
         close(FILE) || die "Can't close $arg: $!\n";

       }
     } else {
       print ($msg);
     }
     1;

HACKER EXPERIMENTE

     #include <stdio.h>
     #define S "HELLO, WORLD\n"
     main(){exit(printf(S) == strlen(S) ? 0 : 1);}

HACKER TRES EXPERIMENTE

     % cc -o a.out ~/src/misc/bv/bv.c
     % a.out

GOUROU DES HACKERS

     % cat
     HELLO, WORLD.
     ^D

DIRECTEUR JUNIOR

     10 PRINT "HELLO WORLD"
     20 END

DIRECTEUR

     mail -s "HELLO, WORLD." bob@b12
     Henri, pourrais-tu m'écrire un programme qui écrit "HELLO,
     WORLD." À l'écran?
     J'en ai besoin pour demain.
     ^D

DIRECTEUR SENIOR

     % zmail Jean
     J'ai besoin d'un programme "HELLO, WORLD." Pour cette après-midi.

PRESIDENT DIRECTEUR GENERAL

     % letter
     letter: Command not found.
     % mail
     To: ^X ^F ^C
     % help mail
     help: Command not found.
     % damn!
     !: Event unrecognized
     % logout

La programmation en C++ chez les industriels

La programmation en C++ chez les industriels, c’est comme le sexe chez les adolescents :

  • Tout le monde y pense
  • Tout le monde en parle
  • Tout le monde croit que le voisin le fait
  • Presque personne le fait
  • Ceux qui le font le font mal
  • Pensent que la prochaine fois ce sera mieux
  • Ne prennent pas de précautions.
  • N’osent pas avouer leurs lacunes de peur de paraître niais.
  • Sont fort bruyants quand ils y arrivent.

Le physicien théoricien et la stabilité d’une chaise

Si on demande à un physicien théoricien d’étudier la stabilité d’une chaise, il s’y prend comme suit :
– Il met 10 minutes pour résoudre le cas d’une chaise à un pied,
– Ensuite 1 heure pour résoudre le cas d’une chaise à une infinité de pieds,
– Et enfin 10 ans pour résoudre le cas d’une chaise à un nombre fini de pieds.