Harddiskfabrikanten zitten niet stil. De maximale grootte van een harddisk verdubbelt ongeveer elk jaar.
We leven nu in 2010 en als je naar de beter gesorteerde computerboer gaat kun je probleemloos een 2 terabyte (TB) grote harddisk kopen. Dat kost je de kop niet. Knoop er een paar aan elkaar in een RAID-array en je hebt een hele flinke "disk". Als je een Storage Area Network hebt, kon je al jaren disken van die grootte toekennen.
2 TiB (iets meer dan 2 TB) is voor PC's een magische grens en daarover wil ik het nu hebben.

Die 2 TiB is geen enkel probleem voor de meeste UNIX-filesystemen. Het onder Linux veelgebruikte ext2/ext3-filesysteem kan bijvoorbeeld al files van 2 TiB aan op een filesysteemgrootte van maximaal 16 TiB. En voor ext4 ligt de horizon helemaal ver weg: die kan filesystemen tot 1 EiB (exbibyte) aan (1 EiB ~ 1.048.576 TiB).
Het probleem zit ook niet in de herkenning van de grootte door het BIOS. Want dat werkt al jaren met 48-bits Logical Block Addressing, waarmee tot 128 PiB (pebibyte) aangesproken kan worden.
Maar een filesysteem leg je op een partitie, en het probleem zit hem in de partitionering.
Voor je een disk in gebruik neemt, zul je er een partitietabel op aan moeten maken. De partitietabel is ondergebracht in het Master Boot Record (MBR), een gebied aan het begin van de disk met een omvang van wel 512 hele bytes.

De eerste 440 bytes van het MBR bevatten de bootloader. Deze is nodig om een besturingssysteem te kunnen starten. Daarnaast staat voor elke primaire partitie - waarvan er maximaal 4 op een disk mogen staan - aangegeven wat de start-sector en de lengte van die partitie zijn.
De MBR-layout gebruikt 32 bits adressering, waardoor er 4.294.967.296 sectoren aangesproken kunnen worden. En omdat de meeste harddisken gebruik maken van sectoren van 512 bytes, kan hij tellen tot 2 TiB (4.294.967.296 * 512 = 2.199.023.255.552 bytes = 2048 GiB = 2 TiB).

Laten we eens een partitie van 3 TiB proberen aan te maken op een disk van 4 TiB:

# fdisk /dev/sdb
Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-996142336, default 1): 
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-536870911, default 536870911): +3000G
Value out of range.

Hmmm ... value out of range. Dat gaat dus niet werken.
Je kunt de grootte in KiB, MiB, GiB of cylinders opgeven. 1 cylinder bestaat uit 8 sectoren van 512 bytes. De maximale cylinder die je kunt opgeven is 536.870.911, wat overeenkomt met 2048 GiB. fdisk is te oud en kan niet overweg met zeer grote partities/disken.

Maar het MBR - waardoor de beperking tot 2 TiB veroorzaakt wordt - kun je ook niet straffeloos overboord gooien. Want hoe kan een PC anders te weten komen welke partities er op een disk staan en waarvan moet hij dan opstarten?
Je kunt ook de grenzen binnen het masterbootrecord niet oprekken, want daarvoor is geen ruimte beschikbaar.
De oplossing is uitgevonden door Intel en zit in de EFI (Extensible Firmware Interface). EFI is bedoeld als BIOS-vervanger. Onderdeel van EFI is de GPT (GUID Partition Table).
GPT biedt de oplossing voor het 2 TiB probleem. Het mooie is dat GPT los van EFI te gebruiken is. Maar dan moeten de besturingssystemen die gebruik maken van de disk dat wel ondersteunen. Linux doet dat al jaren (RedHat bijvoorbeeld al sinds versie 7.2 uit 2001). Maar Windows XP raakt hiervan compleet van de leg.

Het basisprincipe van GPT is: zet in het masterbootrecord een pointer naar een fake partitie, waar de daadwerkelijke partitie-indeling staat. Om GPT te kunnen gebruiken moet de disk aangemerkt zijn als eentje van het type GPT (i.t.t. tot het "standaard" type MSDOS). Dit kun je niet met fdisk doen, want die doet niet aan GPT, maar wel met parted (uit de stal van GNU) of zijn grafische broerje gparted.

sles10:~ # parted /dev/sdc
GNU Parted 1.6.25.1
Copyright (C) 1998 - 2005 Free Software Foundation, Inc.
This program is free software, covered by the GNU General Public License.

Using /dev/sdc
(parted) mklabel gpt                                                      
(parted) mkpart primary 0 3000G
(parted) print                                                            
Disk geometry for /dev/sdc: 0kB - 4080GB
Disk label type: gpt
Number  Start   End     Size    File system  Name      Flags
1       17kB    3000GB  3000GB 
(parted) quit

Met mklabel gpt geef je aan dat je gebruik gaat maken van GPT, i.p.v. het ouderwetse MBR.

