AdaCore Gem of the Week

Gem #148 : Su(per)btypes in Ada 2012 - Part 3

2013-05-20T12:59:50+00:00

In the previous two Gems of this series, we saw how the aspects Static_Predicate and Dynamic_Predicate can be used to state properties of objects that should be respected at all times. This Gem is concerned with the Type_Invariant aspect.

Gem #147 : Su(per)btypes in Ada 2012 - Part 2

2013-05-06T13:00:40+00:00

In the previous Gem in this series, we saw how the aspect Static_Predicate can be used to state properties of scalar objects that should be respected at all times. This Gem is concerned with the Dynamic_Predicate aspect.

Gem #146 : Su(per)btypes in Ada 2012 - Part 1

2013-04-22T12:59:13+00:00

The new revision of Ada is full of features for specifying properties of types. In this series of three Gems, we describe three aspects that can be used to state invariant properties of types. This first Gem is concerned with the Static_Predicate aspect.

Gem #145: Ada Quiz 3 - Statements

2013-04-08T13:00:34+00:00

Abstract: Extracted from the AdaCore training courses, this Gem about "Statements" carries on with the series of occasional quizzes on Ada language features.

Gem #144: A Bit of Bytes: Characters and Encoding Schemes

2013-03-25T13:00:18+00:00

This Gem describes some of the concepts behind character encoding and Unicode. It explains why multiple character sets exist, and how to deal with them in your application if you want to handle international input and output.

Gem #143 : Return to the Sources

2013-03-11T13:00:54+00:00

The GNAT technology introduced the notion of projects with its 3.15 release in 2002. This notion was revisited and stabilized in later versions, and projects are now supported by all GNAT tools. They are a convenient way to describe how the sources of your application are organized, and how they should be manipulated by the various tools. They can also be used from your own tools through a convenient API in the GNAT Components Collection, which this Gem introduces.

Gem #142 : Exception-ally

2013-02-25T13:00:33+00:00

The GNAT compiler is well known for the quality of its error messages. This also extends to the messages associated with exceptions, and this Gem shows a few ways that these can be made more useful.

Gem #141 : Con-figure it out

2013-02-11T09:13:18+00:00

