Fyra debakel

Bij het lezen over de pogingen, in Nederland een hogesnelheidslijn te bouwen en te gebruiken valt op hoe beschamend amateuristisch en achterlijk de Nederlandse Spoorwegen eigenlijk zijn.

NS – Nederlandse Spoorwegen – dekt eigenlijk de lading niet. Spoorwegen hebben wij niet, meer een soort hypervol forenzennet vol met stoptreinen die in andere landen als ‘Regionalbahn’, ‘Pendeltåg’ of iets soortgelijks bekend staan.

Waarom lukt het ons niet om een trein harder te laten rijden dan 160 km/u ? Uit het boek ‘Geschichte der Deutschen Bundesbahn’ komt het volgende stukje :

“Aber dann ab 1970 kamen die 145 Exemplare der Serien 103 natürlich doch; die Utopie wurde Alltag. Ab 1971 wurden sie vor den in Zweistundentakt nur mit Erster Wagenklasse fahrende Intercitys eingesetzt, die dann auf immer längeren Abschnitten auch wirklich 200 km/h fahren durften”

DB103

DB103 1

De (West-)Duitse spoorwegen reden dus vanaf 1970 met hun IC treinen volgens plan stukken met 200 km/h.  43 jaren later lukt het de Nederlandse spoorwegen nog steeds niet om deze dienstregeling ook maar bij benadering te evenaren.

Andere wapenfeiten die onderbouwen hoe wij achterlopen op andere landen:

  • De Franse spoorwegen SNCF rijden sinds 1981 met hun TGV, welke in de reguliere dienst snelheden tot 320 km/u haalt.
  • In Japan rijdt al sinds de jaren 60 de Shinkansen trein, met snelheden tot 320 km/u.
  • De Duitse ICE trein rijdt sinds 1985 door Duitsland en haalt snelheden tot 300 km/u.

De NS moeten hun concessie voor de HSL afstaan en een andere partij, die wel met dit soort treinen overweg kan, ruim baan geven om ons in Nederland wel met een goed werkende HSL van dienst te zijn.

Good old George W Bush nostalgia

During a clean-up of my bookshelf I ran into an old excerpt from a newspaper (Doonesbury by Garry Trudeau).

I immediately felt a surge of “Bush nostalgia” ! Judge for yourself:

George W Bush

De Windcentrale

Voor wie zelf zijn electriciteit wil opwekken, wordt dan mede-eigenaar bij :

En maak je zelf onafhankelijk van stijgende stroomprijzen en op winst beluste energieleveranciers.

Wist U dat als de olieprijzen stijgen, uw met wind opgewekte stroom bij Nuon ook duurder wordt? Het is verbazingwekkend dat de wind in Nederland een prijs heeft die gekoppeld is aan olie uit het midden-oosten. Je zou verwachten dat slechts aanleg, onderhoud en netaansluiting in de kostprijs van een windturbine zitten. Neen, dit is niet zo en in feite wordt U belazerd met een willekeurig schommelende prijs. Een mooie leugen van de energiesector, een sector waar veel geld wordt verdiend aan onwetendheid.

Een andere leugen van die sector is het feit, dat als zij zegt groene stroom leveren, zij eigenlijk alleen maar een eigendomscertificaat van een oude waterkrachtcentrale in Noorwegen in bezit heeft. De Noorse stroom bereikt U nooit, maar wordt ter plekke door Noren (en Zweden) gebruikt.

Uw echte stroom komt gewoon uit een bruinkoolcentrale in Duitsland, of de kerncentrale in Borssele. Ondertussen doet uw leverancier alsof U met uw keuze voor groene stroom een actieve bijdrage levert aan de omschakeling naar duurzaamheid.

Onze overheid maakt het overigens ook bont. Energie van een eigen windturbine, die je aan jezelf levert, is nog steeds aan energiebelasting onderhevig. Een levering die in commercieele zin geen transactie is, want een levering aan jezelf kun je niet als aankoop of verkoop betitelen, wordt door de overheid op wazige gronden wel als transactie gezien.

Het doel is duidelijk : De armlastige staat heeft dringend geldt nodig om graaiende bankiers te steunen en corrupte Grieken nog een lening te verstrekken. De Euro, dat wangedrocht, moet immers in leven blijven. Daartoe berooft zij haar eigen burgers, ook als die zich proberen te onttrekken aan fossiele brandstoffen.

 

 

 

 

 

 