Is GPT noodzakelijk? Ja, zolangzamerhand wel.
Is het dan alles goud wat er blinkt? Nee, dat ook weer niet. Want er zitten nog wel een paar haken en ogen aan het gebruik van GPT:

• Wanneer het een multi-boot systeem is moet je uitkijken. Windows XP en lager (en nee, daar valt Vista niet onder ...) kunnen niet omgaan met GPT.

• De Linux-distributie moet kernel-ondersteuning hebben voor GPT. Nu is dat niet zo'n probleem, want alle distro's die de afgelopen 5 jaar zijn uitgekomen hebben dat.

• Een als MSDOS gelabelde disk - dus met een ouderwets MBR - kun je niet omzetten naar GPT zonder de al bestaande partities kwijt te raken.

Nota Bene: Als je Mac OS X gebruikt (op originele Apple hardware ...), doe je automatisch al aan EFI en GPT.

Meer leesvoer op de websites van IBM of Intel.

Zeggen de volgende namen je wat? Rob Pike, Ken Thompson en Russ Cox. Misschien zegt die laatste naam je niks, maar de eerste twee personen zijn betrokken geweest bij de ontwikkeling van Unix in 1969. Waarbij Thompson Unix zo'n beetje eigenhandig bij elkaar getypt heeft.

Ook de taal C ontwikkeld door Dennis Ritchie is beinvloed door Thompson. Ritchie en Thompson waren immers collega's bij Bell Labs. C is de afgelopen jaren de standaard geweest voor systeem programmering. Bij systeem programma's kun je denken aan de Linux kernel of lowlevel programma's zoals web- en DNS servers. C is daarin nogal succesvol gebleken...

Tegenwoordig blijkt dat C niet meer voor de volle 100% procent voldoet:

• Geheugen beheer is en blijft lastig. Jezelf aanleren dat je malloc() moet gebruiken en daarna het gebruikte geheugen weer vrij moet geven met free() kost discipline;
• Multi-core processoren worden niet door C ondersteund. Tuurlijk, je kunt een C programma schrijven dat prachtig loopt met meerdere processoren, maar makkelijk is het niet en in de taal zelf zit er geen ondersteuning voor ingebakken;
• De header include files die in C is ontstaan is complex;
• C is steeds langzamer geworden tijdens de compilatie slag.

Tijd voor een nieuwe taal, die deze en andere nadelen van C goed oplost. Daarom Go!

Go heeft:

• Automatisch garbage collection; geen malloc() en free() meer, de taal verzorgt dit voor je;
• Door middel van het go-keyword kun je functies afvuren zodat die als een apart, licht gewicht proces draaien;
• Communicatie met de go-routines gaat door middel van channels;
• Supersnelle compilatie, denk hieraan compilaties die binnen 1 - 2 seconden klaar zijn;
• UTF-8 ondersteuning in strings en in de programma code. Eindelijk Griekse symbolen in je berekening;
• Strings ingebouwd in de taal (net zoals in Perl, Python, etc.)
• Een opgelegde coding style;
• Lol! Go probeert de lol in programmeren terug te brengen.

Hello World

Zoals bij elke nieuwe taal wordt ook de taal Go aangekondigd met het volgende programma:

package main

import fmt "fmt" // Package voor geformatteerde I/O.