In the Gem series on GNAT.Command_Line (Gems #138 and #139), we mentioned that there are several ways a user can control the behavior of an application. These are command-line options (as discussed in that Gem), graphical user applications (for instance using GtkAda), and configuration files. This Gem proposes various approaches for the latter.

Gem #140: Bridging the Endianness Gap

2013-01-28T13:00:29+00:00

An IT engineer has to make two essential choices in life:

Shall I break my soft-boiled egg from the big end, or from the little end?
When storing a multibyte value, shall I store it most significant byte first, or least significant byte first?

More than thirty years has passed since Danny Cohen made his plea for peace between big endians and little endians, and software is still plagued with all manner of byte-swapping code to accommodate data produced by systems of different obediences. Can languages come to the rescue?

Gem #139 : Master the Command Line - Part 2

2013-01-14T13:00:14+00:00

The first part of this Gem series described how to use GNAT.Command_Line to retrieve the switches and arguments passed to an application. This still requires writing quite a lot of code. In this part we explain the high-level API of GNAT.Command_Line and show how to make command-line management a breeze.

Gem #138 : Master the Command Line - Part 1

2012-12-10T13:00:19+00:00

Applications can be configured in multiple ways. Among the most frequent are command-line options, configuration files, and graphical user interfaces. The GNAT technology provides various means to interface with those: Ada.Command_Line and GNAT.Command_Line, GNATCOLL.Config, and GtkAda. The latter two will be discussed in later Gems; this series of two Gems will describe how to manipulate the command line.

Gem #137: Ada Quiz 2 - An Heir and a Spare?

2012-11-26T13:00:21+00:00

This Gem about inheritance, derived from the AdaCore training courses, continues with the series of occasional quizzes on Ada language features.

Gem #136: How tall is a kilogram?

2012-11-12T13:00:02+00:00

The GNAT compiler now supports dimensionality checking. The user can specify physical units for objects, and the compiler will verify that uses of these objects are compatible with their dimensions, in a fashion that is familiar to engineering practice. The dimensions of algebraic expressions (including powers with static exponents) are computed from their constituents. The GNAT compiler provides a package to support the MKS system of units, and the user can provide additional packages as needed (CGS, British units, etc.).

Gem #135 : Erroneous Execution - Part 4

2012-10-29T13:00:50+00:00

This Gem completes the series on erroneous execution by discussing the language design. Why does Ada have erroneous execution in the first place?

Gem #134 : Erroneous Execution - Part 3

2012-10-15T13:00:57+00:00

This Gem expands on the example of erroneous execution discussed in Part 2.

Gem #133 : Erroneous Execution - Part 2

2012-09-24T13:00:11+00:00

The previous Gem said that "erroneous execution" means that anything can happen as far as the Ada RM is concerned, and in particular, the program might work properly. This Gem continues the discussion.

Gem #132 : Erroneous Execution - Part 1

2012-09-10T13:00:33+00:00

Many Ada programmers are confused by the term "erroneous", in part because Ada uses the term to mean something other than what it means in plain English. In English, "erroneous" just means "wrong". But in Ada it refers to a particular kind of wrongness. This gem is intended to clarify the Ada meaning.

Gem #131 : Type-Safe Database API - Part 3

2012-08-07T01:00:11+00:00

The first two parts of this Gem demonstrated how to execute type-safe SQL queries on various database systems. In both of those, the SQL was still very much visible in the application. This third part explains the use of an Object-Relationship Management (ORM) that performs SQL queries in the background without exposing them to the user.

Gem #130 : Type-Safe Database API - Part 2

2012-07-23T06:00:24+00:00

The first Gem in this series discussed how to write syntactically correct and type-safe SQL queries. We now need to execute these queries on the DBMS of choice and retrieve the results. This Gem explains how to use the DBMS-agnostic API in GNATColl to do this.

Gem #129 : Type-Safe Database API - Part 1

2012-07-09T12:59:14+00:00

This Gem series describes the design and implementation of a type-safe, vendor-neutral Application Programming Interface (API) to interact with a database system. We review the current practice in this area and summarize the problems and limitations, as well as showing some solutions that were developed in response. The series is presented in three parts, each part corresponding to a layer of the API.

Gem #128 : Iterators in Ada 2012 - Part 2

2012-06-25T13:00:35+00:00

The first part of this two-part Gem series explained the basics of Ada 2012 iterators. Part 2 goes into more detail, showing how to create iterators for user-defined data structures.

Gem #127: Iterators in Ada 2012 - Part 1

2012-06-11T13:00:47+00:00

Ada 2012 iterators provide syntactic sugar for iterating over data structures. This Gem describes the new syntax and what it brings to the language. Part 2 will explain how you can define your own iterators when formulating new data structures.

Gem #126 : Aggregate Library Projects

2012-05-28T13:00:42+00:00

An aggregate library project provides a way to create a single library using multiple other library project files. In this Gem we show how to create such libraries.

Gem #125: Detecting infinite recursion with GDB’s Python API

2012-05-14T08:00:36+00:00

In a previous Gem we saw that the python API of GDB provides some ways to check advanced properties of a program. This Gem illustrates another use case and shows how to set an upper bound on the number of recursive calls to a function.

Gem #124 : Scripting GPS for Static Analysis

2012-04-30T13:00:56+00:00

This Gem shows how to use the scripting capabilities of the GNAT Programming Studio IDE to perform some simple static analysis.

Gem #123: Implicit Dereferencing in Ada 2012

2012-04-17T07:00:44+00:00

This Gem discusses the use of features added in Ada 2012 that simplify accessing and updating the elements of containers.

Gem #122: Breakpoint Commands — Part 2

2012-04-10T14:22:09+00:00

In a previous Gem, a simple use case of breakpoint commands was provided to check some program properties at run time. This Gem extends this use case to show some of the expressive power of the Python API.

Gem #121 Breakpoint Commands—Part 1

2012-03-12T20:37:34+00:00

This gem will give a simple use case of breakpoint commands in GDB to check dynamically some properties of the debugged program.

Gem #120 : GDB Scripting—Part 2

2012-03-12T20:35:25+00:00

In the previous Gem we saw how GDB provides scripting capabilities through its macro-coding language, which allows customization of the debugger using the .gdbinit file. In this Gem, we explore more advanced features of GDB scripting.

Gem #119 : GDB Scripting—Part 1

2012-02-27T16:16:10+00:00

GDB, the GNU Project Debugger, is a powerful tool. General use includes basic CLI commands -- break, run, print, etc. -- but there is so much more you can do with it. One of those capabilities is scripting. Just as you have a .rc for your shell configuration, you can also add a .gdbinit for the debugger. This Gem describes some of the available features of GDB scripting and general customization with .gdbinit.