Kalender nu ook in Windows versie

Ik heb een WIN32 installer gebouwd voor de kalender applicatie, dus de kalender draait nu ook onder Windows.

Verder een voorzichtig begin gemaakt met vertalingen, de kalender kan meer of minder worden omgeschakeld naar Duits en Engels.

Hier is een screenshot van de kalender (Apple versie) :

Alle bestanden zijn te vind op de FTP server.

Verjaardagskalender app voor Apple Mac OS X

Ik heb een kalender app geschreven die het volgende kan :

  • Gebeurtenissen kunnen worden ingegeven en worden getoond binnen een aangegeven max vooruitkijktijd.
  • Gebeurtenistypen kunnen worden opgegeven.
  • Naast algemene filtering op tijd kan ook gefilterd worden op type en naam.

De app is geschreven om te leren werken met SQLite, een geweldige embedded database. De voornaamste reden om hem te schrijven is om nooit meer verjaardagen enz te vergeten.

Vooralsnog is slechts een beta versie  voor Apple Mac OS X beschikbaar. De app is geschreven met behulp van wxWidgets, en een Windows,Linux en FreeBSD versie zijn bijna klaar.

 

Pim Fortuyn 10 jaar dood

 

Fortuyn doodgeschoten

10 jaren geleden werd Pim Fortuyn doodgeschoten door een intolerante gek, Volkert van der Graaf.

de moordenaar van Pim Fortuyn

Fortuyn’s strijd tegen elitaire, ondemocratische en arrogante gezagsstructuren is nog steeds actueel. Waarom heb ik als burger nog steeds geen grip op de keuze van:

  • De burgemeester van mijn woonplaats?  De man/vrouw, die in mijn woonplaats verantwoordelijk is voor het handhaven van de openbare orde, is aan de burgers in zijn/haar gemeente geen verantwoording verschuldigd. Hij/Zij heeft wel grote invloed op mijn persoonlijke veiligheid. Benoemd door de kroon.
  • De commissaris van de koningin? Een functie met een hoog Bobo gehalte, maar feitelijk wel de hoogste bestuurder in mijn provincie. Benoemd door de kroon.
  • Het staatshoofd? Benoemd zichzelf in Nederland en kan alleen afkomstig zijn uit een familie die zichzelf zeer bijzonder vindt, maar waar bij nadere inspectie een hoop op aan te merken is. Aan ons opgedrongen in 1815 bij het Congres van Wenen en tot de dag van vandaag een bloedzuiger van formaat voor de samenleving.

 

Fortuyn was een eigenwijze dandy, een relnicht die het heerlijk vond om de vinger op de zere plek te leggen. Oplossingen had hij niet voor de problemen die hij benoemde, maar het feit dat hij deze benoemde maakt hem uniek. Rust in vrede, Pim Fortuyn!

 

 

Robert Mugabe and ZANU-PF must go by force

BastardIt is long overdue for Robert Mugabe and his gang of thieves and crooks. He must go. They have wrecked what was once called “a jewel in Africa” (Julius Nyerere). Zimbabwe used to be a shining example of progress. It has become a cesspool of lawlessness, violence, hate and indiscriminate abuse of power.

 

Many people have advocated that Mugabe and his fellows should go. Just look at all the people that fled the country, or at the protests facing Zimbabwe’s embassies around the globe. Their cause is sympathetic but hopeless. Mugabe has no shame and will resort to any measure to keep himself in place. Nothing will change, because Mugabe knows that as long as he controls the means to violence, he will get what he want.

 

In the 1970s, the only way Mugabe and ZANU-PF were able to penetrate into Rhodesia was by forcefully bullying the peasant population into submission. Anyone who didn’t cooperate was tortured or killed in front of others. People were stuck between a rock and a hard place – the Rhodesian security forces and Mugabe’s ‘liberation’ fighters. Only, the hard place was harder than the rock – Mugabe was much more brutal than the security forces. Even during the 1980 elections, he could never have won without massive intimidation of the voters, especially in the Shona areas. He found out for himself, that as long as he was more brutal than the others, then he would win.

He did the same thing in the 1980s, when his Matabele comrades in arms found out what he really was – a lowly jackal and a turncoat. He murdered many thousands of  Matabeles to secure his position.

