Planet Ada

Ada in Denmark: Concurrent Ada Programming

Thu, 17 May 2012 17:36:09 +0000

I wrote a short article about concurrent Ada programming, and a mere handful of minutes after I put it online a reader had found a bug in it.

You gotta love the interwebz!

It’s definitely an article for beginners, and I do plan on adding it to the Ada-DK Wiki as soon as possible. Feel free to let me know what you think about it, and don’t hold back on suggestions for improvements.

Ada in Denmark: AdaIC Survey

Thu, 17 May 2012 16:12:49 +0000

The adaic.org website is one of the better online Ada resources, and with the latest survey they’ve put up, it seems they are aiming even higher. We got this from Randy Brukardt:

As part of our ongoing efforts to improve the AdaIC website, we’re conducting a short survey of Ada users to guide possible improvements to the site. Find the survey at:

http://www.adaic.org/survey/

Thanks in advance for your time.

Randy Brukardt, (former) AdaIC webmaster

P.S. You’ll need to have Javascript enabled to access the survey, as I found out when I tried it.

Personally I’d like to see some more code on the website, and a tight integration with Google+.

Ada in Denmark: Ada Industrial Control Widget Library v1.3 Released

Thu, 17 May 2012 16:08:37 +0000

The Ada Industrial Control Widget library provide high-quality industrial control widgets for Ada applications. Version 1.3 is a bug-fix release with no new features:

A sample of asynchronous plotting added, based on the contribution by Yogeshwarsing Calleecharan, who generously provided his code solving a differential equation of a generator’s rotor movement. The sample illustrates ploting data on-line, as they are computed by a separate Ada task.
Memory leak while drawing graph paper annotations fixed.
Graph paper annotations formatting flag to enable or disable superscript numbers.

You can read the release announcement here and get to the code here. Fedora and Debian packages are available and source for the rest of us.

Ada in Denmark: GtkAda Contributions v2.13 Released

Thu, 17 May 2012 15:04:16 +0000

Just a small fix compared to version 2.12:

The procedure Send of Generic_Message has now the Timeout parameter to break possible deadlocks when messages are posted upon application completion.

Read the release announcement here and get the code here. Fedora and Debian packages are available and source for the rest of us.

Ada in Denmark: Ada Server Faces 0.4.0 Released

Thu, 17 May 2012 14:51:12 +0000

Ada Server Faces is moving ahead at a steady pace with the latest 0.4.0 release. It is, as you might remember from earlier Ada-DK posts about it, a framework for making web-applications using the same methodology as Java Server Faces:

Ada Server Faces allows to create web applications using the same pattern a the Java Server Faces (See JSR 252, JSR 314 or JSR 344).

ASF provides a security framework which allows to protect web pages according to some security policy. This framework allows users to authenticate by using OpenID Authentication 2.0.

You can get the latest version here or you can grab the dev version from the SVN repository:

svn checkout http://ada-asf.googlecode.com/svn/trunk/ ada-asf-read-only

New in version 0.4.0 is:

Support for shared or static build configuration.
Support for file upload.
New components , , , .
New EL function util:hasMessage.
ASF now Implements the JSF phase events and phase listeners.
Implements the JSF/Ruby on Rails flash context.
Adds the pre-defined JSF beans: initParam, flash.
Support for locales and honors the Accept-Language.
New demos are available in French and English

There’s a live online demo available. You can read the full release announcement here.

Ada in Denmark: Ada Database Objects 0.3.0 Released

Thu, 17 May 2012 14:36:03 +0000

Ada Database Objects is a library that facilitates access to MySQL and SQLite databases and the mapping of database objects into Ada records, AKA an ORM.

New in this version is:

Support to update database records when a field is really modified.
Customization of the SQLite database connection by using SQLite PRAGMAs.
Escape of MySQL or SQLite reserved keywords.
Support for blob type.

You can get to the code here, or you can grab the latest dev version from SVN:

svn checkout http://ada-ado.googlecode.com/svn/trunk/ ada-ado-read-only

The full release announcement can be read here.

Ada in Denmark: Abusing Operator Overloading for Fun and Profit

Thu, 17 May 2012 14:21:48 +0000

You know there’s a good chance of a programming article being interesting/fun if it starts out like this:

“Preserve the conventional meaning of overloaded operators” — Ada Quality & Style, Overloaded Operators

Mmmmm, bite me.

And he means it! The Worried Programmer goes on to write an excellent piece on how to abusively overload operators. The article is full of great examples, like this one:

procedure Impsel is
   Which : Boolean := True;
   Letter_Choice : Natural := 2;
 
begin
   Put_Line(("This here" or "That there") and Which); -- "That there"
 
   Put_Line(("A" or "B" or "C") and Letter_Choice);  -- "C" (0-based indexing)
 
   Put_Line(("A" or "B" or "C") and False);   -- Constraint_Error!
end Impsel;

Yes, really. The section of the article containing the above marvel was rightly dubbed “Losing Myself” by the author. It might not be pretty, or very Ada-like, but it sure as heck is fun!

Be sure to read the Abusing Operator Overloading for Fun and Profit article. Don’t miss out on this one!

Thomas Løcke: Concurrent Ada Programming

Thu, 17 May 2012 13:36:32 +0000

Ada’s model for doing concurrent programming is absolutely marvelous, and today I’m going to give you a small taste of it. More or less all programming languages provide tools for concurrent programming, but few do it as elegant as Ada, where the whole concept has been build into the language from it’s inception in 1983.

In Ada concurrent programming is a first class citizen, not an afterthought, and in this day and age where even the cheapest of processors have multiple cores, being able to properly harness the power of those many cores is important. A lot of programs could benefit from a bit of concurrent magic, but since concurrent programming brings with it a whole new set of problems, many programmers shy away from it. Not so with Ada programmers. We have tasks, protected objects, scheduling, guards and entries right there in front of us. In this article I’m going to show you how tasks and protected objects can be used to add concurrency to a very simple program.

The first thing we’re going to do is setup a small program that solves the plain problem of counting 20 times to 1_000_000_000.

One possible Ada solution to this problem is this:

with Ada.Task_Identification;
with Ada.Text_IO;
 
procedure Sequential
is
   use Ada.Task_Identification;
   use Ada.Text_IO;
 
   Id   : constant String := Image (Current_Task);
   Jobs : Positive := 20;
