I have no idea what happened yesterday when I charged it, it charged for only a few minutes then the led turned to green (meaning it's finished) yet there was virtually no charge on the battery indicator.

I charged it last night and it's now at full charge, so I'm happy at the moment.

Ubuntu Gutsy (7.10) provides the right packages to get MTP devices working, just not the right versions for the P2. To get it working somebody has put up a repository of packages with the right versions up, install these as per the instructions. These packages also add the /etc/udev/rules.d/libmtp7.rules file which has the correct line for the P2.

To mount the player in Gutsy, do the following:

1. Install mtpfs (as in the above link).
2. Uncomment the user_allow_other line in the /etc/fuse.conf so that any user can mount the player.

Bash code
$ mkdir ~/YP-P2
$ mtpfs -o allow_other ~/YP-P2/

To unmount the player type:

Bash code
$ fusermount -u ~/YP-P2

I've noticed that if RhythmBox has been started you can't use mtpfs at the same time.

Upgrading the firmware

Samsung have made this is a complete doddle to do, mount the P2, and copy over the 2 firmware files to the root of the device, unmount, remove the USB cable (I don't know if this is really necessary) and then reboot. On the first boot, it'll upgrade one of the files and shut down. Power it back up and it'll upgrade the next one and shut down again. Power on for the third time and all should be upgrded to the new firmware. Mine is now running the new Bluewave 2 firmware. Or you can see screenshots of the upgrade.

Getting the cover art to work

This took me about 2 hours to work out during which I tried all sorts of packages. Easytag doesn't work, it embeds it, but the P2 cannot read it. I couldn't work out Amarok, so that was out. Finally, I tried kid3 and it worked first time! Basically, you select all the files that you want to have the same image, add a new tag (APIC), set the encoding (UTF8), the mimetype (image/jpeg), picture type (front cover) and description (the filename in this case) and import the file into kid3. Select OK and then save all the files to disk. Easy as that!

Playlists

My success with these has been patchy really, most of the time I copy a playlist (in m3u format) to the P2 (using mtpfs, as this is supposed to convert to the native playlist format when the file is copied), I can't unmount the player (it says the device is busy). Killing mtpfs works, I can then unmount, but the playlist isn't copied across, the P2 states that it is empty. I've managed to copy a playlist over twice so far, but patchy it is.

I've had an Xclef MT-500 for about 5 years now, but it has a number of problems:

• The battery life is crap and I have to carry around a number of spares.
• internal memory can corrupt easily.
• There are no more firmware updates, and these can easily go wrong causing a broken player.

The things it got right though were:

• The provision of an SD card slot, although no-one seems to know what size limit it has.
• Has an FM radio.

So, I started to look for a new MP3 player this week. Although the Apple iPod nano 4GB MP3 Player's are very sexy, they're still too much style over substance in my opinion. So, these have been ruled out.

I would prefer a player I can upgrade the memory of, but given that these things are such a commodity these days, it's very unlikely that I'd find one that was SD card (or similar) only. I did find the iAudio D2 2GB MP3 Player and although it does have the SD card, for the price, I think it's a bit expensive.

I then found the Samsung YP-P2 8GB Bluetooth Portable Media Player which is slightly bigger than an iPOD Nano, but has a radio, plays films too (whether I'll use these features is unknown at this time though). But then, after a bit of searching on the net, I find that there is a 16GB version coming out, when? I've no idea. Also, a possibility of a dock with a mini-SD card slot in it (although a lot of people think it's a fake). So, if these 2 things pan out, I'm probably going to buy one of these.

I've found that this device can be used on Linux.

I know I've been suffering from this for the past 3 years; basically, since I left my last programming job. I had actually been suffering during the time I was there, for at least 2 years really. I should've left a year after being there like I was going to. Ideally, I never should've taken the job in the first place, but it seemed like such a good job at the time. Hindsight's a wonderful thing!

Anyways, I keep trying to work on projects that I have always wanted to do and I keep failing because I just can't get motivated. The idea of working on something cool just doesn't seem to be enough. So, I thought I'd do a quick search and see what burn out really is. I've read through the article and quite surprised to find that I recognise all of those traits, oh well.

I honestly can't cope with this when I really want to be working on stuff again. How long does this last? Anybody else experience this? Maybe I just need to get out more?

Following on from my hello world style kernel, I've decided to post a plan for what I intend to accomplish in regards to an OS design.

I've been thinking about OS designs for over 10 years on and off and have wanted to develop one. Originally, I was going to do it in C but as I now use Ada more and more I want to use this language for the implementation (and assembly where necessary). The main thing that has been stopping me from developing an OS is the thought that I didn't really know how to. I pretty much know the basics of the underlying core of an OS, e.g. setting up interrupts, memory management, etc. so that is, at least, a starting point.

So, here's the plan; develop a microkernel based OS using Ada. This OS should provide a microkernel, some basic services and be able to run some applications. I'm not aiming to provide a full OS, just something to learn from. I'm also not going to be trying to implement POSIX, it'll be something else entirely.

Targets

I intend for the OS to be portable to other architectures and it should be capable of being compiled for big-endian and little-endian machines. I'll also be aiming to provide versions for both 32-bit and 64-bit architectures.

This might seem a bit excessive, but I believe that the OS designer should start thinking about making their OS cross platform from the outset. Here is a list of the tools I will use:

• binutils-2.18
• GCC/GNAT-4.2.2
• NewLib (latest version from CVS)
• GNU Make (standard Ubuntu version is fine)
• QEMU (latest version from CVS)
• GRUB 2 (there's a problem with GRUB 1 segfaulting on my Ubuntu and the GRUB developers are only interesting in talking/helping with GRUB 2)

These tools will be available on all Linux and Win32 platforms. I'm not too sure about MacOS X, I'm fairly sure that they have the GNU tools available, they definitely have GNAT. I'll be using Ubuntu Linux and compiling my own toolchain. I'll also be attempting to port a minimal Ada runtime so I can have full GNAT tool support (including ASIS) and I will be showing the build process of each relevant component.

The QEMU emulator provides a number of system targets:

• ia32 (PC)
  • Little-endian
  • 32-bit
  • Hardware TLB
• amd64 (PC)
  • Little-endian
  • 64-bit
  • Hardware TLB
• MIPS (Malta board)
  • Endian switchable by running different emulators. On real hardware this is done when executing the kernel.
  • 32/64-bit
  • Software TLB

QEMU provides these targets and this should keep me going for a while anyway. Also, by showing how to do memory managment using a software MMU I'll get more experience as will the reader.

I also forgot to mention, that apart from being different hardware, they'll also provide interesting challenges regarding the booting environment.

After playing with Google AdSense and Amazon Affiliate code, I found that the size of the template was just wrong, so I've gone through and made it slightly wider. This allows for full size banners and more text in the width of the page, which I think is a bit nicer.

I also found that there were a few problems with IE6 (as per usual) so these have been fixed as far as I can possibly fix them.

Also, you'll note the styling on the tag cloud to the left, this is much nicer design-wise and also the line-height has been increased as IE6 (again) decided to render the text too close together.

Finally, I've added the Amazon e-store. This is a real pain as Amazon in their infinite wisdom only provide:

1. a direct link to the store on their site, or
2. a frameset to embed the store into your own site, or
3. an iframe (which is what I've used) to embed the store into you own site.

Now because of this, you have to either set the iframe to scroll if it gets too big or make the frame tall enough to handle lots of data. Why can't they provide an API so we can do what we want with it and not use a frame?

Finally, I fixed that damned date problem I was having way back when.

As you can probably tell, I've been playing with the Amazon Affiliation links and have found that:

• Most of them just don't fit on this site because their size.
• They're not customisable in regards to their size like I thought they might be.
• The optimised links don't seem to provide a close enough match to the content of the pages, oh well.
• Ths shop is too bloody wide for this site!
• It'd also be nice to customise the e-store links to a particular category or product as well.

So, all in all, I'm not that pleased with it so far, I expected so much more. Looks like I'm going to have to go back into the templates and modify them, which I hate doing.

I'll continue to look into it and see what I can find, maybe I can find some scripting API for it, that might be better.

I've just been reading an Ada blog and found a link to a number of programming tips which really should be adhered to by all programmers and managers should read it so they don't get on programmer's backs causing more stress.

Just posted on SlashDot.com is an article outlining the problems with teaching Java as a first language for CS students. I can relate to this as my uni decided to change from Ada95 to Java during the second year, this was interesting at the time, but Java had only just come out and I didn't know anything about the language at the time. I can now see it's problems. In retrospect I think my uni was just jumping on the Java bandwagon. In a way there was some foresight in this as there are now a lot of jobs in industry for Java programmers, mostly banking but even some real-time (I have no idea how well this works).

Let's face it:

1. You really should have programmed before doing a CS degree anyway, but these courses do actually go through the A-level CS stuff in the first year anyway.
2. Teaching Java is a bad idea as a first language as it doesn't touch on pointers and this is necessary for understanding the hardware (later courses will go into this).
3. Teaching C or C++ isn't a good idea either considering it teaches really bad programming habits that are hard to get out of later on. Yes, I was a C/C++ programmer before Ada.
4. If anyone is thinking about it, don't teach VB as a first language either, cos it's crap, half the time it works, type in the same program and it might just work the second time. This has been my experience!

In my CS course they tried to teach Haskell (a functional language) and PROLOG (logic) and they failed miserably. The guy teaching functional programming wasn't a lecturer, didn't like lecturing and lets face it was crap at it. He took a tape recorder into the lecture as back up just in case anyone complained about the course; which they did. The guy taking the PROLOG course was actually the head of department and was Italian, not the best English speaker in the world and didn't like teaching undergraduates. PROLOG isn't the easiest language to get to grips with, but if the lecturer can't speak English that well, he's got no chance.

Also that article mentions formal methods, they taught us discrete maths and Z, I got to the point where I could read Z (ish), but couldn't write a spec in it to save my life. Also, the formal methods used later were an extension of this but without the Z notation (just set theory really) and relating this to actual programming practice is difficult. Let's just say, I didn't really find it easy and subsequently never used it. In industry, it's unlikely students will ever use it either.

Now, unfortunately, having been out of programming for a few years after total burn out I can't say my maths is the best and I've no idea if I'll ever get back to where I was when I was at uni, so I can't say if I'll ever touch a functional language again or even formal methods. Oh well.

Conversations on #Ada keep coming back to operating systems and their kernels so I decided to dig out some code I wrote in 2000 and get it working again. I intended this code to be the basis of a microkernel written in Ada. The code presented here is a second attempt at using the latest version of GNAT (4.2.2) and binutils (2.18) as the first time I just couldn't get it working properly.

Unlike other OSes that have been written in Ada like MarteOS, RTEMS, AdaExpOS (a more full featured test kernel), I wanted to get it working using no Ada runtime, which is quite tricky. These other compilers seem to have a full runtime as they use the host's native port of the compiler and just add the -nostdlib flag when compiling. This isn't exactly the best way forward as you won't actually have this when targeting bare hardware.

Also, I didn't want to go the route of porting the Ada runtime to bare hardware - this is what other Ada OS developers do, which makes sense for specific targets, i.e. a robot in a manufacturing plant or a guided missile, but not for a general purpose OS.

It is possible to build GNAT so that there is no runtime installed. This is called the "Zero Foot Print" runtime which has to be configured from the system.ads package which needs to be modified. The configuration options that are in the private part of the system.ads package are documented in the targparm.ads package in the GNAT distribution.

Further to modifying the system package, we need to provide restrictions in the gnat.adc file. These restrictions are supplied using the Ada 2005 pragma Restrictions directive. There used to be pragma No_Run_Time but this is deprecated now, although I've heard it still works. So, even though the source provided is Ada95 it should be possible to compile it using an Ada95 compiler and using a different gnat.adc file.

The following commands will configure a basic compiler and other tools required.

Bash code
$ cd <to somewhere on disk>
$ mkdir -p build-binutils-2.18 build-gcc-4.2.2
$ tar -xjvpf binutils-2.18.bz2
$ tar -xjvpf gcc-core-4.2.2.bz2
$ tar -xjvpf gcc-ada-4.2.2.bz2
$ cd build-binutils-2.18
$ ../binutils-2.18/configure --prefix=$HOME/opt/cross-gcc \
    --target=i386-elf --host=x86_64-pc-linux \
    --build=x86_64-pc-linux --disable-nls \
    2>&1|tee config.log
$ make
$ make install
$ export PATH=$HOME/opt/cross-gcc/bin:$PATH
$ cd ../build-gcc-4.2.2
$ ../gcc-4.2.2/configure --prefix=$HOME/opt/cross-gcc \
    --target=i386-elf --host=x86_64-pc-linux \
    --build=x86_64-pc-linux --disable-nls \
    --enable-languages=c,ada --without-headers \
    2>&1|tee config.log
$ make all-gcc
$ make install-gcc

You may need to change your --host and --build options to reflect what your host machine is, you may not even need them. I've added them as Ubuntu doesn't define the platform properly.

Now you have the compiler and tools installed you can build my test kernel by downloading it from below and extracting it somewhere, just type the following:

Bash code
$ tar -xzvpf multiboot.tgz
$ cd multiboot
$ make qemu

As long as you have qemu installed somewhere, this will build a boot floppy and boot into GRUB. For some reason, it doesn't pick up the menu, so when booted type the following to get the menu:

GRUB commands
$ configfile /boot/grub/menu.lst

As it stands, I'm not sure that restricting the runtime to zero footprint is the right approach. I think that providing a very limited runtime is the best way forward. This way, the kernel developer has access to aggregates, 'Image attribute (useful for debugging) and other features. Obviously it makes no sense to allow tasking or even exceptions (as far as I can see).

Download multiboot.tgz

During my research of operating systems kernels, I got side tracked towards security mechanisms in operating systems and their kernels. Obviously, I'd heard of the usual 2:

1. Access Control Lists (ACL's), and
2. Capabilities.

ACL's are used in most OSes due to being easy to implement, and I had no idea how to implement capabilities, so I thought I'd try and research them. Seems they're incredibly hard to understand unless you're one of these research type people who spend their days writing in bizarre mathematical notation and dream in Z!

Whilst on IRC, I did go into the #erights channel on Freenode and talk to the guys there who did essentially say that an object-oriented OS is basically a capability OS. They were saying that by holding onto a capability, a process has the right to access whatever that capability points to.

Now, from what I understand, the kernels like EROS and Coyotos define a set of objects (like a class in OOP) that are defined in the kernel. Each of these objects have a bunch of capabilities associated with them, these capabilities are like the method calls of an OOP language so that other programs can call them. So, these capabilities are essentially syscalls into the kernel via Inter-Process Communication (IPC) mechanisms.

Another part of my research into other security mechanisms lead me to HiStar, which is a kernel based on Π-Calculus, no me neither! This stuff is even harder to understand than the capability papers, maybe I should try reading them for longer rather than skimming?

Persistence

Another area of capability based OSes is that they tend to use persistence. This it seems, is due to:

1. The capabilities being managed by the kernel, and
2. Not knowing what configuration capabilities should be in when the machine is rebooted.

So, how was the HURD going to do it using user-space capabilities?

Now, the idea of orthogonal persistence is a fine one:

• You don't have to worry about saving any documents, images, etc. whilst using the OS as the checkpointing mechanism will save your data at regular intervals, i.e. at, say every 5 mins, the system will take a snapshot of the current state of the OS and save this to disk.
• If somebody pulls out the mains cable by accident (or to turn on a hoover), you won't have lost everything you've been working on (you might have lost something between checkpoints though), so when you restart the machine, everything (mostly) will still be present in your session.

Persistence basically maps RAM onto disk. RAM is managed in page sized chunks (usually 4KB), so each page in RAM has a page on disk. When a program opens a file from disk, the OS will just memory map (mmap) the page from disk into RAM, now if the file is small (say, less than a page in size) and you also have quite a few small files open at any one time, you are essentially not utilising RAM efficiently.

Conclusion

1. Nobody knows how an OS based on capabilities is to present itself to the user as it's never really been done. Most capability based OSes are research projects and tend to get shelved when the research has completed and it hardly ever gets released to the public.
2. Most of it is research and can be found in (sometimes) hard to read papers.
3. Placing capabilities in the kernel seems to tie the filesystem to the kernel as well, this goes against the concept of a μ-kernel.
4. With persistence, small files (less than the page size) can cause memory to just be eaten up really quickly.

I've already set myself quite a task in using Ada as the implementation language for an OS kernel, so I think that rather than try to cram in all these extra features, I should concentrate on just getting a portable μ-kernel developed

Conversations in #Ada on IRC yesterday turned back to developing an OS in Ada, this has actually been a goal of mine for some time. I had written a demo hello world style kernel in Ada a few years ago, so I thought I'd try to recompile it using the newest version of FSF GNAT; this failed to build.

After looking through the manuals and finding pragma Restrictions, I stripped out all the other pragmas I had in there to reduce the runtime and tried it out using these pragma restrictions; all compiled ok and it even booted on QEMU!

So, I decided to try and put together a high level design document based on thoughts that I've had over the last 10 years or so, which outlines what I want in an OS. I may even get started on this thing!

Well, there were problems with my last web host, so I closed down that site and shifted everything over to a new host in the US. Hopefully, all will be fine here.

I changed the name as archangel-interactive.com was a bit unwieldy and hard to type and archangeli.co.uk was difficult to type as well. I wanted something shorter, after spending about a week looking for a word that hasn't been taken (the entire dictionary seems to have been registered by a bunch of morons expecting people to pay stupid amounts of cash!!), I found the term Archeia on Wikipedia which I found was a female Archangel, so fitted quite nicely with what I had already. Thing is, it seems that Archeia is a made up word and has never been used before some woman decided to make it up and use it, oh well.

Well, I've begun to look at the ANTLR source and the source I started writing for the Ada95 language target and I'm getting to the point where I'm seeing problems with the Java implementation again. This is just the basic stuff like the token definitions and the generation of the tokens in the string template group (STG) for the language. Ideally, I'd like the token types to be an enumeration so that we can have Ada coverage testing but other classes in the runtime use Token.EOF which in turn is actually the same thing as CharStream.EOF.

Also, the STG dumps out a constant called "Tokens" which is basically a count of all the tokens defined. When using this for Ada it's not quite right. This can be massaged to give the correct value, but in Ada it's unnecessary, as you can use 'Last attribute for any correctly defined type. I'm not sure if I can get rid of this for the target yet.

The channel numbers also seems odd, the default channel is given a number of 0 and the hidden channel is 99, why not 0 and 1? You'd think that channel 99 is the upper bound allowed, but no, any positive integer will do, this just seems like it's been plucked out of thin air without thinking about it. For example, say you have a whole bunch of channels and want to use a counter to step through them, you'd have to keep checking for 99 before you can skip over it, why not just set it to 1 or 0, at least then there is no checking needed!

In this tutorial I will take you through the steps of interfacing to C variables and functions. When creating bindings to libraries written in C from Ada a programmer really needs to know how to use the information contained within Appendix B of the Ada Reference Manual (ARM).

Binding variables

Firstly, I will show how to import a simple integer variable from C. Given the global variable declaration:

C code
/* A variable to import.
 */
int MyGlobal = 10;

The following Ada95 code can be used to bring it into the Ada program:

Ada95 code
  -- We want to link to the C MyGlobal variable here.
  My_Global : Interfaces.C.int;
  pragma Import(
    Convention    => C,
    Entity        => My_Global,
    External_Name => "MyGlobal");

I have used the named parameter passing mechanism so it's easier to see what's happening. We state that the linkage convention is C and the name we will give the integer in the Ada source is My_Global, we then provide the C name MyGlobal and the pragma binds the C name to the Ada name. We can then use the Ada name like this:

Ada95 code
  My_Global := 25;

Binding functions

Now following from this, we can extend this knowledge to importing a simple function from C:

C code
/* A function to import.
 */
int MyAdd(int a, int b)
    {
    return a + b;
    }

Again, using the same import pragma we can bring this function into the Ada program and make use of it:

Ada95 code
  -- We now want to import a function.
  function My_Add(A, B : Interfaces.C.int)
    return Interfaces.C.int;
  pragma Import(
    Convention    => C,
    Entity        => My_Add,
    External_Name => "MyAdd");

See how the C and Ada names differ? The pragma binds the 2 together so that they can be used in a program:

Ada95 code
  My_Global := My_Add(My_Global, 7);

Binding C strings

Strings in C are annoying as they can be viewed in a number of different ways. This also means that binding to them can be tricky. One way is to bind to a pointer to an array. So, for example say we have a function which returns a message string:

C code
/* A message to return to Ada.
 */
const char *Message = "This is a test string";

const char *MyString(void)
    {
    return Message;
    }

We want to import the MyString function into the Ada program. Ada provides access to pointers to char from the Interfaces.C.Strings package:

Ada95 code
  -- We have a function that returns a message in a string.
  function My_String return Interfaces.C.Strings.chars_ptr;
  pragma Import(
    Convention    => C,
    Entity        => My_String,
    External_Name => "MyString");

  -- This converts the char * array into an Ada String type.  
  Message : String := Interfaces.C.Strings.Value(My_String);

In the preceding code, we import as usual, but we use the chars_ptr type rather than the char_array type as we are passing a pointer and not a string from the stack. We can then transform this into an Ada String type by using the Value function.

Source code

I have placed a full example into an archive which can be built with GNAT using the following commands:

Bash code
$ tar -xzvpf importing_c.tgz
$ cd importing_c
$ make

Other Ada95 compilers will differ.

Download importing_c.tgz

Using the code from the interface types tutorial, we can now use the dot notation provided by Ada 2005. This allows the programmer to use the dot for tagged types which will be familiar from other programming languages like C++.

C++ code
class Dragster : public Vehicle, public Parachute {
    bool GearUp();
    // etc.
};

Dragster D;
bool     Result = D.GearUp();

The usual way of referencing a primitive for a tagged type is to either use the package that contains it or to reference it including the package's name:

Ada95 code
with Dragster;

procedure Test is

  D      : Dragster.Dragster_Type;
  Result : Boolean;

begin

  Result := Dragster.Gear_Up(D);
  
end Test;

So, we can transform our code to use the new notation and we still don't have to use the package!

Ada 2005 code
with Dragster;

procedure Test is

  D      : Dragster.Dragster_Type;
  Result : Boolean;

begin

  -- D is passed as the "Self" parameter to Gear_Up.
  Result := D.Gear_Up;
  
end Test;

I have placed a full example into a compressed text file which can be built with GNAT using the following commands:

Bash code
$ gunzip dot_notation.ada.gz
$ gnatchop -cw -gnat05 dot_notation.ada
$ gnatmake -gnat05 test.adb

Other Ada 2005 compilers will differ.

Download dot_notation.ada.gz

Carrying on from the abstract types tutorial, the natural progression is to add multiple inheritance. In Ada95 this cannot be done as the language doesn't supply any features for this - it is possible, however, but requires the use of generics.

In C++ this is easy enough as we can just add another interface (or class) to the list of classes to derive from:

C++ code
class Dragster : public Vehicle, public Parachute {
    bool GearUp();
    bool GearDown();
    void Accelerate();
    void Brake();
    void Deploy(); -- This has been added!
};

For this tutorial we must use the Ada 2005 language as this provides interface types similar to those provided in Java. The interface type is like the abstract type seen in the previous tutorial except that the use of multiple inheritance is allowed. So, in Ada 2005 we would define the Parachute type as:

Ada 2005 code
package Parachute is

  type Parachute_Type is interface;
  
  procedure Deploy(Self : in Parachute_Type) is abstract;
  
end Parachute;

Notice the use of the interface keyword, this is new as of Ada 2005. This package provides the specification of the Deploy operation and again, this is abstract. Interfaces can only have abstract primitives or null primitives (i.e. primitives that do not have to be implemented). We can then create a new Dragster type:

Ada 2005 code
with Vehicle;
with Parachute;

package Dragster is

  type Dragster_Type is new Vehicle.Vehicle_Type and
    Parachute.Parachute_Type with private;

  function Gear_Up(Self : Dragster_Type) return Boolean;
  function Gear_Down(Self : Dragster_Type) return Boolean;
  procedure Accelerate(Self : Dragster_Type);
  procedure Brake(Self : Dragster_Type);
  procedure Deploy(Self : in Dragster_Type);

private

  type Dragster_Type is new Vehicle.Vehicle_Type and
    Parachute.Parachute_Type with null record;
    
end Dragster;

Again, notice the difference in the way we define the type, the and keyword means that we are also deriving this type from the vehicle type and the parachute interface type. The Dragster type has to implement the Deploy primitive, which can then be used:

Ada 2005 code

procedure Test is

  -- Make sure we can accept pointers to all vehicles
  -- in this class.
  type Vehicle_Access is access all
    Vehicle.Vehicle_Type'Class;
  type Parachute_Access is access all
    Parachute.Parachute_Type'Class;

  A      : Vehicle_Access;
  -- Removed some code.
  D      : aliased Dragster.Dragster_Type;
  P      : Parachute_Access;
  Result : Boolean;

begin

  -- Removed some code.

  A      := Vehicle.Vehicle_Type(D)'Access;
  -- Call's Dragster.Gear_Up
  Result := Vehicle.Gear_Up(A.all);
  
  -- Use polymorphism on the Parachute type.
  P      := D'Access;

  Parachute.Deploy(P.all);
  
end Test;

I have placed a full example into a compressed text file which can be built with GNAT using the following commands:

Bash code
$ gunzip interface_types.ada.gz
$ gnatchop -cw -gnat05 interface_types.ada
$ gnatmake -gnat05 test.adb

Other Ada 2005 compilers will differ.

Download interface_types.ada.gz

This tutorial will show you what an abstract type is in Ada. I will also provide information on how the Ada type equates to the C++ class.

An abstract type provides the "specification" for a family of a user defined types. When this type is derived from, the programmer must specify the operations that are defined as abstract.

Say we have a simple vehicle which can change gears, accelerate and brake. We're not interested in knowing what speed we're going, just the basics. In C++ a Vehicle pure virtual class could be defined:

C++ code
class Vehicle {
    virtual bool GearUp() = 0;
    virtual bool GearDown() = 0;
    virtual void Accelerate() = 0;
    virtual void Brake() = 0;
};

This can then be derived from to create a number of concrete vehicles:

C++ code
class Car : public Vehicle {
    bool GearUp();
    bool GearDown();
    void Accelerate();
    void Brake();
};

bool Car::GearUp() {
    // Change the car's gears.
}

// etc.

class Van : public Vehicle {
    bool GearUp();
    bool GearDown();
    void Accelerate();
    void Brake();
};

bool Van::GearUp() {
    // Change the van's gears.
}

// etc.

class Scooter : public Vehicle {
    bool GearUp();
    bool GearDown();
    void Accelerate();
    void Brake();
};

bool Scooter::GearUp() {
    // Change the scooter's gears.
}

// etc.

Now, in Ada95 we use an abstract tagged type to implement the Vehicle type:

Ada95 code
package Vehicle is
  
  type Vehicle_Type is abstract tagged private;

  function Gear_Up(
    Self : Vehicle_Type) return Boolean is abstract;
  function Gear_Down(
    Self : Vehicle_Type) return Boolean is abstract;
  procedure Accelerate(Self : Vehicle_Type) is abstract;
  procedure Brake(Self : Vehicle_Type) is abstract;

private

  type Vehicle_Type is abstract tagged null record;

end Vehicle;

Notice how the package has no body, it is a specification only and all operations are abstract, which means that any types which derive from this one must provide implementations of all the primitive operations.

Again, this can then be derived from to create a number of concrete vehicles:

Ada95 code
with Vehicle;

package Car is
  
  type Car_Type is new Vehicle.Vehicle_Type with private;

  function Gear_Up(Self : Car_Type) return Boolean;
  function Gear_Down(Self : Car_Type) return Boolean;
  procedure Accelerate(Self : Car_Type);
  procedure Brake(Self : Car_Type);

private

  type Car_Type is new Vehicle.Vehicle_Type with
    null record;

end Car;

package body Car is
  
  function Gear_Up(Self : Car_Type) return Boolean is

  begin

    -- Change the car's gears.

  end Gear_Up;

  -- Etc.

end Car;

with Vehicle;

package Van is
  
  type Van_Type is new Vehicle.Vehicle_Type with private;

  function Gear_Up(Self : Van_Type) return Boolean;
  function Gear_Down(Self : Van_Type) return Boolean;
  procedure Accelerate(Self : Van_Type);
  procedure Brake(Self : Van_Type);

private

  type Van_Type is new Vehicle.Vehicle_Type with
    null record;

end Van;

package body Van is
  
  function Gear_Up(Self : Van_Type) return Boolean is

  begin

    -- Change the van's gears.

  end Gear_Up;

  -- Etc.

end Van;

with Vehicle;

package Scooter is
  
  type Scooter_Type is new Vehicle.Vehicle_Type with
    private;

  function Gear_Up(Self : Scooter_Type) return Boolean;
  function Gear_Down(Self : Scooter_Type) return Boolean;
  procedure Accelerate(Self : Scooter_Type);
  procedure Brake(Self : Scooter_Type);

private

  type Scooter_Type is new Vehicle.Vehicle_Type with
    null record;

end Scooter;

package body Scooter is
  
  function Gear_Up(Self : Scooter_Type) return Boolean is

  begin

    -- Change the scooter's gears.

  end Gear_Up;

  -- Etc.

end Scooter;

So, where ever a pointer to a Vehicle type is used it is possible to assign either Car, Van or Scooter instance to that variable:

Ada95 code
with Vehicle;
with Car;
with Scooter;
with Van;

procedure Test is

  -- Make sure we can accept pointers to all vehicles
  -- in this class.
  type Vehicle_Access is access all
    Vehicle.Vehicle_Type'Class;

  A      : Vehicle_Access;
  C      : aliased Car.Car_Type;
  S      : aliased Scooter.Scooter_Type;
  V      : aliased Van.Van_Type;
  Result : Boolean;

begin

  -- Call's Car.Gear_Up
  A      := C'Access;
  Result := Vehicle.Gear_Up(A.all);

  -- Call's Scooter.Gear_Up
  A      := S'Access;
  Result := Vehicle.Gear_Up(A.all);

  -- Call's Van.Gear_Up
  A      := V'Access;
  Result := Vehicle.Gear_Up(A.all);

end Test;

I have placed a full example into a compressed text file which can be built with GNAT using the following commands:

Bash code
$ gunzip abstract_types.ada.gz
$ gnatchop -cw abstract_types.ada
$ gnatmake test.adb

Other Ada95 compilers will differ.

Download abstract_types.ada.gz

wxWidets was a piece of software I was using at work, I liked it so much that it made it's way into my home projects.

As I was using wxWidgets a lot, I was getting rather annoyed with C++. I wanted to go back to developing more in Ada but there wasn't any decent GUI toolkits. So, I decided to try and create an Ada95 binding to wxWidgets.

This didn't exactly work out as the strong typing that Ada enforces was causing problems with the class hierarchy I was trying to replicate from C++ into Ada. This caused me to stall, which in turn caused the demise of the project.

I then started to look at a native Ada95 GUI toolkit using design patterns but the cyclic dependency problem in Ada bit me, so this has also ceased for now. I haven't decided what I'll do about this project just yet.

I placed the wxAda source code in it's entirety into a Tigris repository so that anybody with an interest in carrying on the project can do so.

Whilst working for a games company I ported one of their games to the Dreamcast without the use of an official development kit (which was called Dolphin/Katana), I used the freely available tools.

The game was very slow due to the fact that it was all done in 2D, there was no 3D interface for the game and it would've been particularly difficult to bolt something like that into an existing game. I then dabbled with the free tools in my own time, but not much came of that.

I put up documentation detailing the Sega Dreamcast onto GeoCities.

Back in 1995, AROS was just starting out and needed programmers to work for them. I joined the development mail list and ended up reverse engineering a few command line tools. I actually wrote more than I submitted but due to time constraints they didn't all get submitted and the source has since been lost (since I no longer have any Amiga's). AROS is still going and is a very active project.