The only thing he really respected, because they stood in his path to tyranny and dictatorship, were the Rhodesian security forces. They nearly killed him. He hated them and he hated Ian Smith, but he also respected them because they answered his language of force with counter force. Smith’s presence in politics in the early 1980s probably kept him from going all-out like he did in the 1990s and 2000s.

He is hated by his people. Ian Smith said, in 2003, that if he and Mugabe were to walk into a black Harare township together, only one would come out alive. Smith was confident enough to do it. Mugabe isn’t. He hurries along in his huge motorcade.

So, there you have a dictator who is afraid, who is reviled by his people and everybody is desperate for a change. What can be done about it. A protest? Nothing will change. More drastic measures must be taken.

I say, let’s get rid of him and his thieves.  I say, let us complete their task and stand up against Mugabe. Let him feel the power of the gun. Let him run into the bush with armed units after him. Rise and dismiss the dictator. Kill him and all his cronies in the most ferocious way possible.

Zimbabwe needs new men of steel, like Ian Smith or Ron Reid Daly, who are willing to take up arms against Mugabe. A new Chimurenga must take place, but this time, to restore the values that were buried when Rhodesia disappeared.

 

 

 

TI’s new Cortex-M4 line versus the rest

Recently I received an email from Texas Instruments (TI) in which they announced the availability of their new Cortex-M4 line. I really like many products TI makes. When I spoke to TI people at Nürnberg’s Embedded World fair last March, I was thrilled to hear TI would release a Cortex-M4 part in autumn 2011.

I have used their LM3S9B96 processor and am very satisfied with it – excellent peripherals, very good DMA controller, lots of memory and the inclusion of Stellarisware and SafeRTOS in ROM in the chip. I sort of expected the extension of their Cortex-M3 family with Cortex-M4 based microcontrollers that would be faster and  just as well, or better, equipped. To my disappointment, that is not the case:

  • The new Cortex-M4 line (Blizzard) is not faster than the Tempest class Cortex-M3.
  • The new Blizzard class has less internal memory (32K vs 96K).
  • The new Blizzard class has no external bus interface.
  • The new Blizzard class has no Ethernet MAC/PHY like the Tempest class.

The only things going for it seem to be the internal EEPROM, the DSP additions in the core and the fact that the IC is produced using a 65 nm process.

So, why would I use the new Blizzard class instead of the Tempest class? I see no major compelling reasons to migrate. In fact, I think that many if not most DSP style calculations can easily be done on the Tempest class if you use the IQMath library, which is used to map floating point calculations onto fixed-point ones.

Also, when comparing the Blizzard class to competing offerings from other manufacturers, it doesn’t really impress me:

  • Freescale has been offering their Kinetis controller for a while. Running at 150 MHz (the K70 type) and equipped with many useful peripherals (among them, a LCD controller) this seems better equipped than the Blizzard class, and almost twice as fast.
  • NXP will soon be releasing the LPC4000 family, which will run at 180 MHz and which has a Cortex-M4 together with a Cortex-M0 on board. Again, in terms of raw performance, this one leaves the Blizzard class kicking in the dust.
  • ST recently released their STM32F4 series. This stunning Cortex-M4  microcontroller runs (from flash) at 168 MHz – more than double the speed of the Blizzard class. It has loads of memory, many peripherals, an external bus and so on. I seriously doubt TI’s Blizzard class will beat this one.
I hope TI will follow suit and release a Cortex-M4 offering with a performance similar to or better than the ones above. If not, I think they will not compete well in the Cortex-M4 class arena.

Using new and delete in C++ on Cortex-M3

A nice way to precisely time the instantiation of an object in C++  is to use the new and delete operators. Normally, an global object is instantiated at a undefined time – the compiler decides on this, not a language standard.

Whilst delete would not be of great use in an embedded system without good memory management (the easiest implementation would be the  BGET package), new can be used efficiently to cater for a linear instantiation where the user decides when to instantiate.

If you want to use C++ without the bloat, you’re probably forced to provide your own new and delete routines. On Cortex-M3, this can be tricky.

Although the core supports unaligned memory access, unaligned multiple LDM, STM, LDRD and STRD calls will cause a Usage Fault exception. Also, using unaligned data decreases performance. When instantiating a class with a multitude of variables listed in the class, the allocated memory block could well be unaligned. Also, code could conceivably be generated that will execute a number of LDM or LDRD instructions, for example, in the constructor of the object.  It is therefore imperative that a new call will always return an aligned block of data.