begin
   for Job in reverse 1 .. Jobs loop
      for K in 1 .. 1_000_000_000 loop
	 null; --  This is really hard!
      end loop;
 
      Put_Line ("Job" & Positive'Image (Job) & " done by " & Id);
   end loop;
end Sequential;

Before we get into actually compiling and running Sequential, allow me to first explain what’s going on in the program.

First we with the two packages Ada.Task_Identification and Ada.Text_IO. What this does is make the subprograms and types from those packages visible and available to our program, somewhat analogous to the #include directive used in C. After that we setup our “main” procedure and name it Sequential. In Ada you can call your main procedure whatever you like. The use clauses we encounter next lets us access the tools of the Ada.Text_IO and Ada.Task_Identification packages without having to prefix every type and subprogram with the package name. This is equivalent to the using namespace statement in C++.

The Ada.Task_Identification package makes it possible for us to figure out the id of a running task and Ada.Text_IO makes the Put_Line procedure available to Sequential.

We declare and initialize two objects in the declarative part of the program (between is and begin): Id and Jobs. The Id constant contains a String representation of the environment task identifier. As our program only have one running task (or thread if you will), which is the main environment task, the output done in the Put_Line line will show the same Id for every job completed.

The Jobs variable is the queue of jobs, in our case 20. Note that the Positive type is actually a subtype of Integer with the range 1 .. Integer'Last. If you try to assign a value below 1 or above Integer'Last then the program will raise a Constraint_Error exception.

After the begin keyword we’re in the actual body of the program, and the first thing we do is setup a for loop that’ll count down from 20 to 1, as indicated by the reverse keyword and the given range of 1 .. Jobs.

Inside this loop we do the actual work: Counting to 1_000_000_000 for each job and then outputting a line of text indicating whenever a job has been completed and by which task id.

And that’s it.

In order to compile the program do:

gnatmake sequential.adb

And then to execute and time:

time sequential

My laptop yields the following when executed and timed:

thomas@t420:~/Ada/Simple_Tasking time sequential
Job 20 done by main_task_000000000064A010
Job 19 done by main_task_000000000064A010
Job 18 done by main_task_000000000064A010
Job 17 done by main_task_000000000064A010
Job 16 done by main_task_000000000064A010
Job 15 done by main_task_000000000064A010
Job 14 done by main_task_000000000064A010
Job 13 done by main_task_000000000064A010
Job 12 done by main_task_000000000064A010
Job 11 done by main_task_000000000064A010
Job 10 done by main_task_000000000064A010
Job 9 done by main_task_000000000064A010
Job 8 done by main_task_000000000064A010
Job 7 done by main_task_000000000064A010
Job 6 done by main_task_000000000064A010
Job 5 done by main_task_000000000064A010
Job 4 done by main_task_000000000064A010
Job 3 done by main_task_000000000064A010
Job 2 done by main_task_000000000064A010
Job 1 done by main_task_000000000064A010

real    0m52.737s
user    0m52.636s
sys     0m0.001s

As you can see it took a good 52 seconds to finish all 20 jobs. At no point during the execution of the program did the system utilize more than one CPU core. Each job was completed in an absolute sequential manner, starting with job 20 and ending with 1.

Surely this is sad, considering my laptop is equipped with a CPU sporting a whooping four cores. Lets add some tasking magic to the program and see how much faster we can make it go.

with Ada.Task_Identification;
With Ada.Text_IO;
 
procedure Concurrent
is
   use Ada.Task_Identification;
   use Ada.Text_IO;
 
   protected Jobs is
      procedure Get 
	(Job : out Natural);
   private
      J : Natural := 20;
   end Jobs;
 
   ------------
   --  Jobs  --
   ------------
 
   protected body Jobs is
      -----------
      --  Get  --
      -----------
 
      procedure Get 
	(Job : out Natural)
      is
      begin
	 Job := J;
         if J > 0 then
            J := J - 1;
         end if;
      end Get;
   end Jobs;
 
   task type Worker;
   --  The Worker gets a job, and does the hard work.
   --  When there are no more jobs, the Worker exits.
 
   --------------
   --  Worker  --
   --------------
 
   task body Worker is
      A_Job : Natural;
      Id    : constant String := Image (Current_Task);
   begin
      loop
	 Jobs.Get (A_Job);
 
	 exit when A_Job < 1; 
 
	 for K in 1 .. 1_000_000_000 loop
	    null; --  This is really hard!
	 end loop;
 
	 Put_Line ("Job" & Natural'Image (A_Job) & " done by " & Id);
      end loop;
   end Worker;
 
   Workers : array (1 .. 4) of Worker;
begin
   null; --  We're not using the main environment task for anything.
end Concurrent;

Let’s dive in!

We with and use the same packages as before, but after that there are quite a few new things, first of which is a protected object. In Ada these are objects that export procedures, functions and entries that enables us to interact with the encapsulated data structure. In our case we’ve setup a protected object called Jobs, but we could just as well have created a protected type and then declared one of more objects to be of that type.

We can only operate on the data structure of a protected object via the exported subprograms and this is done under automatic mutual exclusion. A protected object will allow many concurrent readers (via exported functions), but only one writer (via exported procedures and entries).

A protected object is just what we need to protect our job queue from race conditions, now that we have several tasks querying and updating it.

   protected Jobs is
      procedure Get 
	(Job : out Natural);
   private
      J : Natural := 20;
   end Jobs;
 
   ------------
   --  Jobs  --
   ------------
 
   protected body Jobs is
      -----------
      --  Get  --
      -----------
 
      procedure Get 
	(Job : out Natural)
      is
      begin
	 Job := J;
         if J > 0 then
            J := J - 1;
         end if;
      end Get;
   end Jobs;

First we declare our Jobs protected object. We export the sole Get (Job : out Natural) procedure, which is the only way for us to interact with the very simple data structure, consisting only of the variable J.

In the body of Jobs we find the actual implementation of the Get procedure. All it does is put the current value of J into the Job parameter and then decrease the value of J by one. With this simple system in place we’re ensured that access to J is only ever granted to one single task at the same time. Only when that task is done is the next one allowed access.

With a secure job queue in place we move on to creating the tasks that will be doing the actual work:

   task type Worker;
   --  The Worker gets a job, and does the hard work.
   --  When there are no more jobs, the Worker exits.
 
   --------------
   --  Worker  --
   --------------
 
   task body Worker is
      A_Job : Natural;
      Id    : constant String := Image (Current_Task);
   begin
      loop
	 Jobs.Get (A_Job);
 
	 exit when A_Job < 1; 
 
	 for K in 1 .. 1_000_000_000 loop
	    null; --  This is really hard!
	 end loop;
 
	 Put_Line ("Job" & Natural'Image (A_Job) & " done by " & Id);
      end loop;
   end Worker;

First we declare a task type called Worker. We could’ve setup a task object, just as we did with the Jobs protected object, but since we want more than one worker a type is the way to go. The body of the task looks a lot like the body from the Sequential program, with a few minor differences. We declare the A_Job variable to be of the type Natural, which is a subtype of Integer with the range 0 .. Integer'Last. The Id constant is exactly like the one from the first program.

In the body of the Worker task we’ve got a plain loop that starts out with putting a job into the A_Job variable. We then check if the job is valid in the exit when... line and if not we exit the loop and the task is then completed.

The for loop and the Put_Line code is more or less the same as before.

Last we have this:

   Workers : array (1 .. 4) of Worker;
begin
   null; --  We're not using the main environment task for anything.
end Concurrent;

Here we declare an array of 4 Worker tasks. As soon as the program reach this spot, four workers are created and when we pass begin they spring to life. Since we already have 4 workers counting to 1_000_000_000 like there’s no tomorrow, we don’t really need to add any code to the main environment task, so we simply add a null statement. The main environment task is the master of the 4 workers, so it wont complete until all 4 workers have completed.

Lets see how the program performs now:

thomas@t420:~/Ada/Simple_Tasking$ time concurrent
Job 20 done by workers(4)_000000000065FCC0
Job 19 done by workers(2)_0000000000659240
Job 18 done by workers(3)_000000000065C780
Job 17 done by workers(1)_0000000000655D00
Job 16 done by workers(4)_000000000065FCC0
Job 15 done by workers(2)_0000000000659240
Job 13 done by workers(1)_0000000000655D00
Job 14 done by workers(3)_000000000065C780
Job 12 done by workers(4)_000000000065FCC0
Job 10 done by workers(1)_0000000000655D00
Job 11 done by workers(2)_0000000000659240
Job 9 done by workers(3)_000000000065C780
Job 6 done by workers(2)_0000000000659240
Job 8 done by workers(4)_000000000065FCC0
Job 7 done by workers(1)_0000000000655D00
Job 5 done by workers(3)_000000000065C780
Job 4 done by workers(2)_0000000000659240
Job 3 done by workers(4)_000000000065FCC0
Job 1 done by workers(3)_000000000065C780
Job 2 done by workers(1)_0000000000655D00

real    0m18.727s
user    1m11.454s
sys     0m0.025s

YAY! It is much faster now, and all four cores on my CPU is running at 100% while the program executes. Also note how the jobs are no longer completed sequentially. You can experiment with the amount of workers by changing the size of the Workers array. On my box the sweet spot is firing up 20 workers at the same time. With twenty workers I’m very close to a clean 18 seconds. The second fastes result is obtained with 4 workers. Every other amount of workers I’ve tried is slower.

There’s of course a whole lot more to Ada and concurrent programming than shown here. This little example has barely scratched the surface. A good place to start is the Ada Programming Wikibook.

You can grab the code for these examples at github.com/ThomasLocke/Simple_Tasking.

Adding concurrency to an Ada program is very simple, and the model for doing it is both easy to understand and to work with. When you’re using Ada there’s simply no excuse for not adding concurrency to your program where it will benefit from it.

Ada in Denmark: Spawning Processes From Ada Using The Ada Spawn Manager

Thu, 10 May 2012 08:02:18 +0000

The codelabs.ch project is steadily growing their collection of nice Ada projects, the latest being the Ada Spawn Manager:

The Ada spawn manager implements the concept described in the GNAT GPL package System.OS_Lib. It is used to solve the problem of spawning processes at arbitrary times from multitasking Ada programs:

If the parent is using tasking, and needs to spawn subprocesses at arbitrary times, one technique is for the parent to spawn (very early) a particular spawn-manager subprocess whose job is to spawn other processes. The spawn-manager avoids tasking. The parent sends messages to the spawn-manager requesting it to spawn processes, using whatever inter-process communication mechanism you like, such as sockets.

SYSTEM.OS_LIB specification
— GNAT COMPILER COMPONENTS

The Ada spawn manager uses UNIX domain sockets provided by the Anet library to implement fast and simple IPC.

Fun!

Currently there’s no official release version, but you can git clone the development version:

git clone http://git.codelabs.ch/git/spawn-manager.git

I wonder how this compares to spawning processes using the Florist POSIX package found at libre.adacore.com?

Ada in Denmark: Stephane Carrez Releases Ada Utility Library 1.5.0

Thu, 10 May 2012 07:50:16 +0000

It’s been a while since I’ve posted anything from Stephane Carrez’ excellent Java2Ada blog, but today that drought is ended with the release of Stephane’s Ada Utility Library v1.5.0. As the name implies the library provides a bunch of Ada utilities, chief among those being concurrent fifo queues and arrays, process creation/spawning and SHA1/HMAC encoding. There’s lots more in there, so be sure to check it out.

You can read the full release announcement here or you could simply svn clone it and get to the goodies immediately:

svn checkout http://ada-util.googlecode.com/svn/trunk/ ada-util-read-only

What I’d really like to see in this package is a standalone implementation of Stephane’s OpenID stuff. I’ve got a project that needs OpenID, and it would be really nice to be able to do “with Util.OpenID” and then make it fly. One can dream!

Ada in Denmark: Another Round of Dmitry Kazakov Updates

Thu, 10 May 2012 07:26:04 +0000

The productivity of Dmitry Kazakov continues to amaze me. Not only is he producing some rather large libraries and projects, he is also very actively updating and maintaining them.

I could probably learn a lot from this guy.

Today we’ve got updates to the following projects:

Simple components for Ada v3.16:

Changes in version 3.16 (and 3.15, since I forgot to report those):

Bug fix in the package Storage_Streams. The bug was caused by an overflow in index computations.
Parsers now have a mechanism to disallow an operation outside brackets.
Closing brackets can be returned back when misplaced switching to infix context. For example, it is now possible to parse expressions like f(|a|+1|x), where | is both |·|-brackets and an infix operation.
Association checks are performed on all operations and brackets.

Simple components provides…

…implementations of smart pointers, directed graphs, sets, maps, stacks, tables, string editing, unbounded arrays, expression analyzers, lock-free data structures, synchronization primitives (events, race condition free pulse events, arrays of events, reentrant mutexes, deadlock-free arrays of mutexes), pseudo-random non-repeating numbers, symmetric encoding and decoding, IEEE 754 representations support. Tables management and strings editing are described in separate documents see Tables and Strings edit. The library is kept conform to both Ada 95 and Ada 2005 language standards.

The next contender is the Ada industrial widget library v1.2:

Changes to the previous version:

Bug fix in waveform sampling which had the effect that sometimes the amplifier get permanently rescaled when in auto-scale mode.
Rendering waveform annotations was changed to prevent values shown as xxx*10**0.

The key features of the Ada industrial widget library are..

…widgets composed of transparent layers drawn by cairo, fully scalable graphics, support of time controlled refresh policy for real-time and heavy-duty applications, caching graphical operations, stream I/O support for serialization and deserialization, ready-to-use gauge, meter, oscilloscope widgets, editor widget for WYSIWYG design of complex dashboards.

Go get ‘em while they are hot!

Ada in Denmark: Some Fast Ada Programming News

Sat, 05 May 2012 19:40:43 +0000

First lets start with the fact that it just got easier to build Ada packages for Debian. YAY!

Second it’s great to know that the Ada networking library, Anet, just hit version 0.1 – Get it while it’s hot.

Third you’ll be thrilled to know that the What would you like in Ada 202X? thread on comp.lang.ada has gone berserk! Fun read, if you have the time.

Fourth we get ZanyBlue, which is a project implementing a finite element based solution of the Maxwell field equations. En route to that goal, supporting libraries and applications are being implemented. Initial functionality covers localization support for Ada. ZanyBlue is now at version 1.0.0 BETA. Here’s the release announcement.

Finally Stephe Leake did the entire Ada 2005, 2012 (draft 17) reference manual in info format. Pretty awesome, if you ask me.

DragonLace: Fortran and ObjC for GnatDroid

Sat, 05 May 2012 08:35:31 +0000

GnatDroid on FreeBSD has been updated build from GCC 4.6.3 on both ARMv5 and ARMv7. Now that the FreeBSD GNAT-AUX port is modular, the GnatDroid ports should automatically upgrade with GNAT-AUX is upgraded.

gnatdroid-armv5 20120301
gnatdroid-armv7 20120301

GnatDroid now supports Fortran and Objective-C as another benefit of the port modularity. These additional languages are not built by default, but they are easily activated when building GnatDroid from source. An option configuration screen will appear after "make" command allowing GnatDroid to support one or both of these extra languages. The screen can be forced to appear later with the "make config" command.

C++ is not yet supported as it is in GNAT-AUX. There is a build error on this language that needs to be examined in depth before C++ support can be added.

Ada in Denmark: The May 2012 Open Ada-DK Meeting

Fri, 04 May 2012 08:17:01 +0000

May 8th. 2012 from 1730 -> ? marks the day and time when the eighteenth open Ada-DK meeting is being held.

The “open” part means that the meeting is not a members-only affair, but that anybody interested in Ada is welcome, so feel free to invite whomever you might believe could be interested in spending an evening talking about Ada programming.

If you’re interested in participating, feel free to send us an email and we’ll inform you of the when and where. You can also ping me at Google+, identi.ca/thomaslocke or join the Freenode IRC #ada channel and look for ThomasLocke.

The meeting is of course free.

Ada in Denmark: The Jeffrey R. Carter SIGAda Papers Freely Available

Fri, 20 Apr 2012 06:46:43 +0000

The other day Jeffrey R. Carter announced that all his SIGAda papers had been made available for free.

YAY!

You can now get instant access to such classics as:

And more!

These are some golden oldies – be sure not to miss them. There’s some valuable Ada programming gold in that stash.

Ada in Denmark: Ada on Slackware64

Fri, 20 Apr 2012 06:32:05 +0000

At Z’s space (the blog of Zhu Qun-Ying) you can find a post about building an Ada environment on Slackware64. It comes complete with a bunch of slackbuild scripts and some precompiled Slackware packages. Awesome!

I haven’t tried the packages myself, since I just download the stuff I need straight from libre.adacore.com, but there are obvious advantages to having the software packaged as a standard Slackware packages, so I might give ‘em a whirl in the future.

If you’re interested in seeing how the default libre.adacore.com packages are installed on a Slackware64 box, then feel free to take a look at the 5 videos I did on the subject a while ago: Ada on Slackware.

No matter which path you choose, it’s great to know that Ada programming on Slackware is as easy as it gets. A big “Thank you Zhu Qun-Ying!” for making it even simpler.

Ada in Denmark: Fuzzy Machine Learning Framework v1.0

Fri, 13 Apr 2012 14:31:42 +0000

Shortly after I’d posted yesterday’s A Slew of Dmitry Kazakov Updates news, a release announcement for version 1.0 of his Fuzzy Machine Learning Framework program was made to comp.lang.ada. The Fuzzy Machine Learning Framework allows us to operate uncertain and contradictory data in a unified, certain and feasible way. I’m sure you know that I did not come up with that last sentence. I found it on the website for the project, where this quote is also from:

Based on the intuitionistic fuzzy sets and the possibility theory. Fuzzy approach is fully utilized by using intuitionistic sets extended to represent not only uncertain, but also contradictory data within same framework. Consequently the results of the possibility theory are generalized for the case of contradictory data. Same as with the shades of uncertainty we introduce the shades of contradiction from feasible to infeasible. This allows us to operate uncertain and contradictory data in a unified, certain and feasible way.

Fuzzy features. All the data the system operates on are considered fuzzy. For this a notion of fuzzy feature is introduced as a generalization of crisp features known in classical machine learning. Similar to statistical pattern recognition, a feature is a measurable function with the possibility used as the measure. Both the features and the things viewed through features are consistently supposed fuzzy. By these two ways uncertainty comes into play. It might be a crisp thing described in vague terms, like a number being big or small. Or it can be a precise description of something uncertain, like a temperature said to be n degrees. There could be a mixture of both.

I gotta admit that most of that text is quite a bit above my pay grade, but I’m sure that if you have a need for fuzzy machine learning, then you probably “get” exactly what he’s talking about. You can read the full release announcement here.

Ada in Denmark: Buffers Galore! Now in Version 1.2

Thu, 12 Apr 2012 09:10:51 +0000

Dequesterity is a set of Ada 2005 generics that provide various forms of general purpose buffer containers. There are currently 75 (yes, seventy-five) buffer types in Dequesterity, so if you’re in the market for a buffer, chances are high that you’ll find what you need here.

Dequesterity is a set of Ada 2005 generics that provide various forms of general purpose buffer containers. Buffers may be used as deques, queues, ring buffers, stacks, double ended stacks, vectors, and similar abstractions.

The generics are combinable and pluggable such that lower level buffer implementations may be combined with higher level buffer generics to create a wide selection of buffer types with specific sets of functionality.

Lower level buffer implementations include bounded and unbounded buffer forms. Higher level buffer implementations add concurrency support, and streaming capabilities. Buffer instances may be streamed, or may be accessed remotely using the Distributed Systems Annex. Most buffers can store their state persistently. Some buffer implementations operate entirely on secondary (file based) storage. The buffers may be instantiated with user defined types, and indefinite buffer forms also exist.

The interface to the buffers is modelled after the Ada 2005 container library.

New in release 1.2 is:

Saving/Loading buffers from files, and Persistent Buffers were not working under Linux. The low level Preelaborated IO had some portability issues in the area of determining the size of a file. The Linux test executable, test_buffers now works as it should.
Prelaborated_IO Size now returns a long integer instead of Integer. (Which would be 64 bits on 64 bit OS’s) This allows buffers to work with much larger files, if buffer content is to be stored persistently.
Only one project file needed for an executable, that builds for both Windows and Linux.
Cleaned up compiler warnings.
Created a Buffer Demo executable, which is stripped down to demonstrate some buffer concepts.
Ravenscar example exits after 30 seconds, instead of executing indefinitely.
Persistent Stream Buffers do not need to be instantiated, similar to the other Stream Buffer types.
Fixed bug in Unbounded Buffer, if vector to read into is a zero element array, the Read routine does not generate a constraint error.
Fixed bug in indefinite Unbounded buffers. When finalizing the buffer if the internal buffer is null, don’t attempt to dereference the null value.

You can read the full release announcement from Brad Moore here.

Ada in Denmark: A Slew of Dmitry Kazakov Updates

Thu, 12 Apr 2012 08:54:17 +0000

Dmitry Kazakov refreshed a bunch of his Ada packages a few days ago:

If Ada programming is your game, then there’s a good chance you’ll find one or more of Dmitry’s Ada packages beneficial, so be sure to check them out.

Ada in Denmark: VTKAda 5.10, QtAda 4.8.1 Released

Thu, 12 Apr 2012 08:41:02 +0000

Today Leonid Dulman (PDF) announced the release of VTKAda 5.10 and QtAda 4.8.1:

VTKAda is an Ada-2012 port of VTK (Visualization Toolkit by Kitware, Inc) and Qt4 application and UI framework by Nokia ParaView 3.14.0 (VTK version 5.10.0), Qt version 4.8.1 open source and qt4c.dll(libqt4c.so) were build with Microsoft Visual Studio 2010 for Windows and gcc for Linux x86. Packages has been tested with gnat gpl 2011 ada compiler (-gnat12 option) for Windows XP Sp3 32bit, Windows 7 Sp1 64bit and Debian 5 x86.

VTKAda is powerful 2D/3D rendering and imaging system that works inside a Qt4 application.

You can read the full release announcement here.

Ada in Denmark: Trimming cost and size: The software side of the story

Wed, 04 Apr 2012 10:34:42 +0000

In his Trimming cost and size: The software side of the story article Benjamin Brosgol from AdaCore delves into the subject matter with his usual gusto. If you’ve done any kind of software development, you’ll know that the cheapest bugs to fix are those found before the product is launched and this even more so for embedded software, where it can be a real pain to update the devices. Brosgol does a good job of describing these issues:

For several reasons, buggy software is especially acute in embedded applications. First, an embedded system typically monitors or controls some external device, so in critical applications an error or vulnerability could compromise safety, security or both; lives could be lost, and substantial assets could be at risk.

Second, debugging embedded software is harder than debugging native software. For example, embedded systems generally involve concurrency and real-time constraints, which introduce opportunities for errors such as deadlock, missed deadlines and corrupted data. Because some of these bugs are timing dependent and not easily reproduced, they could go undetected until the software is fielded. With perhaps thousands or even millions of systems in use, even a bug with low probability of being triggered will occur eventually.

Third, correcting a defect in an embedded product already in service is complex and expensive. Solutions that involve wireless uploads raise serious security issues that are just beginning to be addressed in equipment ranging from medical devices to automotive systems.

One solution to help programmers produce fewer bugs is design by contract or contract-based programming, and halfway down Brosgol introduce us to the contract features of Ada 2012, specifically the pre- and postconditions for subprograms:

Other language technologies treat contracts as run-time constructs. A recent example is Ada 2012, in which contracts take the form of Boolean conditions that are supplied in contexts such as invariants for types and preconditions and/or postconditions for subprograms. The programmer can control whether the software generates code to check these conditions at run-time; a failed check raises an exception. In this way, the specified contracts can be used either as formal comments that document the program’s intent or as run-time checks that are part of a testing regimen.

Next Brosgol goes on to talk about the extensive restrictions programmers can utilize in Ada to tailor the run-time requirements to their exact needs, using the Restrictions pragma. The entire article is a very nice and informative read, so be sure not to miss it.

Gautier de Montmollin: The Corporate Bullshit Generator

noreply@blogger.com (GdM) — Sat, 31 Mar 2012 20:39:00 +0000

This open-source project is not new, but new on the Web!
The Corporate Bullshit Generator (CBSG) is a high-performance random text generator that is focused on corporate bullshit, producing 400 pages per second of sentences like "A balanced efficiency drives the enablers within the industry", as meaningless as those from real people you might hear at some meetings. If you ever wondered why some speeches sound so random, it is because they are random. Perhaps they even come from this generator - who knows? After all, why sweat for writing a few lines during long minutes while your computer can create hundred of pages of the finest corporate language on a single click, and all for free!

Click here to join the project web page.
[ update 16-Mar-2012: the Generator's live version is here ! ]

Here are a few examples:

The Director of Human Resources transitions our enhanced skills using our communication; in the same time the resources address a tolerably expensive intelligence.
An overarching successful execution credibly generates our paradigms.
The resources proactively focus on our expertise.
Our customer-centric dialogues synergize the enablers as part of the plan, while lessons learned leverage a documented and integrated client focus.
An industry-standard platform technically transfers the focus, while a cost-effective 360-degree thinking transfers cascading skills. We must activate the matrix to think differently.
The thought leader pre-prepares our leveraged soft cycle issues; in the same time decentralized, progressive, contents inspire the project manager. An effective stress management generates a non-deterministic pipeline, while compliant strategic staircases interact with unique frameworks.
A strong value creation synergizes agreed-upon executions going forward.

Actually, the idea of random text generation is not new.

The first instance I came across is a 1987 book of Jean Epstein, Petit guide de conversation usuelle pour changer le monde sans fatigue, ou, Comment se débarrasser des gêneurs, which provides a grid of words to be used randomly and suggest the use of a computer to compose random sentences.

Of course there are some famous ancestors of the CBSG, with very refined random grammars and even a random chart generator!

SciGen, the Computer Science paper generator
PoMo, the Postmodernism generator

Enabled through Ada programming :-)

Gautier de Montmollin: The Corporate Bullshit Generator goes live !

noreply@blogger.com (GdM) — Sat, 31 Mar 2012 20:35:50 +0000

Since today, you find the interactive Web version here: http://cbsg.sf.net/ !

Ada in Denmark: The April 2012 Open Ada-DK Meeting

Sat, 31 Mar 2012 07:46:24 +0000

April 3rd. 2012 from 1730 -> ? marks the day and time when the seventeenth open Ada-DK meeting is being held.

The meeting is of course free.

Ada in Denmark: SC_Timer 2.0, the Session Chair Timer

Fri, 30 Mar 2012 13:12:04 +0000

J-P Rosen released version 2.0 of his SC_Timer program a few days ago, and it is shaping up to become a rather nice little package for your timing needs:

SC_Timer is a very convenient timer for session chairs in conferences who need to manage the presentation time of speakers. The chair enjoys a rich pannel to manage talk time (screenshot) and a secondary display to let the speaker know the remaining time, prompt messages, etc (screenshot). The display turns yellow -for example- ten minutes before time is over, then turns red five minutes before the end. When the presentation time is over, it displays a big red flashing “Off”. Alternatively, the timer can be set to count up (from 0 to programmed time) instead of down. Other features allow to manage various special cases (pauses, increasing or reducing talk time…).

There is also a regular clock in the upper right corner that tells you the current time.

Of course, the program is really a general count-down timer, and you can use it for all your count-down needs!

Sounds good ‘eh?

You can read J-P’s extremely short release announcement here and you can download the program as source, Linux executable and Windows executable. There’s also some excellent documentation available.

Ada in Denmark: Paraffin 3.2 Released

Fri, 30 Mar 2012 12:44:47 +0000

The 3.2 release of Paraffin comes with a hefty amount of changes since the not so old 3.1 release:

The same technique that was applied to iterative work stealing that significanly improved performance, was also applied to the work seeking generics, which also resulted in some performance gains.
Another benefit of this change is that the work seeking mechanisms are now more hidden inside the generic, and not exposed to client code. As a result, the modifications needed to parallelize a sequential loop is the same for work-sharing, work-seeking, and work-stealing. It mostly just involves wrapping the loop in a nested procedure, and then passing the start and finish indexes of the loop as parameters to the nested procedure.
A Minimum_Seek parameter replaces the Other_Workers parameter. This parameter indicates the minimum number of iterations that can be “seeked” at one time by an idle worker. This parameter can be left unspecified, in which case, a reasonable default will automatically be assigned.
As a result of these changes, the Work-seeking iterative tests generally seem to out perform work-stealing, although the differences are usually quite marginal. There are still tests where work-sharing can be best choice, and other tests where work-stealing can come out ahead.

Yup, Brad Moore is a busy man! In case the changelog doesn’t give away what exactly Paraffin is and does, here’s a short quote from projects website:

A suite of Ada 2005 generics to facilitate iterative and recursive parallelism for multicore systems and provide safer recursion for single and multicore systems. Includes useful generics for parallel quicksort, fast fourier transform, function integration, and Red-Black trees.

You can get to the goodies here and you can read the full release announcement here.

Ada in Denmark: SparForte 1.3 Released

Thu, 29 Mar 2012 09:15:30 +0000

Known in the olden days as Business Shell (or BUSH for short), SparForte is an all-in-one replacement for BASH, PHP, J2EE, Ruby, Python, Perl and PSQL. Yea, that does sound like a bit of a mouthful, but seeing as the head honcho of the project is Ken O. Burtch, author of Linux Shell Scripting with Bash (awesome book by the way), I’m fairly certain the description is very fitting.

SparForte is an Ada-based command shell, template engine and scripting language. It natively interprets Bourne shell commands and basic database commands at the command prompt and has an integrated debugger. There are 23 built-in packages including MySQL, PostgreSQL, CGI and Memcache and over 80 example scripts.

I gotta get me some of that. Why am I still using Bash on my boxes? It makes no sense.

Major changes in SparForte 1.3 is:

with separate (“include files”) and is separate
two memcache packages
JSON: built-in functions and import_json/export_json pragmas
unit testing mode and associated pragmas
software license management features
new architectural pragmas
package documentation redesigned

You can read the full release announcement here and you can grab the code here.

Ada in Denmark: VTKADA 5.9 release 3 free edition

Thu, 29 Mar 2012 08:58:43 +0000

A new version of VTKAda is now available:

VTKAda is Ada-2012 port to VTK (Visualization Toolkit by Kitware, Inc) and Qt4 application and UI framework by Nokia VTK version 5.9.0, Qt version 4.7.3 open source and qt4c.dll(libqt4c.so) were builded with Microsoft Visual Studio 2010 in Windows and gcc in Linux x86 Package was tested with gnat gpl 2011 ada compiler (-gnat12 option) in Windows XP Sp3 32bit, Windows 7 Sp1 64bit and Debian 5 x86.

Leonid Dulman (PDF) must be a busy man, because I remember having reported on anotherVTKAda release not so long ago. You can read the full release announcement here.

Ada in Denmark: ColdFrame 20120324 Released

Thu, 29 Mar 2012 08:44:32 +0000

If you use UML and specifically ArgoUML to model your programs, then ColdFrame might of interest to you:

ColdFrame is an open-source code generator backend for use with UML tools. In its present state, it’s targeted at ArgoUML and generates Ada code frameworks. The intermediate representation uses XML. The code generation uses the XSL Transformation (XSLT) language, so – with an investment in time and thought – you can design your own transformation mechanisms to the programming language of your choice.

You can grab the latest version of ColdFrame here and you can read the, short, release announcement here.

Maybe ColdFrame is just what I need to get started on learning some UML?

Ada in Denmark: AdaCommons Temporarily Moved

Thu, 29 Mar 2012 07:27:14 +0000

Due to some missed renewal emails our beloved AdaCommons wiki is temporarily down and out for the count. Or rather it has been relocated for now to commons.ada.cx, so we wont have to go into withdrawal from not having access to the AdaCommons wiki.

I don’t have any ETA on when AdaCommons will be back online, but I suspect it wont too far into the future.

Ada in Denmark: Corporate Bullshit Generator Online

Sat, 17 Mar 2012 09:18:25 +0000

Gautier de Montmollin have gone and done it: Put his marvelous Corporate Bullshit Generator online, so now you can get your daily dose of corporate madness with a mere click on the mouse.

The new paradigms streamline accepted relationships. Escalations target the customers; in the same time the resources transition the strategic, executive-level, implications.

Yea, that’s right: New paradigms always streamline accepted relationships. Already I feel wiser. Thanks Gautier!

Ada in Denmark: Ada And Arduino – A Good Match

Thu, 15 Mar 2012 12:16:56 +0000

Let me start by admitting almost zero knowledge about electronics. The last time I did any soldering was +20 years ago, but that doesn’t stop me from being absolutely amazed at the marvelous things people can build with the Arduino boards, and because I’m not the only Ada’ist with this fascination, it didn’t take long before we got Ada support for these wonderful machines.

Our very own Jacob Sparre Andersen did a talk at FOSDEM 2012 and Open Source Days 2012 about Ada and the Arduinos: Programming Arduinos in Ada(PDF). It’s a pretty good read if you’re thinking about venturing into the amazing world of Arduino.

Another Ada’ist working with Arduinos is Tero Koskinen, and besides being the man behind the Ahven unit test framework, he also dabbles in electronics, and a few days ago he did a new post on his blog titled Building Custom Arduino LCD Shield To Be Used With AVR-Ada. Yup, long title indeed, but well worth the read.

Ada in Denmark: GNAT AUX Synced With GCC 4.6.3

Tue, 13 Mar 2012 14:23:42 +0000

The DragonLace project is still going strong, and a little over a week ago they synced the GNAT AUX compiler with GCC 4.6.3:

GCC 4.6.3 was released on 1 March 2012. Due to recent work on the gnat-aux package, it was relatively easy to update the pkgsrc version of gnat-aux to version 20120301 which syncs with GCC Release 4.6.3. It has already been tested and committed to the pkgsrc CVS trunk.

It wasn’t all sunshine and happy bananas though, as there was some trouble getting it to work properly with FreeBSD 9.x. The DragonLace people are on it though, and if things pan out as they usually do, they will have everything solved soon ™.

You can read the full post about the update here

Ada in Denmark: Ahven 2.2 released

Tue, 13 Mar 2012 09:57:55 +0000

Tero Koskinen recently released version 2.2 of his Ahven unit testing library:

This (2.2) is long overdue bug fix release for Ahven. Ahven.XML_Runner had same bug as Ahven.Text_Runner and this release fixes it. Now your XML test result files should have skipped tests correctly reported. Another bigger change is API documentation generator change from Adabrowse to Sphinx.

You can find the projects official SourceForge page here or you can skip all the difficult stuff and go straight to the goodies.

Ada in Denmark: The March 2012 Open Ada-DK Meeting

Mon, 12 Mar 2012 15:40:35 +0000

March 13th. 2012 from 1730 -> ? marks the day and time when the sixteenth open Ada-DK meeting is being held.

The meeting is of course free.

Ada in Denmark: Robert Dewar @ FOSDEM 2012

Tue, 06 Mar 2012 11:35:00 +0000

Robert Dewar’s FOSDEM 2012 keynote titled Free Software: A viable model for Commercial Success has been put online (webm video), and it is, as always with mr. Dewar, a great talk.

I really liked the angle of his talk, especially because we at the AdaHeads project intend to go down that exact route with our products. It was good to hear that it is indeed a viable business model.

If you’re doubtful about the viability of open source software as the foundation for making money, then don’t miss Robert’s talk.

You can view the the other FOSDEM 2012 videos here.

Ada in Denmark: AdaCore Releases GNAT Pro 7.0

Tue, 06 Mar 2012 10:01:47 +0000

I’m fairly sure I’ll never be able to afford GNAT Pro, but that wont stop me from being very excited about the release of GNAT Pro 7.0:

AdaCore today announced the availability of GNAT Pro 7.0, a major new version of the company’s flagship development environment product. This latest annual release completely implements the upcoming Ada 2012 language revision, offers a range of improvements (many based on user suggestions), supports several new platforms, includes an important new testing tool (GNATtest), and enhances several existing tools. As with all AdaCore products, GNAT Pro is Freely-Licensed Open Source Software (FLOSS)

Having full Ada 2012 support in an Ada compiler is pretty damn awesome. Kudos to AdaCore for making it happen so fast. The only downside is that us poor people will have to wait for GNAT GPL for what will now feel like an eternity. GNAT GPL is still stuck at version 2011 on the libre.adacore.com website. But hey, time flies when you’re having fun, so I guess we best get cracking on some fun projects ASAP.

Tero Koskinen: Ahven 2.2 released

Mon, 05 Mar 2012 10:52:00 +0000

This (2.2) is long overdue bug fix release for Ahven. Ahven.XML_Runner had same bug as Ahven.Text_Runner and this release fixes it. Now your XML test result files should have skipped tests correctly reported. Another bigger change is API documentation generator change from Adabrowse to Sphinx.

As usual, you can get the source from Sourceforge.

DragonLace: GNAT AUX Synced with GCC 4.6.3 on pkgsrc

Fri, 02 Mar 2012 16:23:33 +0000

GCC 4.6.3 was released on 1 March 2012. Due to recent work on the gnat-aux package, it was relatively easy to update the pkgsrc version of gnat-aux to version 20120301 which syncs with GCC Release 4.6.3. It has already been tested and committed to the pkgsrc CVS trunk.

The same can't be said for the FreeBSD version. The port updated okay, and would work fine on FreeBSD 8.x and below, but it's failing FreeBSD 9.0 ACATS testsuite. It turns out that version 4.6.2 was failing as well. Specifically 23 tasking tests are failing with "Fatal error 'thread exits with resources held!'". This is caused by an update to the thread library that detects this sort of thing and FreeBSD 9.0 is the first version to use the updated library.

I will try to modify GNAT to free the thread's resources so that tasking for FreeBSD will work. Also, the gnatdroid port will use part of the gnat-aux makefiles and patches so that it will automatically update when gnat-aux updates. It is still at gcc version 4.6.1, but an update for that port will follow shortly after gnat-aux is fixed.

Tero Koskinen: Building custom Arduino LCD shield to be used with AVR-Ada

Tue, 28 Feb 2012 00:30:00 +0000

Using 16x2 LCD display for text output purposes is sometimes more convenient than serial communication via UART/USB.

But if you do the wiring on the breadboard you get quite a mess:

So, I wanted to create a shield for Arduino to make the LCD usage easier.

AVR-Ada includes library for HD44780-compatible LCD using 4 bits for data.

That means we need to use 4 pins for data, one pin for Enable signal, and one pin for Register select. Wiring on the shield therefore is something like this:

We also want a trimpot on the shield:

The middle pin of the trimpot is connected to the LCD pin 3 (Contrast adjust), other two pins are connected to GND and VCC.

After placing the wires and the trimpot, we put the display there:

Finally, using code from my Bitbucket repository, we get some visible text:

Some notes:

I used here Arduino UNO r3 with Arduino Protoshield r3.
The Ada code requires AVR-Ada 1.2 (the latest development version from AVR-Ada git repository at the moment).
If you fear that the LCD display might get damaged, you probably don't want to solder it directly to the proto shield but place female header between instead.
My LCD display did not have working backlight, so I left those pins (15,16) disconnected.

Ada in Denmark: FSF GNAT 4.3.4 binaries for OpenBSD/amd64 5.0

Fri, 24 Feb 2012 15:53:35 +0000

This is just a quick one to let you know that Tero Koskinen has done a couple of packages for OpenBSD/amd64 5.0 to help alleviate some of the pain of bootstrapping GNAT:

GNAT is somewhat painful to bootstrap on new platforms and existing binaries for OpenBSD/amd64 are for older releases, so I made fresh ones for OpenBSD 5.0 release on amd64 (x86_64 for Linux people) platform.
Tasking and most other “common” features should be supported, although I suspect that GNAT-AUX 4.6.x from http://www.dragonlace.net/ passes more ACATS tests. But once you have 4.3.4 installed, you can use it to bootstrap GNAT-AUX 4.6.x.

You can get the packages from http://koti.kapsi.fi/tkoskine/openbsd/5.0-amd64-packages/ and then it’s just a simple matter of using pkg_add to install them.

You can read the full release announcement from Tero here.

Ada in Denmark: SPARK: A red-black tree with correctness proofs

Fri, 24 Feb 2012 15:37:48 +0000

From Phil Thornley of SparkSure fame we get a SPARK package implementing a red-black tree data structure:

A SPARK package implementing a red-black tree is now available and correctness proofs have been completed for the code. (SPARK correctness is, of course, partial correctness as there are no proofs of termination of the operations.)

In this version the Ada code is complete and all the mandatory SPARK annotations for information flow analysis are included, but the optional proof annotations within the operations in the package body have been excluded. (I have completed these, but they are not yet in a publishable form.)

You download the package here (ZIP) and you can read more about the SparkSure data structures here. The full release announcement is available here.

Forward in Code: Expressiveness in Python

noreply@blogger.com (Simon) — Tue, 21 Feb 2012 12:21:39 +0000

I've been having fun reworking the Literate Programming tool nuweb in Python; the Mercurial repository for the rework can be browsed here. On the way I've come across a neat hack, and a rather unlikely workaround for Python's lack of a switch statement.
Read more »

Forward in Code: A Makefile hack

noreply@blogger.com (Simon) — Tue, 21 Feb 2012 12:02:25 +0000

I had a problem with GNU Make where multiple targets were created from one prerequisite.

Ada in Denmark: Ada Server Faces 0.3.0 is available

Thu, 16 Feb 2012 09:47:18 +0000

Stephane Carrez from Java 2 Ada is hard at work on his Ada Server Faces framework, and as this online demo clearly is showing, he’s making good progress. The version 0.3.0 release announcement outlines some of what Ada Server Faces is:

Ada Server Faces is a web framework which uses the Java Server Faces design patterns (See JSR 252 and JSR 314).

JSF and ASF use a component-based model for the design and implementation of a web application. The presentation layer is implemented using XML or XHTML files and the component layer is implemented in Ada 05 for ASF and in Java for JSF.

I can’t claim a whole lot of knowledge about the Java Server Faces design patterns, but judging from the demo, it’s some pretty powerful stuff. I look forward to tracking this project further, especially considering my involvement in the AdaHeads K/S project.

Ada in Denmark: CUDA/Ada version 0.1

Thu, 16 Feb 2012 09:27:19 +0000

Back in December 2011 we reported on an early developer version of the newly started CUDA/Ada project, and now a mere 2 months later the codelabs.ch guys have officially released version 0.1 of the CUDA/Ada binding to Nvidia’s CUDA platform:

CUDA/Ada is an Ada binding to NVIDIA’s CUDA parallel computing platform and programming model. This project was developed during the course of the master seminar “Program Analysis and Transformation” at the University of Applied Sciences Rapperswil.

There’s a nice benchmark chart on the website, which really shows of the power of CUDA/Ada, and there’s also an interesting paper (PDF) available with lots of information about the project.

You can download the latest version here and you can read the release announcement here.

Ada in Denmark: GWindows – A New Ada GUI Framework For Windows

Tue, 14 Feb 2012 08:22:20 +0000

A new GUI framework for Ada is always welcome, even though this is one restricted to one platform. GWindows is..

…the Professional Open Source Ada 95 Win32 RAD Framework. It introduces for the first time to Ada programming a comprehensive rapid application development framework spanning GUI, Database and Active X integration. It brings the power of Ada to programming domains that up until now are dominated by VB and Delphi.

GWindows includes extensive bindings to the Windows GUI including support for common controls and dialogs, printing, and owner drawn extensions to controls. In addition, GWindows adds a number of new controls, keyboard support, multiple models of event handling, Active
X controls, support for creating dialogs and windows from resource files, dynamic garbage collected windows, Window docking, non-GUI bindings, database support, database bound controls, and much more!

GWindows builds as either ANSI or UNICODE (a first for Ada!) for internationalization and performance boosts on Windows NT, 2000, and XP. GWindows is tightly integrated with GNATCOM, the Ada 95 COM/DCOM/COM+ Development Framework and Tools opening every facet of the Windows platforms to Ada 95 development. Never again will the cries be heard, “but there are no bindings” on the Windows platform!

GWindows is designed to take advantage of Ada’s unique combination of features rich typing mechanisms. It is not a think binding to an underlying C interface, but a complete framework that takes advantage of Ada at every level.

Usage seems pretty simple and straightforward, and creating the ever popular Hello world! application is done rather easily:

with GWindows.Windows.Main; use GWindows.Windows.Main;
with GWindows.Application;
 
procedure Hello_World is
   pragma Linker_Options ("-mwindows");
 
   Main_Window : Main_Window_Type;
begin
   Create (Main_Window, "Hello world!");
   Visible (Main_Window, True);
 
   GWindows.Application.Message_Loop;
end Hello_World;

Yea, I just completely stole that from their tutorial – I haven’t actually tried it, since I don’t use Windows.

If you’re an Ada programmer and you’re itching to build some GUI applications, then be sure to take a look at the GWindows documentation to see if it suits your fancy.

You can read the full release announcement here.

Ada in Denmark: Strings edit v2.7

Tue, 14 Feb 2012 08:06:42 +0000

Hot on the heels of Strings Edit v2.6 comes v2.7. This latest releases fixes some bugs in the implementation of String-based streams. You can read Dmitry’s short and sweet release announcement here.

Ada in Denmark: Paraffin 2.4 Released

Tue, 14 Feb 2012 07:54:31 +0000

Back in October 2011 we reported on the release of version 2.0 of Brad Moore’s Paraffin library, and now, a mere 3½ months later we’re graced with the latest and greatest: Paraffin version 2.4.

Since the name Paraffin in itself doesn’t give away what it does, here’s a quote from the project website:

A suite of Ada 2005 generics to facilitate iterative and recursive parallelism for multicore systems and provide safer recursion for single and multicore systems. Includes useful generics for parallel quicksort, fast fourier transform, function integration, and Red-Black trees.

New in this release is:

Added a reusable utility to solve a matrix of linear equations using Gauss-Jordan Elimination.
Added test_matrix test driver for parallel/sequential matrix solvers.
Red-Black Tree containers fully implemented now. (Delete, and Contains calls work)
Split Red-Black Tree container into separate generics
- Sequential
- Work sharing
- Work Seeking
- Stack Safe Work Seeking
The Red Black Tree generic was previously intended mostly as a test driver for Paraffin Recursive generics. Now the generic has been completed to a state where it can be reused on its own as a generic container.
Changed use of Unchecked_Conversion for Recurse supprogram access to use ‘Unrestricted_Access instead. This cleaned the code up considerably in this area. One issue to look into, is that ‘Unrestricted_Access is a non-standard attribute. It is supported by both GNAT and the ICC compiler however. It may not be supported by other Ada 2005 compilers. Unfortunately, Unchecked_Conversion in this case is not portable either, and may not even continue to work with the existing compilers, so it was thought that using ‘Unrestricted_Access was the best option for now. Will investigate to see if there is a possibility for a better solution, or providing a portable mechanism in a future version of Ada.

Yea, Brad’s been busy!

You can read the full release announcement here.

Ada in Denmark: Interval Arithmetic for Ada, v1.10

Tue, 14 Feb 2012 06:56:10 +0000

If one day you’re finding yourself in need of doing some interval arithmetic in Ada, then you need look no further than Dmitry Kazakov’s Interval Arithmetic for Ada package:

The packages define a logical and interval types. The interval types are obtained through instantiation of the corresponding generic packages. Interval and numeric types can be mixed where the result has mathematical sense.

So if tri-state logic and dimensioned intervals is what you need, then be sure to check out this package. It’s available in 32/64 bit flavors for Fedora and Debian, and of course also as a plain source package. You can read the full release announcement here.

Ada in Denmark: Zip-Ada v.42 released

Fri, 10 Feb 2012 20:08:22 +0000

A few days ago Gautier de Montmollin mentioned that the .42 release of Zip-Ada was in the works, and today it was finally released on the world.

Zip-Ada is a programming library for dealing with the Zip compressed archive file format. The full sources of Zip-Ada are in Ada, compilable on every compiler and for every system. For more details, read the files zipada.txt and zip.ads from the archive below.

New in version .42 is:

Support for Zip archives appended to other files, like a self-extracting archive with Zip-Ada in the executable.
Support for Unicode UTF-8 entry names within Zip archives.
New package Zip.Compress.Deflate, with a first (weak but straightforward) compression technique for the Deflate format

For those of you wondering why one should use this library, instead of simply just using the zlib library, the answer is simple and straightforward: Independence. With Zip-Ada you can zip and unzip data without any OS-dependent external calls, which obviously is a nice thing. You should also, theoretically, get better portability, since you don’t have to worry about the existence of zlib (or similar) on the target platform. Gautier have tested Zip-Ada with several different environments, so there’s a good chance it will work on almost whatever you throw at it.

You can read the full release announcement here.

Ada in Denmark: Report from the February 2012 open Ada-DK meeting

Thu, 09 Feb 2012 10:23:42 +0000

What this meeting lacked in numbers it weighed up in fun discussions and tryouts of bleeding-edge card games.

Only Thomas Løcke and Kim Rostgaard Christensen was present at this meeting, so the time was passed discussing code, politics, operating systems, weirdness of corporate strategies and Ada in the education system.

The meeting was started of with a massive beating of Thomas Løcke in a game of CPU Wars, which then led to a stroll down memory lane revisiting some of the processors that had been a big part of our lives.

The food was excellent as always, and the dinner discussion ever interesting. The discussion rather fast went into AdaHeads-mode as there were no non-AdaHeads-folks to stop us. What was agreed here, is a story for another day – and a quite interesting one I must say.

- Stay tuned.

Ada in Denmark: FOSDEM 2012 Ada Presentations

Thu, 09 Feb 2012 06:49:37 +0000

For those of us not lucky enough to have been able to attend FOSDEM 2012, I’m very glad to report that all the Ada presentations are now available at the Ada Belgium website. There’s some really good stuff in there, so be sure to check it out.

But there’s more good news: The FOSDEM 2012 people are apparently working on getting some of the videos of the event online. I cannot begin to express how much I appreciate that. I really look forward to seeing the presentations. It’ll be almost the same as having been there myself. Almost.

Ada in Denmark: The February 2012 Open Ada-DK Meeting

Mon, 06 Feb 2012 08:10:18 +0000

February 7th. 2012 from 1800 -> ? marks the day and time when the fifteenth open Ada-DK meeting is being held.

The meeting is of course free.

Ada in Denmark: Ada.Directories Wiki Article Migrated

Wed, 01 Feb 2012 19:44:21 +0000

It’s finally over! The entire Ada-DK Wiki has been migrated successfully. Today I moved the Ada.Directories article, and with that one out of the way, the new dokuwiki setup is now on par with the old wiki.

So next on the wiki-agenda is writing some new articles. It’s been a while since we’ve added anything new to our wiki, which is a bit of a shame. The last one I did was the GNATCOLL.JSON one, and that’s a good 2½ months ago! I’m considering doing one on the Ada.Task_Attributes package, but it’s not set in stone yet. Feel free to ping me if you’ve got any good ideas.

Ada in Denmark: Units of measurement for Ada v3.2

Tue, 31 Jan 2012 15:56:52 +0000

Version 3.2 of Dmitry Kazakov’s Units of Measurements for Ada library has just been let lose on the world. This library deals with, well, units of measurement:

The library is provided for handling dimensioned values in Ada. The library supports irregular and shifted measurement units. String formatting and GTK+ widgets and cell renderers are provided.

New in version 3.2 is:

The procedure Put in Measures_UTF8_Edit has additional parameters Field, Justify, Fill
Fedora and Debian packages are provided for both 32- and 64-bit architectures.

You can read the full release announcement here.

Ada in Denmark: Overridable Class Attributes in Ada 2012

Tue, 31 Jan 2012 10:41:04 +0000

One of the nicest features of the AdaCore website is the Ada Gem of the Week. Currently sitting at 117 gems, this place is a regular treasure-trove for Ada programming.

Today’s gem is written by Emmanuel Briot and it deals with some of the new Ada 2012 features, specifically in relation to object oriented Ada programming. it’s called Gem #117: Design Pattern: Overridable Class Attributes in Ada 2012.

Most object-oriented programming languages provide a facility for declaring variables that are shared by all objects of a given class. In C++, these are called “static members” (and use the “static” keyword), and similarly Python has the notion of “class attributes”.

Let’s consider an example where this is useful. For instance, let’s say we want to define the notion of a block of text that is generated by expanding a template (perhaps after we replace some parameters in that template, as can be done with AWS’s templates parser, for instance). Once we have computed those parameters, we might want to generate multiple outputs (for instance HTML and CSV). Only the template needs to change, not the computation of the parameters.

I can’t say I’m a huge expert on object oriented Ada programming, but this little snippet actually made me hungry for playing around with some of the new Ada 2012 features, such as expression functions, where you can do stuff like this:

pragma Ada_2012;
 
type Text_Block is tagged null record;
function Template (Self : Text_Block) return String
   is ("filename.txt");
function Render (Self : Text_Block) return String;

Instead of the old more clunky method:

type Text_Block is tagged null record;
function Template (Self : Text_Block) return String;
function Render (Self : Text_Block) return String;
 
function Template (Self : Text_Block) return String is
   pragma Unreferenced (Self);
begin
   return "file_name.txt";
end Template;

Very nice indeed! The new Ada 2012 syntax allows for a much more simple and readable setup of the Text_Block type. But don’t take my word for it, go read the Gem instead. It is definitely worth it.

Forward in Code: Catching exceptions in GDB

noreply@blogger.com (Simon) — Sun, 29 Jan 2012 18:44:53 +0000

There's a problem running gdb from GNAT GPL 2011 (which works fine with programs compiled with GNAT GPL 2011) on programs compiled with GCC 4.6 on Max OS X Lion and possibly earlier: you can't catch exceptions as you'd expect:


   (gdb) break exception
   Unable to insert catchpoint. Try to start the program first.

Forward in Code: Debugging and stack traces on Mac OS X Lion

noreply@blogger.com (Simon) — Fri, 27 Jan 2012 21:44:34 +0000

Mac OS X 10.7 Lion (really, Xcode 4) has changed the way that the system linker works in a way which makes debugging and interpreting stack traces difficult-to-impossible without special action.
Read more »

Ada in Denmark: GtkAda Contributions and AICW updates

Thu, 26 Jan 2012 07:29:00 +0000

More updates from Dmitry Kazakov:

GtkAda Contributions is the work of Dmitry Kazakov and Maxim Reznik. It is a package of proposed contributions to GtkAda, adding stuff like tasking support, embeddable images, spawning processes synchronously and asynchronously with pipes and a whole lot more. You can read the release announcement here.

Ada Industrial Control Widget Library enables you to create all sorts of graphical gauges, meters, clocks and oscilloscopes. If you need some sort of visual indication of load, pressure, speed or whatever, then this package will probably be able to get the work done. You can read Dmitry’s release announcement here.