func main() { 
    fmt.Printf("Hello, world) 
}

Programmeurs zullen weinig moeite hebben met de bovenstaande code. De accolades van C komen terug in Go, maar de puntkomma's zijn weggelaten. Vergelijkbaar met C begint de uitvoering van een programma door het starten van de functie main(), bij Go hoort deze functie ook nog in het package main te zitten.

Echo

Hier een wat langer voorbeeld uit de introductie van Go, een her-implementatie van het Unix commando echo:

package main

import ( 
    "os"
    "flag" // commando regel opties parser
) 

var omitNewline = flag.Bool("n", false, "print geen regel overgang")

const ( 
    Space = " " 
    Newline = "\n" 
)

func main() { 
    flag.Parse() // Parseer de commando regel
    var s string = "" 
    // Bouw de nieuwe string op 
    for i := 0; i < flag.NArg(); i++ { 
        if i > 0 { 
            s += Space 
        } 
        s += flag.Arg(i) 
    } 
    if !*omitNewline { 
        s += Newline 
    } 
    // Schrijf de string naar buiten
    os.Stdout.WriteString(s) 
}

Wat opvalt aan de bovenstaande code is de eenvoud en de lengte. Een ander innovatief aspect van Go is dat de type aanduiding bij variabelen niet vooraan staat maar achteraan:

var s string

declareert de variabele s als een string. Meerdere variabelen zijn te declareren als:

var s,t string

Natuurlijk raak ik hier maar het topje van de ijsberg en is er nog veel meer te vertellen. Zie daarom ook de links aan het eind van dit document.

Coding style

Een stap waar de Go-auteurs al veel kritiek op hebben gekregen is het afdwingen van een bepaalde codeer stijl. Vergelijkbaar met hoe de taal Python dat doet, maar met een twist. Voor Go geldt het volgende:

De afgesproken codeer stijl is de stijl zoals het programma gofmt het weergeeft.

Alle bibliotheken (packages in Go) zijn ook geformatteerd door gofmt. En, ik moet zeggen, het is ook wel gemakkelijk, nooit meer discussie over waar de opening accolade nu precies moet komen te staan.

Starten met Go

De volgende links zijn interessant, mocht je je meer willen verdiepen in Go.

De Go introductie en geavanceerd programmeren.

Een video, door Rob Pike, over een voorloper taal van Go, Newsqueak genaamd. Hierin zitten veel aspecten die ook in Go terecht zijn gekomen. Newsqueak is nooit vrij gegeven buiten Google.

Een andere taal met vergelijkbare features is Erlang. Deze taal draait op een VM (ala Java), en is een meer functionele taal.

Aangezien de grote namen die achter deze taal staan en omdat het ook nog eens gesponsord wordt door Google verwacht ik er aardig wat van. (Beginners) documentatie op dit moment schaars, maar ook daar wordt aan gewerkt. Wie weet, geeft AT Computing over jaar wel Go cursussen.

Let wel op, de taal zelf is nog volop in ontwikkeling, dus ook op taal niveau worden zaken aangepast c.q. verbeterd.

Onlangs kregen we een verzoek of een slechtziende persoon aan een van onze cursussen zou kunnen deelnemen. We hebben in het verleden vaker slechtziende en blinde cursisten gehad, en met wat extra moeite komen zij en wij daar in het algemeen erg tevreden uit.

De docent moet zijn woorden, zijn gebaren, en het schrijven op het bord zorgvuldig op elkaar afstemmen. Dat vereist wat oefening en discipline. Ook de uit te reiken cursusdocumentatie moet aangepast worden afgedrukt, en/of als PDF beschikbaar worden gesteld. Tenslotte moet de werkplek op maat worden ingericht. Over die werkplek gaat de rest van dit verhaaltje.

Deze cursist liet ons weten dat hij graag gebruik zou maken van vergrotingssoftware vergelijkbaar met het produkt ZoomText van ai squared onder Windows. Letters van 2 cm hoogte zouden ideaal zijn.

Bij zulke grote letters wil je ook een groot scherm. We hebben bij AT een werkplek met een Apple Cinema HD 30 beeldscherm, 40x64 cm, 2560x1600 pixels. Daar hoort natuurlijk een flinke grafische kaart bij: Nvidia GeForce 9600GT. De betreffende computer is ingericht met een recente Ubuntu Linux. Het is een uiterst comfortabele werkplek!

Bij Ubuntu is "gnome-terminal" het gebruikelijke shell-venster. Met de maximale "zoom-in" levert dat op het genoemde beeldscherm 7 mm hoge (m-height) characters. Dat was dus nog niet genoeg. En grafische programma's gebruiken geen gnome-terminal, maar moeten wel mee worden vergroot.

In eerste instantie denk je aan het commando "xmag", maar dat kan alleen statische delen van het scherm vergroten, en is niet echt meer van deze tijd.

In onze Ubuntu Certified Professional cursus komt onder andere "Accessibility" (kort) aan bod. Daaruit wisten we dat de compiz window manager ook zoom-support kan leveren. Daarvoor moet je wel het pakket "simple-ccsm" apart downloaden en installeren. Met de Ubuntu "apt-get" is dat in een paar tellen gebeurd.

Instellen gaat vervolgens via het Ubuntu-menu: System -> Preferences -> Appearance, en daar selecteer je Visual Effects -> Custom

Daarna kun je de combinatie van scrollwiel en "Special"-toets (dat is dan de Windows-toets, zie foto van het keyboard) gebruiken om in- en uit te zoomen. Bewegen van de muis geeft "panning": het vergrootglas over de ondergrond bewegen. Het mooie hieraan is dat het hele scherm wordt vergroot. Op de andere foto ziet u een stukje van onze website, gefotografeerd op het betreffende grote beeldscherm, en een telefoontoestel erbij als referentie.

Meer informatie is te vinden op: http://www.howtoforge.com/enabling-compiz-fusion-on-an-ubuntu-9.10-desktop-nvidia-geforce-fx-5200-p2

Voor de volledigheid moet worden gezegd dat naast deze compiz-gebaseerde faciliteiten ook het Orca-project in de gnome window manager uitgebreide faciliteiten voor slechtziende en blinde gebruikers bevat. Een projectbeschrijving vindt u hier en op de website van Willi Walker, de voortrekker van dit project.

Het is qua rekentijd allemaal niet gratis, maar je krijgt wel wat moois. De cursist "voelde zich met deze werkplek verwend".