A simple way to implement new and delete would be like this :

static void * toewijzing(const size_t size) /* let op: size geeft het aantal bytes aan */
{
    static UInt8 *heap_ptr = (UInt8 *)(__bss_end);
    const UInt8 *base = heap_ptr;       /*  Point to end of heap.  */
    const UInt8 *eindeSRAM = (const UInt8 *)__TOP_STACK;        

    if ((heap_ptr+size) < eindeSRAM)
    {
        heap_ptr += size;       /*  Increase heap met size aantal bytes  */
    }
    else
    {
        while(1);
        KiwandaAssert(0);
    }

    return((void *)base);               /*  Return pointer to start of new heap area.  */
}

void * operator new(size_t size) /* let op: size geeft het aantal bytes aan */
{
    return(toewijzing(size));
} 

void * operator new[](size_t size)
{
    return(toewijzing(size));
} 

void operator delete(void * ptr)
{
    // free(ptr);
} 

void operator delete[](void * ptr)
{
    //free(ptr);
}

The linker will provide the location of the end of the used SRAM space (__bss_end) and the end of the SRAM block (__TOP_STACK).  An example would be the following Linker Load file, used for the Energy Micro EFM32G880F64 processor:

************************************************************************
ARM Cortex M-3 standaard microcontroller loadscript.
Memory I/O adressen, aangepast aan eigenschappen
van de Energy Micro EFM32G880F64 Microcontroller

Alle aanpassingen in dit bestand zijn
(c) 2008-2011 Kiwanda Embedded Systemen
Voor alle overige software geldt het copyright van Atmel

$Id: efm32g880f64.ld 3041 2011-08-28 20:29:52Z oldenburgh $
************************************************************************/

OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm")
OUTPUT_ARCH(arm)

MEMORY
{
  FLASH (rx)   : ORIGIN = 0x00000000, LENGTH = 64K
  DATA (rw)    : ORIGIN = 0x20000000, LENGTH = 16K
}

__TOP_STACK    = ORIGIN(DATA) + LENGTH(DATA);

/* Section Definitions */

