C++Guns – RoboBlog blogging the bot

test.cpp

#include < stdlib.h >

// fortran can only call C routines
extern "C" {
  // we need the address of the fortran pointer thus a pointer of a pointer.
  void myC_func(int **arr) {   
    // we cannot use new() here because fortran deallocate() use free() instead of delete[]
    *arr = (int*) malloc(12*sizeof(int));
    for(int i=0; i < 12; i++) {
      (*arr)[i] = i;
    }
  }
}

test.F90

! https://gcc.gnu.org/onlinedocs/gcc-4.6.2/gfortran/Working-with-Pointers.html

program main
  use iso_c_binding
  implicit none
  
  interface
    subroutine my_routine(arr) bind(c,name='myC_func')
      import :: c_ptr
      ! If a pointer is a dummy-argument of an interoperable procedure, 
      ! it usually has to be declared using the VALUE attribute. 
      ! void* matches TYPE(C_PTR), VALUE, while TYPE(C_PTR) alone matches void**. 
      type(c_ptr), intent(out) :: arr
    end subroutine
  end interface
  
  type(c_ptr) :: cptr
  integer,pointer :: fptr(:)
  
  ! allocate and fill cptr
  call my_routine(cptr)
  ! convert it to fortran pointer
  call c_f_pointer(cptr, fptr, [12])
  
  if(associated(fptr)) write(*,*) "associated"
  write(*,*) fptr
  deallocate(fptr)
  
end program main

g++ -Wall -Wextra -c test.cpp 
gfortran -Wall -Wextra -fcheck=all test.F90 test.o

valgrind ./a.out 
==5256== Memcheck, a memory error detector
==5256== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==5256== Using Valgrind-3.9.0 and LibVEX; rerun with -h for copyright info
==5256== Command: ./a.out
==5256== 
 associated
           0           1           2           3           4           5           6           7           8           9          10          11
==5256== 
==5256== HEAP SUMMARY:
==5256==     in use at exit: 0 bytes in 0 blocks
==5256==   total heap usage: 22 allocs, 22 frees, 11,874 bytes allocated
==5256== 
==5256== All heap blocks were freed -- no leaks are possible
==5256== 
==5256== For counts of detected and suppressed errors, rerun with: -v
==5256== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)

Leute, ist sag es schon die ganze Zeit: Fortran ist eine tote Sprache.
Und damit meine ich nicht nur diese verbuggten Compiler. Oder dass es ewig braucht bis man ein neues Feature vom Compiler unterstützt wird. Im Fortran 2003 Standard sind zwar schön viele OO Ansatze festgelegt, aber ich kenne kein Compiler der den Standard nach 10 Jahre komplett unterstützt. Andere Sprachen sind schon 2 Schritte weiter.

Nein, diesmal habe ich viel bessere Argumente auf Lager. In dem Paper [1] wurden 800000 Software Projekte und 13000 Programmierer ausgewertet. Ich möchte nur zu einem Bild aus diesem Paper meine Meinung loswerden. Dieses da:

Also, man sieht hier die Wahrscheinlichkeit, mit der man die Programmiersprache wechselt, wenn ein neues Projekt angefangen wird. Weis bis blau sind niedrige Wahrscheinlichkeiten und rot bis schwarz hohe.
Die Punkte auf der Diagonalen zeigen, dass man die Sprache NICHT wechselt.
Was haben wir denn da alles:
Rote Punkte sehe ich bei allesn *Basic Sprachen. Auch bei der C-Familie mit Java, Perl, PHP, Python bleiben die Programmierer bei ihrer Sprache.

Welche Sprachen bekommen Zuwachs? Das sieht man schön an den vertikalen Balken. Also Java, C/C++ und meinetwegen noch PHP. Das sind also die view Großen wohin die Programmierer wechseln, nachdem sie erkannten, dass ihre vorherige Wahl Schrott war. Tja, wagt es nicht das Wort gegen C++ zu erheben ;) Die Sprache ist sowas von geil und wird den ganzen anderen Schrott längerfristig schon tot trampeln ;)

Wohin rennen denn die Fortran Leute? JAVA. Ach ich lach mich kaputt. Das sind doch total verschiedene Welten.
Ich wette die Auftraggeber wollten parallelisierte hoch performante Software. Haben aber keine Programmierer gefunden der was aufn Kasten hat, und der Rest kam mit der Sprache nicht klar. Also wurde es wieder Java. Das ist ja bekannt und jeder kann es. Und jetzt ärgern die sich mit ihrere total aufgeblasenen, lahmen Software rum, HäHä.

Die *Basic sprachen sind auch alle hinfällig. Zwar wechseln die Leute hier nicht, aber es kommen auch keine neuen hinzu. Die Sprache stirbt also aus, wenn auch alle *Basic Programmierer ausgestorben sind. Sehr einfach Das ;)

[1] Empirical Analysis of Programming Language Adoption; Leo A. Meyerovich; Ariel S. Rabkin