Voici un résumé des techniques de programmation :

But : écrire un programme qui affichera "HELLO WORLD" à l'écran!

Question subsidiaire: auquel de ces niveaux vous situez-vous?


Ecrire un programme qui affichera "HELLO WORLD" à l'écran.


----------------------------------------------------------------
     Terminale
       10 PRINT "HELLO WORLD"
        20 END

----------------------------------------------------------------
     DUT 1ère année
        program HELLO(input, output)
          begin
            writeln('HELLO WORLD')
          end.

----------------------------------------------------------------
     DUT 2ème année
        (defun HELLO
          (print
            (cons 'HELLO (list 'WORLD))
           )
          )

----------------------------------------------------------------
     Fraîchement sorti de l'école
        #include
        void main(void)
        {
          char *message[] = {"HELLO ", "WORLD"};
          int i;
                for(i = 0; i < 2; ++i)
            printf("%s", message[i]);
          printf("\n");
        }

----------------------------------------------------------------
     Professionnel très expérimenté
        #include
        #include
        class string
        {
        private:
           int size;
               char *ptr;
        public:
           string() : size(0), ptr(new char('')) {}
           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 très très expérimenté
       [
       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 "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 "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 "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] = '';
         wcsT[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 Système
       #include
       main()
       {
         char *tmp;
         int i=0;
         /* on y va bourin */
         tmp=(char *)malloc(1024*sizeof(char));
         while (tmp[i]="HELLO WOLRD"[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 expérimenté
       #include
       #define S "HELLO, WORLD\n"
       main(){exit(printf(S) == strlen(S) ? 0 : 1);}

----------------------------------------------------------------
     Hacker très expérimenté
       % 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.

----------------------------------------------------------------
     Président Directeur Général
       % letter
       letter: Command not found.
       % mail
       To: ^X ^F ^C
       % help mail
       help: Command not found.
       % bordel!
       !: Event unrecognized
       % logout