SECTIONS
{
  /* first section is .text which is used for code */

  . = ORIGIN(FLASH);
  .text :
  {
        KEEP(*(.cortexm3vectors))      /* core exceptions */
        KEEP(*(.geckovectors))          /* efm32 exceptions */
        . = ALIGN(4);
        KEEP(*(.init))
        CREATE_OBJECT_SYMBOLS
        *(.text .text.*)                   /* C en C++ code */
        *(.gnu.linkonce.t.*)
        *(.glue_7)
        *(.glue_7t)
        *(.vfp11_veneer)
        *(.ARM.extab* .gnu.linkonce.armextab.*)
        *(.gcc_except_table)
        . = ALIGN(4);
   } >FLASH

__exidx_start = .;
.ARM.exidx   : { *(.ARM.exidx* .gnu.linkonce.armexidx.*) }
__exidx_end = .;

   . = ALIGN(4);

        .rodata : ALIGN (4)
        {
                *(.rodata .rodata.* .gnu.linkonce.r.*)

                . = ALIGN(4);
                KEEP(*(.init))

                . = ALIGN(4);
                __preinit_array_start = .;
                KEEP (*(.preinit_array))
                __preinit_array_end = .;

                . = ALIGN(4);
                __init_array_start = .;
                KEEP (*(SORT(.init_array.*)))
                KEEP (*(.init_array))
                __init_array_end = .;

                . = ALIGN(4);
                KEEP(*(.fini))

                . = ALIGN(4);
                __fini_array_start = .;
                KEEP (*(.fini_array))
                KEEP (*(SORT(.fini_array.*)))
                __fini_array_end = .;

                . = ALIGN(0x4);

                __CTOR_LIST__ = .;
                LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
                *(.ctors)
                LONG(0)
                __CTOR_END__ = .;
                __DTOR_LIST__ = .;
                LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
                *(.dtors)
                LONG(0)
                __DTOR_END__ = .;

                . = ALIGN(0x4);

                KEEP (*crtbegin.o(.ctors))
                KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors))
                KEEP (*(SORT(.ctors.*)))
                KEEP (*crtend.o(.ctors))

                . = ALIGN(0x4);
                KEEP (*crtbegin.o(.dtors))
                KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors))
                KEEP (*(SORT(.dtors.*)))
                KEEP (*crtend.o(.dtors))

                *(.init .init.*)
                *(.fini .fini.*)

                PROVIDE_HIDDEN (__preinit_array_start = .);
                KEEP (*(.preinit_array))
                PROVIDE_HIDDEN (__preinit_array_end = .);
                PROVIDE_HIDDEN (__init_array_start = .);
                KEEP (*(SORT(.init_array.*)))
                KEEP (*(.init_array))
                PROVIDE_HIDDEN (__init_array_end = .);
                PROVIDE_HIDDEN (__fini_array_start = .);
                KEEP (*(.fini_array))
                KEEP (*(SORT(.fini_array.*)))
                PROVIDE_HIDDEN (__fini_array_end = .);

                . = ALIGN (8);
                *(.rom)
                *(.rom.b)

        } >FLASH

   . = ALIGN(4);
   _etext = . ;
   PROVIDE (etext = .);

  /* .data section which is used for initialized data */

   _bdata = . ;
   PROVIDE (bdata = .);

  .data : AT(_bdata)
  {
    _data = . ;
    *(.data)            /* normale data */
    *(.data.*)        

    SORT(CONSTRUCTORS)
    . = ALIGN(4);
  } >DATA

   _edata = . ;
   PROVIDE (edata = .);

  . = ALIGN(4);

  /* .bss section which is used for uninitialized data */
  .bss(NOLOAD) :
  {
    _bss = . ;
    __bss_start = . ;
    __bss_start__ = . ;
    *(.bss)
    *(.bss.*)
    *(COMMON)
   __bss_end__ = . ;
   __bss_end   = . ;
   PROVIDE (_ebss = .) ;
  } >DATA

  . = ALIGN(4);

   _end = .;
   PROVIDE (end = .);    /* einde intern geheugen */

  /* Stabs debugging sections.  */
  .stab          0 : { *(.stab) }
  .stabstr       0 : { *(.stabstr) }
  .stab.excl     0 : { *(.stab.excl) }
  .stab.exclstr  0 : { *(.stab.exclstr) }
  .stab.index    0 : { *(.stab.index) }
  .stab.indexstr 0 : { *(.stab.indexstr) }
  .comment       0 : { *(.comment) }
  /* DWARF debug sections.
     Symbols in the DWARF debugging sections are relative to the beginning
     of the section so we begin them at 0.  */
  /* DWARF 1 */
  .debug          0 : { *(.debug) }
  .line           0 : { *(.line) }
   *(.data)            /* normale data */
    *(.data.*)        

    SORT(CONSTRUCTORS)
    . = ALIGN(4);
  } >DATA

   _edata = . ;
   PROVIDE (edata = .);

  . = ALIGN(4);

  /* .bss section which is used for uninitialized data */
  .bss(NOLOAD) :
  {
    _bss = . ;
    __bss_start = . ;
    __bss_start__ = . ;
    *(.bss)
    *(.bss.*)
    *(COMMON)
   __bss_end__ = . ;
   __bss_end   = . ;
   PROVIDE (_ebss = .) ;
  } >DATA

  . = ALIGN(4);

   _end = .;
   PROVIDE (end = .);    /* einde intern geheugen */

  /* Stabs debugging sections.  */
  .stab          0 : { *(.stab) }
  .stabstr       0 : { *(.stabstr) }
  .stab.excl     0 : { *(.stab.excl) }
  .stab.exclstr  0 : { *(.stab.exclstr) }
  .stab.index    0 : { *(.stab.index) }
  .stab.indexstr 0 : { *(.stab.indexstr) }
  .comment       0 : { *(.comment) }
  /* DWARF debug sections.
     Symbols in the DWARF debugging sections are relative to the beginning
     of the section so we begin them at 0.  */
  /* DWARF 1 */
  .debug          0 : { *(.debug) }
  .line           0 : { *(.line) }
  /* GNU DWARF 1 extensions */
  .debug_srcinfo  0 : { *(.debug_srcinfo) }
  .debug_sfnames  0 : { *(.debug_sfnames) }
  /* DWARF 1.1 and DWARF 2 */
  .debug_aranges  0 : { *(.debug_aranges) }
  .debug_pubnames 0 : { *(.debug_pubnames) }
  /* DWARF 2 */
  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
  .debug_abbrev   0 : { *(.debug_abbrev) }
  .debug_line     0 : { *(.debug_line) }
  .debug_frame    0 : { *(.debug_frame) }
  .debug_str      0 : { *(.debug_str) }
  .debug_loc      0 : { *(.debug_loc) }
  .debug_macinfo  0 : { *(.debug_macinfo) }
  /* SGI/MIPS DWARF 2 extensions */
  .debug_weaknames 0 : { *(.debug_weaknames) }
  .debug_funcnames 0 : { *(.debug_funcnames) }
  .debug_typenames 0 : { *(.debug_typenames) }
  .debug_varnames  0 : { *(.debug_varnames) }

} /* einde secties */

When the size of the allocated block is not a multiple of 4, the next allocated block will be unaligned. In order to prevent this, allocation must always be done at multiples of 4 bytes. The next example will show this:

static void * toewijzing(const size_t size) /* let op: size geeft het aantal bytes aan */
{
    static UInt8 *heap_ptr = (UInt8 *)(__bss_end);
    const UInt8 *base = heap_ptr;       /*  Point to end of heap.  */
    const UInt8 *eindeSRAM = (const UInt8 *)__TOP_STACK;        

    if ((heap_ptr+size) < eindeSRAM)
    {
        heap_ptr += size;       /*  Increase heap met size aantal bytes en eindig op 32 bit boundary */

        while (((unsigned int)heap_ptr & 0x3) != 0)   /* bit 0 en 1 = 0 --> stappen in 4 * byte = 32 bytes */
            heap_ptr++;
    }
    else
    {
        while(1);
        KiwandaAssert(0);
    }

    return((void *)base);               /*  Return pointer to start of new heap area.  */
}

void * operator new(size_t size) /* let op: size geeft het aantal bytes aan */
{
    return(toewijzing(size));
} 

void * operator new[](size_t size)
{
    return(toewijzing(size));
} 

void operator delete(void * ptr)
{
     /* not applicable in embedded application */
} 

void operator delete[](void * ptr)
{
    /* not applicable in embedded application */
}

Advancing the heap_ptr to the next aligned address will prevent unaligned allocation to take place. The price paid for this is the loss of, at most, 3 bytes in between two allocated blocks. Since most systems have SRAM memory equal to or in excess of 16 KBytes, this won’t pose a major problem. During design of a class, careful placement of the data members will also prevent unaligned variables. Simply stated, group your equal variables together (for example, all unsigned char or unsigned short) and pad them, if necessary,  at the end with a dummy variable to grow to the 32 bit boundary:

UInt8 var1;
UInt16 var2[3];

/* total = 8+2*16 = 40 bits  -> we need 24 bits padding */
UInt8 padding[3];

This will prevent costly unaligned acces.

VVD verbaast mij al weer

Opnieuw een bericht dat mij ongelofelijk voorkomt:

“Dit betekent niks voor het Nederlandse debat”, zegt VVD-Kamerlid René Leegte. „Duitsland wil 25 procent duurzame energie opwekken. Dan zullen ze moeten importeren en laat je niks wijsmaken: dat wordt Franse kernenergie.”

Meneer Leegte (zijn naam beschrijft goed zijn denkproces) vergeet dat wij als Nederland voor een zeer groot gedeelte van onze welvaart en stabiliteit afhankelijk zijn van wat er in Duitsland gebeurt. Dat “dit niets betekent” is dan ook een lege kreet, want wat in Duitsland wordt besloten heeft altijd gevolgen voor ons. Hij sluit slechts de ogen voor het feit dat, hoe zeer hij ook een tweede Fukushima- of Tsjernobylachtige centrale in ons land wil plaatsen (waarom eigenlijk?) we links worden ingehaald door een aantal belangrijke buurlanden.

En waar is het élan gebleven? “Ze zullen wel kernenergie gaan importeren………” wat een misselijkmakende negatieve pessimistische blik op de toekomst. Vergeten wordt waar het technisch vernunft van de Duitsers toe in staat is. Je kunt beter goed proberen dan fout blijven doorgaan, maar meneer Leegte vindt fout doorgaan een echt liberaal standpunt.

Wij moeten ook het roer wenden en mee gaan doen met het Duitse initiatief. Dat levert kennis, inkomenst en en een schonere wereld op. In plaats daarvan wil de VVD (waar ik lid van ben)  als een stel conservatieve oude verstilde zakken ons geld in de bouw van een kerncentrale steken, want iets anders durven ze niet. Maar met zo’n renteniersmentalieit komen we er niet.