assignment statement in ada

Copyright 1980, 1982, 1983 owned by the United States Government. Direct reproduction and usage requests to the Ada Information Clearinghouse .

• Ada for the Embedded C Developer
• The C Developer's Perspective on Ada

The C Developer's Perspective on Ada 

What we mean by embedded software .

The Ada programming language is a general programming language, which means it can be used for many different types of applications. One type of application where it particularly shines is reliable and safety-critical embedded software; meaning, a platform with a microprocessor such as ARM, PowerPC, x86, or RISC-V. The application may be running on top of an embedded operating system, such as an embedded Linux, or directly on bare metal. And the application domain can range from small entities such as firmware or device controllers to flight management systems, communication based train control systems, or advanced driver assistance systems.

The GNAT Toolchain 

The toolchain used throughout this course is called GNAT, which is a suite of tools with a compiler based on the GCC environment. It can be obtained from AdaCore, either as part of a commercial contract with GNAT Pro or at no charge with the GNAT Community edition . The information in this course will be relevant no matter which edition you're using. Most examples will be runnable on the native Linux or Windows version for convenience. Some will only be relevant in the context of a cross toolchain, in which case we'll be using the embedded ARM bare metal toolchain.

As for any Ada compiler, GNAT takes advantage of implementation permissions and offers a project management system. Because we're talking about embedded platforms, there are a lot of topics that we'll go over which will be specific to GNAT, and sometimes to specific platforms supported by GNAT. We'll try to make the distinction between what is GNAT-specific and Ada generic as much as possible throughout this course.

For an introduction to the GNAT Toolchain for the GNAT Community edition, you may refer to the Introduction to GNAT Toolchain course.

The GNAT Toolchain for Embedded Targets 

When we're discussing embedded programming, our target device is often different from the host, which is the device we're using to actually write and build an application. In this case, we're talking about cross compilation platforms (concisely referred to as cross platforms).

The GNAT toolchain supports cross platform compilation for various target devices. This section provides a short introduction to the topic. For more details, please refer to the GNAT User’s Guide Supplement for Cross Platforms

GNAT supports two types of cross platforms:

cross targets , where the target device has an embedded operating system.

ARM-Linux, which is commonly found in a Raspberry-Pi, is a prominent example.

bareboard targets , where the run-times do not depend on an operating system.

In this case, the application has direct access to the system hardware.

For each platform, a set of run-time libraries is available. Run-time libraries implement a subset of the Ada language for different use cases, and they're different for each target platform. They may be selected via an attribute in the project's GPR project file or as a command-line switch to GPRbuild . Although the run-time libraries may vary from target to target, the user interface stays the same, providing portability for the application.

Run-time libraries consists of:

Files that are dependent on the target board.

These files are responsible for configuring and interacting with the hardware. They are known as a Board Support Package — commonly referred to by their abbrevation BSP .

Code that is target-independent.

This code implements language-defined functionality.

The bareboard run-time libraries are provided as customized run-times that are configured to target a very specific micro-controller or processor. Therefore, for different micro-controllers and processors, the run-time libraries need to be ported to the specific target. These are some examples of what needs to be ported:

startup code / scripts;

clock frequency initializations;

memory mapping / allocation;

interrupts and interrupt priorities;

register descriptions.

For more details on the topic, please refer to the following chapters of the GNAT User’s Guide Supplement for Cross Platforms :

Bareboard Topics

Customized Run-Time Libraries

Hello World in Ada 

The first piece of code to translate from C to Ada is the usual Hello World program:

The resulting program will print Hello World on the screen. Let's now dissect the Ada version to describe what is going on:

The first line of the Ada code is giving us access to the Ada . Text_IO library which contains the Put_Line function we will use to print the text to the console. This is similar to C's #include <stdio.h> . We then create a procedure which executes Put_Line which prints to the console. This is similar to C's printf function. For now, we can assume these Ada and C features have similar functionality. In reality, they are very different. We will explore that more as we delve further into the Ada language.

You may have noticed that the Ada syntax is more verbose than C. Instead of using braces {} to declare scope, Ada uses keywords. is opens a declarative scope — which is empty here as there's no variable to declare. begin opens a sequence of statements. Within this sequence, we're calling the function Put_Line , prefixing explicitly with the name of the library unit where it's declared, Ada . Text_IO . The absence of the end of line \n can also be noted, as Put_Line always terminates by an end of line.

The Ada Syntax 

Ada syntax might seem peculiar at first glance. Unlike many other languages, it's not derived from the popular C style of notation with its ample use of brackets; rather, it uses a more expository syntax coming from Pascal. In many ways, Ada is a more explicit language — its syntax was designed to increase readability and maintainability, rather than making it faster to write in a condensed manner. For example:

full words like begin and end are used in place of curly braces.

Conditions are written using if , then , elsif , else , and end if .

Ada's assignment operator does not double as an expression, eliminating potential mistakes that could be caused by = being used where == should be.

All languages provide one or more ways to express comments. In Ada, two consecutive hyphens -- mark the start of a comment that continues to the end of the line. This is exactly the same as using // for comments in C. Multi line comments like C's /* */ do not exist in Ada.

Ada compilers are stricter with type and range checking than most C programmers are used to. Most beginning Ada programmers encounter a variety of warnings and error messages when coding, but this helps detect problems and vulnerabilities at compile time — early on in the development cycle. In addition, checks (such as array bounds checks) provide verification that could not be done at compile time but can be performed either at run-time, or through formal proof (with the SPARK tooling).

Ada identifiers and reserved words are case insensitive. The identifiers VAR , var and VaR are treated as the same identifier; likewise begin , BEGIN , Begin , etc. Identifiers may include letters, digits, and underscores, but must always start with a letter. There are 73 reserved keywords in Ada that may not be used as identifiers, and these are:

abort else null select abs elsif of separate abstract end or some accept entry others subtype access exception out synchronized aliased exit overriding tagged all for package task and function pragma terminate array generic private then at goto procedure type begin if protected until body in raise use case interface range when constant is record while declare limited rem with delay loop renames xor delta mod requeue digits new return do not reverse

Compilation Unit Structure 

Both C and Ada were designed with the idea that the code specification and code implementation could be separated into two files. In C, the specification typically lives in the .h, or header file, and the implementation lives in the .c file. Ada is superficially similar to C. With the GNAT toolchain, compilation units are stored in files with an .ads extension for specifications and with an .adb extension for implementations.

One main difference between the C and Ada compilation structure is that Ada compilation units are structured into something called packages.

The package is the basic modularization unit of the Ada language, as is the class for Java and the header and implementation pair for C. A specification defines a package and the implementation implements the package. We saw this in an earlier example when we included the Ada . Text_IO package into our application. The package specification has the structure:

The package implementation, or body, has the structure:

Declaration Protection 

An Ada package contains three parts that, for GNAT, are separated into two files: .ads files contain public and private Ada specifications, and .adb files contain the implementation, or Ada bodies.

Private types are useful for preventing the users of a package's types from depending on the types' implementation details. Another use-case is the prevention of package users from accessing package state/data arbitrarily. The private reserved word splits the package spec into public and private parts. For example:

Subprograms declared above the private separator (such as P ) will be visible to the package user, and the ones below (such as Q ) will not. The body of the package, the implementation, has access to both parts. A package specification does not require a private section.

Hierarchical Packages 

Ada packages can be organized into hierarchies. A child unit can be declared in the following way:

Here, Root . Child is a child package of Root . The public part of Root . Child has access to the public part of Root . The private part of Child has access to the private part of Root , which is one of the main advantages of child packages. However, there is no visibility relationship between the two bodies. One common way to use this capability is to define subsystems around a hierarchical naming scheme.

Using Entities from Packages 

Entities declared in the visible part of a package specification can be made accessible using a with clause that references the package, which is similar to the C #include directive. After a with clause makes a package available, references to the package contents require the name of the package as a prefix, with a dot after the package name. This prefix can be omitted if a use clause is employed.

In contrast to C, the Ada with clause is a semantic inclusion mechanism rather than a text inclusion mechanism; for more information on this difference please refer to Packages .

Statements and Declarations 

The following code samples are all equivalent, and illustrate the use of comments and working with integer variables:

You'll notice that, in both languages, statements are terminated with a semicolon. This means that you can have multi-line statements.

The shortcuts of incrementing and decrementing

You may have noticed that Ada does not have something similar to the a ++ or a -- operators. Instead you must use the full assignment A := A + 1 or A := A - 1 .

In the Ada example above, there are two distinct sections to the procedure Main . This first section is delimited by the is keyword and the begin keyword. This section is called the declarative block of the subprogram. The declarative block is where you will define all the local variables which will be used in the subprogram. C89 had something similar, where developers were required to declare their variables at the top of the scope block. Most C developers may have run into this before when trying to write a for loop:

For the fun of it, let's also see the Ada way to do this:

We will explore more about the syntax of loops in Ada in a future section of this course; but for now, notice that the I variable used as the loop index is not declared in the declarative section!

Declaration Flippy Floppy

Something peculiar that you may have noticed about declarations in Ada is that they are backwards from the way C does declarations. The C language expects the type followed by the variable name. Ada expects the variable name followed by a colon and then the type.

The next block in the Ada example is between the begin and end keywords. This is where your statements will live. You can create new scopes by using the declare keyword:

Notice that we declared a new variable E whose scope only exists in our newly defined block. The equivalent C code is:

Fun Fact about the C language assignment operator = : Did you know that an assignment in C can be used in an expression? Let's look at an example:

Run the above code example. What does it output? Is that what you were expecting?

The author of the above code example probably meant to test if a == 10 in the if statement but accidentally typed = instead of == . Because C treats assignment as an expression, it was able to evaluate a = 10 .

Let's look at the equivalent Ada code:

The above code will not compile. This is because Ada does no allow assignment as an expression.

The "use" clause

You'll notice in the above code example, after with Ada.Text_IO ; there is a new statement we haven't seen before — use Ada.Text_IO ; . You may also notice that we are not using the Ada . Text_IO prefix before the Put_Line statements. When we add the use clause it tells the compiler that we won't be using the prefix in the call to subprograms of that package. The use clause is something to use with caution. For example: if we use the Ada . Text_IO package and we also have a Put_Line subprogram in our current compilation unit with the same signature, we have a (potential) collision!

Conditions 

The syntax of an if statement:

In Ada, everything that appears between the if and then keywords is the conditional expression, no parentheses are required. Comparison operators are the same except for:

The syntax of a switch/case statement:

Switch or Case?

A switch statement in C is the same as a case statement in Ada. This may be a little strange because C uses both keywords in the statement syntax. Let's make an analogy between C and Ada: C's switch is to Ada's case as C's case is to Ada's when .

Notice that in Ada, the case statement does not use the break keyword. In C, we use break to stop the execution of a case branch from falling through to the next branch. Here is an example:

Run the above code with v = 0 . What prints? What prints when we change the assignment to v = 1 ?

When v = 0 the program outputs the strings Zero then One then Other . This is called fall through. If you add the break statements back into the switch you can stop this fall through behavior from happening. The reason why fall through is allowed in C is to allow the behavior from the previous example where we want a specific branch to execute for multiple inputs. Ada solves this a different way because it is possible, or even probable, that the developer might forget a break statement accidentally. So Ada does not allow fall through. Instead, you can use Ada's syntax to identify when a specific branch can be executed by more than one input. If you want a range of values for a specific branch you can use the First .. Last notation. If you want a few non-consecutive values you can use the Value1 | Value2 | Value3 notation.

Instead of using the word default to denote the catch-all case, Ada uses the others keyword.

Let's start with some syntax:

The loop syntax in Ada is pretty straightforward. The loop and end loop keywords are used to open and close the loop scope. Instead of using the break keyword to exit the loop, Ada has the exit statement. The exit statement can be combined with a logic expression using the exit when syntax.

The major deviation in loop syntax is regarding for loops. You'll notice, in C, that you sometimes declare, and at least initialize a loop counter variable, specify a loop predicate, or an expression that indicates when the loop should continue executing or complete, and last you specify an expression to update the loop counter.

In Ada, you don't declare or initialize a loop counter or specify an update expression. You only name the loop counter and give it a range to loop over. The loop counter is read-only ! You cannot modify the loop counter inside the loop like you can in C. And the loop counter will increment consecutively along the specified range. But what if you want to loop over the range in reverse order?

Strangely enough, Ada people call the single apostrophe symbol, ' , "tick". This "tick" says the we are accessing an attribute of the variable. When we do ' Img on a variable of a numerical type, we are going to return the string version of that numerical type. So in the for loop above, I ' Img , or "I tick image" will return the string representation of the numerical value stored in I. We have to do this because Put_Line is expecting a string as an input parameter.

We'll discuss attributes in more details later in this chapter .

In the above example, we are traversing over the range in reverse order. In Ada, we use the reverse keyword to accomplish this.

In many cases, when we are writing a for loop, it has something to do with traversing an array. In C, this is a classic location for off-by-one errors. Let's see an example in action:

The above Ada and C code should initialize an array using a for loop. The initial values in the array should be contiguously decreasing from 99 to 0 as we index from the first index to the last index. In other words, the first index has a value of 99, the next has 98, the next 97 ... the last has a value of 0.

If you run both the C and Ada code above you'll notice that the outputs of the two programs are different. Can you spot why?

In the C code there are two problems:

There's a buffer overflow in the first iteration of the loop. We would need to modify the loop initialization to int i = LIST_LENGTH - 1 ; . The loop predicate should be modified to i >= 0 ;

The C code also has another off-by-one problem in the math to compute the value stored in list [ i ] . The expression should be changed to be list [ i ] = LIST_LENGTH - i - 1 ; .

These are typical off-by-one problems that plagues C programs. You'll notice that we didn't have this problem with the Ada code because we aren't defining the loop with arbitrary numeric literals. Instead we are accessing attributes of the array we want to manipulate and are using a keyword to determine the indexing direction.

We can actually simplify the Ada for loop a little further using iterators:

In the second for loop, we changed the syntax to for I of List . Instead of I being the index counter, it is now an iterator that references the underlying element. This example of Ada code is identical to the last bit of Ada code. We just used a different method to index over the second for loop. There is no C equivalent to this Ada feature, but it is similar to C++'s range based for loop.

Type System 

Strong typing .

Ada is considered a "strongly typed" language. This means that the language does not define any implicit type conversions. C does define implicit type conversions, sometimes referred to as integer promotion . The rules for promotion are fairly straightforward in simple expressions but can get confusing very quickly. Let's look at a typical place of confusion with implicit type conversion:

Run the above code. You will notice that a != b ! If we look at the output of the last printf statement we will see the problem. a is an unsigned number where b is a signed number. We stored a value of 0xFF in both variables, but a treated this as the decimal number 255 while b treated this as the decimal number -1 . When we compare the two variables, of course they aren't equal; but that's not very intuitive. Let's look at the equivalent Ada example:

If you try to run this Ada example you will get a compilation error. This is because the compiler is telling you that you cannot compare variables of two different types. We would need to explicitly cast one side to make the comparison against two variables of the same type. By enforcing the explicit cast we can't accidentally end up in a situation where we assume something will happen implicitly when, in fact, our assumption is incorrect.

Another example: you can't divide an integer by a float. You need to perform the division operation using values of the same type, so one value must be explicitly converted to match the type of the other (in this case the more likely conversion is from integer to float). Ada is designed to guarantee that what's done by the program is what's meant by the programmer, leaving as little room for compiler interpretation as possible. Let's have a look at the following example:

Are the three programs above equivalent? It may seem like Ada is just adding extra complexity by forcing you to make the conversion from Integer to Float explicit. In fact, it significantly changes the behavior of the computation. While the Ada code performs a floating point operation 1.0 / 10.0 and stores 0.1 in Result , the C version instead store 0.0 in result . This is because the C version perform an integer operation between two integer variables: 1 / 10 is 0. The result of the integer division is then converted to a float and stored. Errors of this sort can be very hard to locate in complex pieces of code, and systematic specification of how the operation should be interpreted helps to avoid this class of errors. If an integer division was actually intended in the Ada case, it is still necessary to explicitly convert the final result to Float :

The complete example would then be:

Floating Point Literals

In Ada, a floating point literal must be written with both an integral and decimal part. 10 is not a valid literal for a floating point value, while 10.0 is.

Language-Defined Types 

The principal scalar types predefined by Ada are Integer , Float , Boolean , and Character . These correspond to int , float , int (when used for Booleans), and char , respectively. The names for these types are not reserved words; they are regular identifiers. There are other language-defined integer and floating-point types as well. All have implementation-defined ranges and precision.

Application-Defined Types 

Ada's type system encourages programmers to think about data at a high level of abstraction. The compiler will at times output a simple efficient machine instruction for a full line of source code (and some instructions can be eliminated entirely). The careful programmer's concern that the operation really makes sense in the real world would be satisfied, and so would the programmer's concern about performance.

The next example below defines two different metrics: area and distance. Mixing these two metrics must be done with great care, as certain operations do not make sense, like adding an area to a distance. Others require knowledge of the expected semantics; for example, multiplying two distances. To help avoid errors, Ada requires that each of the binary operators + , - , * , and / for integer and floating-point types take operands of the same type and return a value of that type.

Even though the Distance and Area types above are just Float , the compiler does not allow arbitrary mixing of values of these different types. An explicit conversion (which does not necessarily mean any additional object code) is necessary.

The predefined Ada rules are not perfect; they admit some problematic cases (for example multiplying two Distance yields a Distance ) and prohibit some useful cases (for example multiplying two Distances should deliver an Area ). These situations can be handled through other mechanisms. A predefined operation can be identified as abstract to make it unavailable; overloading can be used to give new interpretations to existing operator symbols, for example allowing an operator to return a value from a type different from its operands; and more generally, GNAT has introduced a facility that helps perform dimensionality checking.

Ada enumerations work similarly to C enum :

But even though such enumerations may be implemented by the compiler as numeric values, at the language level Ada will not confuse the fact that Monday is a Day and is not an Integer . You can compare a Day with another Day , though. To specify implementation details like the numeric values that correspond with enumeration values in C you include them in the original enum declaration:

But in Ada you must use both a type definition for Day as well as a separate representation clause for it like:

Note that however, unlike C, values for enumerations in Ada have to be unique.

Type Ranges 

Contracts can be associated with types and variables, to refine values and define what are considered valid values. The most common kind of contract is a range constraint introduced with the range reserved word, for example:

In the above example, Grade is a new integer type associated with a range check. Range checks are dynamic and are meant to enforce the property that no object of the given type can have a value outside the specified range. In this example, the first assignment to G1 is correct and will not raise a run-time exception. Assigning N to G1 is illegal since Grade is a different type than Integer . Converting N to Grade makes the assignment legal, and a range check on the conversion confirms that the value is within 0 .. 100 . Assigning G1 + 10 to G2 is legal since + for Grade returns a Grade (note that the literal 10 is interpreted as a Grade value in this context), and again there is a range check.

The final assignment illustrates an interesting but subtle point. The subexpression G1 + G2 may be outside the range of Grade , but the final result will be in range. Nevertheless, depending on the representation chosen for Grade , the addition may overflow. If the compiler represents Grade values as signed 8-bit integers (i.e., machine numbers in the range - 128 .. 127 ) then the sum G1 + G2 may exceed 127, resulting in an integer overflow. To prevent this, you can use explicit conversions and perform the computation in a sufficiently large integer type, for example:

Range checks are useful for detecting errors as early as possible. However, there may be some impact on performance. Modern compilers do know how to remove redundant checks, and you can deactivate these checks altogether if you have sufficient confidence that your code will function correctly.

Types can be derived from the representation of any other type. The new derived type can be associated with new constraints and operations. Going back to the Day example, one can write:

Since these are new types, implicit conversions are not allowed. In this case, it's more natural to create a new set of constraints for the same type, instead of making completely new ones. This is the idea behind subtypes in Ada. A subtype is a type with optional additional constraints. For example:

These declarations don't create new types, just new names for constrained ranges of their base types.

The purpose of numeric ranges is to express some application-specific constraint that we want the compiler to help us enforce. More importantly, we want the compiler to tell us when that constraint cannot be met — when the underlying hardware cannot support the range given. There are two things to consider:

just a range constraint, such as A : Integer range 0 .. 10 ; , or

a type declaration, such as type Result is range 0 .. 1_000_000_000 ; .

Both represent some sort of application-specific constraint, but in addition, the type declaration promotes portability because it won't compile on targets that do not have a sufficiently large hardware numeric type. That's a definition of portability that is preferable to having something compile anywhere but not run correctly, as in C.

Unsigned And Modular Types 

Unsigned integer numbers are quite common in embedded applications. In C, you can use them by declaring unsigned int variables. In Ada, you have two options:

declare custom unsigned range types;

In addition, you can declare custom range subtypes or use existing subtypes such as Natural .

declare custom modular types.

The following table presents the main features of each type. We discuss these types right after.

When declaring custom range types in Ada, you may use the full range in the same way as in C. For example, this is the declaration of a 32-bit unsigned integer type and the X variable in Ada:

In C, when unsigned int has a size of 32 bits, this corresponds to the following declaration:

Another strategy is to declare subtypes for existing signed types and specify just the range that excludes negative numbers. For example, let's declare a custom 32-bit signed type and its unsigned subtype:

In this case, we're just skipping the sign bit of the Signed_Int_32 type. In other words, while Signed_Int_32 has a size of 32 bits, Unsigned_Int_31 has a range of 31 bits, even if the base type has 32 bits.

Note that the declaration above is actually similar to the existing Natural subtype. Ada provides the following standard subtypes:

Since they're standard subtypes, you can declare variables of those subtypes directly in your implementation, in the same way as you can declare Integer variables.

As indicated in the table above, however, there is a difference in behavior for the variables we just declared, which occurs in case of overflow. Let's consider this C example:

The corresponding code in Ada raises an exception:

While the C uses modulo arithmetic for unsigned integer, Ada doesn't use it for the Unsigned_Int_32 type. Ada does, however, support modular types via type definitions using the mod keyword. In this example, we declare a 32-bit modular type:

In this case, the behavior is the same as in the C declaration above.

Modular types, unlike Ada's signed integers, also provide bit-wise operations, a typical application for unsigned integers in C. In Ada, you can use operators such as and , or , xor and not . You can also use typical bit-shifting operations, such as Shift_Left , Shift_Right , Shift_Right_Arithmetic , Rotate_Left and Rotate_Right .

Attributes 

Attributes start with a single apostrophe ("tick"), and they allow you to query properties of, and perform certain actions on, declared entities such as types, objects, and subprograms. For example, you can determine the first and last bounds of scalar types, get the sizes of objects and types, and convert values to and from strings. This section provides an overview of how attributes work. For more information on the many attributes defined by the language, you can refer directly to the Ada Language Reference Manual.

The ' Image and ' Value attributes allow you to transform a scalar value into a String and vice-versa. For example:

Semantically, attributes are equivalent to subprograms. For example, Integer ' Image is defined as follows:

Certain attributes are provided only for certain kinds of types. For example, the ' Val and ' Pos attributes for an enumeration type associates a discrete value with its position among its peers. One circuitous way of moving to the next character of the ASCII table is:

A more concise way to get the next value in Ada is to use the ' Succ attribute:

You can get the previous value using the ' Pred attribute. Here is the equivalent in C:

Other interesting examples are the ' First and ' Last attributes which, respectively, return the first and last values of a scalar type. Using 32-bit integers, for instance, Integer ' First returns -2 31 and Integer ' Last returns 2 31 - 1.

Arrays and Strings 

C arrays are pointers with offsets, but the same is not the case for Ada. Arrays in Ada are not interchangeable with operations on pointers, and array types are considered first-class citizens. They have dedicated semantics such as the availability of the array's boundaries at run-time. Therefore, unhandled array overflows are impossible unless checks are suppressed. Any discrete type can serve as an array index, and you can specify both the starting and ending bounds — the lower bound doesn't necessarily have to be 0. Most of the time, array types need to be explicitly declared prior to the declaration of an object of that array type.

Here's an example of declaring an array of 26 characters, initializing the values from ' a ' to ' z ' :

In C, only the size of the array is given during declaration. In Ada, array index ranges are specified using two values of a discrete type. In this example, the array type declaration specifies the use of Integer as the index type, but does not provide any constraints (use <> , pronounced box , to specify "no constraints"). The constraints are defined in the object declaration to be 1 to 26, inclusive. Arrays have an attribute called ' Range . In our example, Arr ' Range can also be expressed as Arr ' First .. Arr ' Last ; both expressions will resolve to 1 .. 26 . So the ' Range attribute supplies the bounds for our for loop. There is no risk of stating either of the bounds incorrectly, as one might do in C where I <= 26 may be specified as the end-of-loop condition.

As in C, Ada String is an array of Character . Ada strings, importantly, are not delimited with the special character '0' like they are in C. It is not necessary because Ada uses the array's bounds to determine where the string starts and stops.

Ada's predefined String type is very straightforward to use:

Unlike C, Ada does not offer escape sequences such as 'n' . Instead, explicit values from the ASCII package must be concatenated (via the concatenation operator, & ). Here for example, is how to initialize a line of text ending with a new line:

You see here that no constraints are necessary for this variable definition. The initial value given allows the automatic determination of My_String 's bounds.

Ada offers high-level operations for copying, slicing, and assigning values to arrays. We'll start with assignment. In C, the assignment operator doesn't make a copy of the value of an array, but only copies the address or reference to the target variable. In Ada, the actual array contents are duplicated. To get the above behavior, actual pointer types would have to be defined and used.

In all of the examples above, the source and destination arrays must have precisely the same number of elements. Ada allows you to easily specify a portion, or slice, of an array. So you can write the following:

This assigns the 4th, 5th, and 6th elements of A1 into the 1st, 2nd, and 3rd elements of A2 . Note that only the length matters here: the values of the indexes don't have to be equal; they slide automatically.

Ada also offers high level comparison operations which compare the contents of arrays as opposed to their addresses:

You can assign to all the elements of an array in each language in different ways. In Ada, the number of elements to assign can be determined by looking at the right-hand side, the left-hand side, or both sides of the assignment. When bounds are known on the left-hand side, it's possible to use the others expression to define a default value for all the unspecified array elements. Therefore, you can write:

In this example, we're specifying that A1 has a range between -2 and 42. We use ( others => 0 ) to initialize all array elements with zero. In the next example, the number of elements is determined by looking at the right-hand side:

Since A1 is initialized with an aggregate of 9 elements, A1 automatically has 9 elements. Also, we're not specifying any range in the declaration of A1 . Therefore, the compiler uses the default range of the underlying array type Arr_Type , which has an unconstrained range based on the Integer type. The compiler selects the first element of that type ( Integer ' First ) as the start index of A1 . If you replaced Integer range <> in the declaration of the Arr_Type by Positive range <> , then A1 's start index would be Positive ' First — which corresponds to one.

Heterogeneous Data Structures 

The structure corresponding to a C struct is an Ada record . Here are some simple records:

Ada allows specification of default values for fields just like C. The values specified can take the form of an ordered list of values, a named list of values, or an incomplete list followed by others => <> to specify that fields not listed will take their default values. For example:

As a foreword to the topic of pointers, it's important to keep in mind the fact that most situations that would require a pointer in C do not in Ada. In the vast majority of cases, indirect memory management can be hidden from the developer and thus saves from many potential errors. However, there are situation that do require the use of pointers, or said differently that require to make memory indirection explicit. This section will present Ada access types, the equivalent of C pointers. A further section will provide more details as to how situations that require pointers in C can be done without access types in Ada.

We'll continue this section by explaining the difference between objects allocated on the stack and objects allocated on the heap using the following example:

There are many commonalities between the Ada and C semantics above. In Ada and C, objects are allocated on the stack and are directly accessed. V1 and V2 are two different objects and the assignment statement copies the value of V1 into V2 . V1 and V2 are two distinct objects.

Here's now a similar example, but using heap allocation instead:

In this example, an object of type R is allocated on the heap. The same object is then referred to through V1 and V2 . As in C, there's no garbage collector in Ada, so objects allocated by the new operator need to be expressly freed (which is not the case here).

Dereferencing is performed automatically in certain situations, for instance when it is clear that the type required is the dereferenced object rather than the pointer itself, or when accessing record members via a pointer. To explicitly dereference an access variable, append . all . The equivalent of V1 -> A in C can be written either as V1 . A or V1 . all . A .

Pointers to scalar objects in Ada and C look like:

In Ada, an initializer can be specified with the allocation by appending '( value ) :

When using Ada pointers to reference objects on the stack, the referenced objects must be declared as being aliased. This directs the compiler to implement the object using a memory region, rather than using registers or eliminating it entirely via optimization. The access type needs to be declared as either access all (if the referenced object needs to be assigned to) or access constant (if the referenced object is a constant). The ' Access attribute works like the C & operator to get a pointer to the object, but with a scope accessibility check to prevent references to objects that have gone out of scope. For example:

To deallocate objects from the heap in Ada, it is necessary to use a deallocation subprogram that accepts a specific access type. A generic procedure is provided that can be customized to fit your needs, it's called Ada . Unchecked_Deallocation . To create your customized deallocator (that is, to instantiate this generic), you must provide the object type as well as the access type as follows:

We'll discuss generics later in this section .

Functions and Procedures 

General form .

Subroutines in C are always expressed as functions which may or may not return a value. Ada explicitly differentiates between functions and procedures. Functions must return a value and procedures must not. Ada uses the more general term subprogram to refer to both functions and procedures.

Parameters can be passed in three distinct modes:

in , which is the default, is for input parameters, whose value is provided by the caller and cannot be changed by the subprogram.

out is for output parameters, with no initial value, to be assigned by the subprogram and returned to the caller.

in out is a parameter with an initial value provided by the caller, which can be modified by the subprogram and returned to the caller (more or less the equivalent of a non-constant pointer in C).

Ada also provides access and aliased parameters, which are in effect explicit pass-by-reference indicators.

In Ada, the programmer specifies how the parameter will be used and in general the compiler decides how it will be passed (i.e., by copy or by reference). C has the programmer specify how to pass the parameter.

There are some exceptions to the "general" rule in Ada. For example, parameters of scalar types are always passed by copy, for all three modes.

Here's a first example:

The first two declarations for Proc and Func are specifications of the subprograms which are being provided later. Although optional here, it's still considered good practice to separately define specifications and implementations in order to make it easier to read the program. In Ada and C, a function that has not yet been seen cannot be used. Here, Proc can call Func because its specification has been declared.

Parameters in Ada subprogram declarations are separated with semicolons, because commas are reserved for listing multiple parameters of the same type. Parameter declaration syntax is the same as variable declaration syntax (except for the modes), including default values for parameters. If there are no parameters, the parentheses must be omitted entirely from both the declaration and invocation of the subprogram.

In Ada 202X

Ada 202X allows for using static expression functions, which are evaluated at compile time. To achieve this, we can use an aspect — we'll discuss aspects later in this chapter .

An expression function is static when the Static aspect is specified. For example:

In this example, we declare X1 using an expression. In the declaration of X2 , we call the static expression function If_Then_Else . Both X1 and X2 have the same constant value.

Overloading 

In C, function names must be unique. Ada allows overloading, in which multiple subprograms can share the same name as long as the subprogram signatures (the parameter types, and function return types) are different. The compiler will be able to resolve the calls to the proper routines or it will reject the calls. For example:

The Ada compiler knows that an assignment to C requires a Code value. So, it chooses the Get function that returns a Code to satisfy this requirement.

Operators in Ada are functions too. This allows you to define local operators that override operators defined at an outer scope, and provide overloaded operators that operate on and compare different types. To declare an operator as a function, enclose its "name" in quotes:

Aspect specifications allow you to define certain characteristics of a declaration using the with keyword after the declaration:

For example, you can inline a subprogram by specifying the Inline aspect:

We'll discuss inlining later in this course .

Aspect specifications were introduced in Ada 2012. In previous versions of Ada, you had to use a pragma instead. The previous example would be written as follows:

Aspects and attributes might refer to the same kind of information. For example, we can use the Size aspect to define the expected minimum size of objects of a certain type:

In the same way, we can use the size attribute to retrieve the size of a type or of an object:

We'll explain both Size aspect and Size attribute later in this course .

Ada Programming/Variables

• 1 Assignment statements
• 3.1 Ada Reference Manual

Variables are references that stand in for a value that is contained at a certain memory address.

Variables are said to have a value and may have a data type . If a variable has a type, then only values of this type may be assigned to it. Variables do not always have a type.

A value can have many values of many different types: integers (7), ratios (1/2), (approximations of) reals (10.234), complex numbers (4+2i), characters ('a'), strings ("hello"), and much more.

Different languages use different names for their types and may not include any of the above.

Assignment statements

An assignment statement is used to set a variable to a new value.

Assignment statements are written as name := value .

The example set the variable X to the integer value of 10 . The assignment statement overwrites the contents of the variable and the previous value is lost.

In some languages, before a variable can be used, it will have to be declared, where the declaration specifies the type.

Ada is the same. The declaration is as follows:

Variables store everything in your program. The purpose of any useful program is to modify variables.

Without variables, we would not be able to create programs that go much beyond the classic "Hello World!" example. Variables in Ada must be declared. They cannot just magically appear in a program without first having been declared. A variable declaration looks like this:

If a variable is assigned a value when declared, it is said to be initialized. It is possible to declare more than one variable of the same type in one go by comma-separating the variable names:

As you can see, the assignment of a value to a variable is optional. All the compiler needs to know, is what kind of data (the type ) you intend the variable to hold. It doesn't care if there's actual data in the variable or not. When you declare a variable, you're basically just asking for a specific amount of memory to be set aside. The actual amount of memory depends, of course, on the declared type . An Integer might take up 4 bytes of memory, and a String (1 .. 10) might take up 10 bytes of memory. The variable name is nothing more than a symbolic name, associated with whatever value that is placed in the memory reserved to the variable.

If we were to assign a value to a variable during its declaration, it would look like this:

Let's try it with some real Ada variables. As seen above, a variable in Ada **must** be declared as pointing to a specific type of data:

Here we declare the variable A_String_Variable as a String type, the length of which is 10 characters, (1 .. 10) . Lets see how it looks if we assign a value to A_String_Variable during its declaration:

Here we've first declared and then initialized the A_String_Variable variable.

In the case of the String type, the length can be omitted and we can instead simply write:

Here the assignment of "abcdefghij" implicitly declares A_String_Variable to be of length (1 .. 10) , because that is the length of the assigned string.

Variables can be declared as any type , be it String , Integer , records , array or homegrown types. Lets try and declare a variety of variables:

Notice the homegrown Colors type. First we declare the new type, and then we declare the Color variable the of that type. This is one of the biggest strengths of Ada: The ability to declare your own types and subtypes. More can be found on this subject in the Type System article.

Now, let's try and use the above declared variables in an actual program:

When executed, the above program should output the following:

Here we can actually see why variables are called variables: Their values vary.

Notice how we are able to change the data contained in, for example, the A_String variable. When we declare it, we assign the value A_String (the variable is said to be initialized), but a little later we assign another value to A_String : String_A . That right there is the core concept of variables that every beginning programmer must understand: Variables vary. A variable name is just a reference to a place in memory where a a specified type of data resides. The exact data can, and probably will, change a lot during the run of a program, but the variable name and the type remains the same.

If a variable doesn't change during program execution, then we have a better option: A constant . These are the stiff upper lip siblings of variables.

Finally, let's take a short look at variable scope in regard to blocks. When and where are they visible? This is perhaps best understood by a simple program:

The output we get from the above looks like this:

Note how Name is declared as a local variable in the first block. The declaration in the first block does not in any way interfere with the "global" Name variable. If no Name variable is declared for a block, the "global" Name variable is used, as can be seen in the final block, where Thomas Løcke is printed, even though no such assignment has been done in the block.

So variable scope in regard to blocks is very straightforward: Blocks inherit variables from their parent(s) and these can then be overridden locally in the block by declaring the variable anew.

Ada Reference Manual

• 3.3 Objects and Named Numbers ( Annotated )

• Book:Ada Programming
• Book:Ada Programming/Pages containing deprecated templates

Navigation menu

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

How to have multiple conditionals in an if statement in Ada

How would I go about having multiple conditionals in an if statement?

Eg. The user is asked a set of questions by the program:

1.) Enter an altitude between 0 and 1000

(user types in data)

2.) Enter Velocity between 0 and 500

3.) Enter Temperature between 0 and 200

the program then prints back

• altitude = user value
• velocity = user value
• temperature = user value //ignore those list numbers

I have set in my (.ads) file that each of these ranges has a criticle value.

I want to create an if statement that has multiple conditionals. in pseudo : If velocity = critical velocity & temperature = critical temperature & altitude = critical altitude then print ("some message") else do nothing

• if-statement
• conditional-statements

2 Answers 2

The syntax of an if-statement is

and the syntax of “condition” is

(that is, an expression which happens to be boolean); the syntax of “expression” is

so your code would look like

You can leave out the else clause, and you can say and then instead of plain and if for some reason you shouldn’t check the rest of the condition if the first part is already False . This is called short-circuit evaluation, and it’s not the default in Ada (it is in C).

evaluates Y / X even if X is 0.

• Thank you Simon! A very iterative breakdown, very helpful :) –  DaveSwans Commented Apr 30, 2016 at 14:40
• here is a link to another question that I couldnt ask in the comments because it was too long for a comment. If you could please shed some light it would be much appreciated. stackoverflow.com/questions/36957726/… –  DaveSwans Commented Apr 30, 2016 at 17:04

In Ada you will use the and , or and not boolean operator:

When evaluation order matters, you will use the and then or the or else syntax (otherwise the compiler can change order for optimization). Expressions will be evaluated in the 'and then'/'or else' order.

With an or else , you may write as follows:

Beware that you cannot mix and and or together (because this leads to many confusion for developers). You have to use parenthesis arround them if you do it.

• There is also xor. –  darkestkhan Commented Apr 29, 2016 at 6:12

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged if-statement conditional-statements ada or ask your own question .

• Featured on Meta
• We spent a sprint addressing your requests — here’s how it went
• Upcoming initiatives on Stack Overflow and across the Stack Exchange network...
• The [lib] tag is being burninated
• What makes a homepage useful for logged-in users

Hot Network Questions

• Plastic plugs used to fasten cover over radiator
• Decorate equations with arrows using TikZ
• What does "that" in "No one ever meant that, Drax" refer to?
• Why does the length of an antenna matter when electromagnetic waves propagate perpendicular to the antenna?
• firefox returns odd results for file:/// or file:///tmp
• Did Joe Biden refer to himself as a black woman?
• Optimizing Pi Estimation Code
• Does closedness of the image of unit sphere imply the closed range of the operator
• Can I access Apple ID setting in mac by terminal, how?
• Why does black have a higher win rate here?
• Does it make sense to use a skyhook to launch and deorbit mega-satellite constellations now?
• Making space for contents inserted by tikzpicture
• Apex Batch QueryLocator : SOQL statements cannot query aggregate relationships more than 1 level away from the root entity object
• Everything has a tiny nuclear reactor in it. How much of a concern are illegal nuclear bombs?
• Splitting Scalar into Holomorphic and Anti-Holomorphic Parts
• custom PCB design for UART-TTL to STM32
• Was I wrongfully denied boarding for a flight where the airliner lands to a gate that doesn't directly connect to the international part the airport?
• Who is the woman who speaks when the Ravagers stop the Benatar?
• Running command with pipe and spaces on PowerShell using `wsl`
• Do you always experience the gravitational influence of other mass as you see them in your frame?
• Why do Electric Aircraft Seem to Eschew Photovoltaics?
• When selling a machine with proprietary software that links against an LGPLv3 library, do I need to give the customer root access?
• In a sum of high-variance lognormals, what fraction comes from the first term?
• Job talk Q&A: handling the room vs. being respectful

Official websites use .gov

A .gov website belongs to an official government organization in the United States.

Secure .gov websites use HTTPS

A lock ( ) or https:// means you've safely connected to the .gov website. Share sensitive information only on official, secure websites.

CDC Updates RSV Vaccination Recommendation for Adults

For the upcoming respiratory virus season, CDC recommends everyone age 75 and older receive the RSV vaccine

For Immediate Release, Wednesday, June 26, 2024 Contact: Media Relations (404) 639-3286 [email protected]  

Today, CDC updated its recommendation for the use of Respiratory Syncytial Virus (RSV) vaccines in people ages 60 and older. For this upcoming respiratory virus season, CDC recommends:

• Everyone ages 75 and older receive the RSV vaccine.
• People ages 60–74 who are at increased risk of severe RSV, meaning they have certain chronic medical conditions, such as lung or heart disease, or they live in nursing homes, receive the RSV vaccine.

This recommendation is for adults who did not get an RSV vaccine last year. The RSV vaccine is not currently an annual vaccine, meaning people do not need to get a dose every RSV season. Eligible adults can get an RSV vaccine at any time, but the best time to get vaccinated is in late summer and early fall before RSV usually starts to spread in communities.

Today’s updated recommendation for people 60 and older replaces the recommendation made last year to simplify RSV vaccine decision-making for clinicians and the public.

Immunizations were available last year for the first time to protect people at increased risk for severe RSV, including infants and young children, and people ages 60 and older. Today’s updated recommendation is based on analyses of RSV disease burden among people 60 and older, as well as RSV vaccine effectiveness and cost-effectiveness studies. Those studies included the first real-world data since RSV vaccines were recommended for people 60 and older.

Healthcare providers should recommend RSV vaccines to their eligible patients, as well as discuss what other vaccines they will need this fall to help prevent respiratory infections.

The following is attributable to CDC Director Dr. Mandy Cohen:

“The CDC has updated its RSV vaccination recommendation for older adults to prioritize those at highest risk for serious illness from RSV,” said Mandy Cohen, M.D., M.P.H. “People 75 or older, or between 60-74 with certain chronic health conditions or living in a nursing home should get one dose of the RSV vaccine to provide an extra layer of protection.”

### U.S. DEPARTMENT OF HEALTH AND HUMAN SERVICES

Whether diseases start at home or abroad, are curable or preventable, chronic or acute, or from human activity or deliberate attack, CDC’s world-leading experts protect lives and livelihoods, national security and the U.S. economy by providing timely, commonsense information, and rapidly identifying and responding to diseases, including outbreaks and illnesses. CDC drives science, public health research, and data innovation in communities across the country by investing in local initiatives to protect everyone’s health.

To receive email updates about this page, enter your email address:

• Data & Statistics
• Freedom of Information Act Office

Exit Notification / Disclaimer Policy

• The Centers for Disease Control and Prevention (CDC) cannot attest to the accuracy of a non-federal website.
• Linking to a non-federal website does not constitute an endorsement by CDC or any of its employees of the sponsors or the information and products presented on the website.
• You will be subject to the destination website's privacy policy when you follow the link.
• CDC is not responsible for Section 508 compliance (accessibility) on other federal or private website.

5.3 If Statements

This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue

[An if_statement selects for execution at most one of the enclosed sequences _ of _ statements , depending on the (truth) value of one or more corresponding condition s.]

if _ statement ::= if condition then sequence_of_statements { elsif condition then sequence_of_statements } [ else sequence_of_statements ] end if ;

Paragraphs 3 and 4 were deleted.

Dynamic Semantics ​

For the execution of an if_statement , the condition specified after if , and any condition s specified after elsif , are evaluated in succession (treating a final else as elsif True then ), until one evaluates to True or all condition s are evaluated and yield False. If a condition evaluates to True, then the corresponding sequence_of_statements is executed; otherwise, none of them is executed.

The part about all evaluating to False can't happen if there is an else , since that is herein considered equivalent to elsif True then .

Examples of if statements:

if Month = December and Day = 31 then Month := January; Day := 1; Year := Year + 1; end if; 8 if Line _ Too _ Short then raise Layout _ Error; elsif Line _ Full then New _ Line; Put(Item); else Put(Item); end if; 9 if My _ Car.Owner.Vehicle /= My _ Car then -- see 3.10.1 Report ("Incorrect data"); end if;

Wording Changes from Ada 2005 ​

Moved definition of condition to 4.5.7 in order to eliminate a forward reference.

Hyperglycemic Crises in Adults With Diabetes: A Consensus Report

• Split-Screen
• Article contents
• Figures & tables
• Supplementary Data
• Peer Review
• Open the PDF for in another window
• Cite Icon Cite
• Get Permissions

Guillermo E. Umpierrez , Georgia M. Davis , Nuha A. ElSayed , Gian Paolo Fadini , Rodolfo J. Galindo , Irl B. Hirsch , David C. Klonoff , Rozalina G. McCoy , Shivani Misra , Robert A. Gabbay , Raveendhara R. Bannuru , Ketan K. Dhatariya; Hyperglycemic Crises in Adults With Diabetes: A Consensus Report. Diabetes Care 2024; dci240032. https://doi.org/10.2337/dci24-0032

Download citation file:

• Ris (Zotero)
• Reference Manager

The American Diabetes Association (ADA), European Association for the Study of Diabetes (EASD), Joint British Diabetes Societies for Inpatient Care (JBDS), American Association of Clinical Endocrinology (AACE), and Diabetes Technology Society (DTS) convened a panel of internists and diabetologists to update the ADA consensus statement on hyperglycemic crises in adults with diabetes, published in 2001 and last updated in 2009. The objective of this consensus report is to provide up-to-date knowledge about the epidemiology, pathophysiology, clinical presentation, and recommendations for the diagnosis, treatment, and prevention of diabetic ketoacidosis (DKA) and hyperglycemic hyperosmolar state (HHS) in adults. A systematic examination of publications since 2009 informed new recommendations. The target audience is the full spectrum of diabetes health care professionals and individuals with diabetes.

This consensus report is fully endorsed by the American Diabetes Association (ADA), European Association for the Study of Diabetes (EASD), American Association of Clinical Endocrinology (AACE), Joint British Diabetes Societies for Inpatient Care (JBDS), and Diabetes Technology Society (DTS).

This consensus report was reviewed and endorsed by the ADA Professional Practice Committee and the EASD Committee on Clinical Affairs and approved by the EASD Executive Board, AACE, JBDS Group, and DTS.

This article is being simultaneously published in Diabetes Care ( https://doi.org/10.2337/dci24-0032 ) and Diabetologia ( https://doi.org/10.1007/s00125-024-06183-8 ) by the ADA and the EASD.

A consensus report is a document on a particular topic that is authored by a technical expert panel under the auspices of ADA. The document does not reflect the official ADA position but rather represents the panel’s collective analysis, evaluation, and expert opinion. The primary objective of a consensus report is to provide clarity and insight on a medical or scientific matter related to diabetes for which the evidence is contradictory, emerging, or incomplete. The report also aims to highlight evidence gaps and to propose avenues for future research. Consensus reports undergo a formal review process, including external peer review and review by the ADA Professional Practice Committee and ADA scientific team for publication.

Email alerts

• Online ISSN 1935-5548
• Print ISSN 0149-5992
• Diabetes Care
• Clinical Diabetes
• Diabetes Spectrum
• Standards of Medical Care in Diabetes
• Scientific Sessions Abstracts
• BMJ Open Diabetes Research & Care
• ShopDiabetes.org
• ADA Professional Books

Clinical Compendia

• Clinical Compendia Home
• Latest News
• DiabetesPro SmartBrief
• Special Collections
• DiabetesPro®
• Diabetes Food Hub™
• Insulin Affordability
• Know Diabetes By Heart™
• About the ADA
• Journal Policies
• For Reviewers
• Advertising in ADA Journals
• Reprints and Permission for Reuse
• Copyright Notice/Public Access Policy
• ADA Professional Membership
• ADA Member Directory
• Diabetes.org
• X (Twitter)
• Cookie Policy
• Accessibility
• Terms & Conditions
• Get Adobe Acrobat Reader
• © Copyright American Diabetes Association

This Feature Is Available To Subscribers Only

Sign In or Create an Account

You're signed out

Sign in to ask questions, follow content, and engage with the Community

• Canvas Ideas and Themes
• Canvas Ideas

Step-by-step reminders for multipart assignments

• Subscribe to RSS Feed
• Mark as New
• Mark as Read
• Printer Friendly Page
• Report Inappropriate Content
• What is the feature development process for Instructure products?
• How do Ideas and Themes work in the Instructure Community?
• How do I participate with themes?
• What are the guidelines for submitting a new idea?
• How do I create a new idea in the Instructure Community?

Community Help

View our top guides and resources:.

To participate in the Instructure Community, you need to sign up or log in:

Breakthrough Studies on Automated Insulin Delivery and CGM for Type 2 Diabetes Unveiled at ADA Scientific Sessions

Results Demonstrate Enhanced Diabetes Management and Quality of Life with Advanced Technology

New data focused on advanced technology innovations for managing type 2 diabetes (T2D) highlight the positive impact of automated insulin delivery systems (AID) and continuous glucose monitoring (CGM) in improving glycemic control and overall diabetes management. Three studies showing advancements for type 2 diabetes were presented at the American Diabetes Association’s ® (ADA) 84th Scientific Sessions in Orlando, FL.

Of the nearly 40 million Americans with diabetes, more than 90% have type 2 diabetes. As the prevalence continues to rise globally, effective management strategies are more critical than ever. The studies showcased at the ADA Scientific Sessions emphasize the transformative potential of integrating advanced technologies into diabetes care, particularly for under-resourced populations.

"These studies represent a significant advancement in diabetes management technologies, showing substantial improvements in glycemic control and quality of life for people with type 2 diabetes," said Robert Gabbay, MD, PhD, ADA chief scientific and medical officer. “By leveraging these innovations, we can empower patients with more effective and manageable treatment options, ultimately transforming the landscape of diabetes care.”

SECURE-T2D Pivotal Trial Demonstrates Significant Benefits of Omnipod® 5 Automated Insulin Delivery System in Adults with Type 2 Diabetes

Findings from the SECURE-T2D pivotal trial, the first large-scale, multicenter study evaluating the Omnipod® 5 AID System, a novel insulin pump, in a racially diverse group of adults with type 2 diabetes were presented as a late-breaking poster.

The Omnipod 5 AID System is a tubeless insulin pump that automatically adjusts insulin delivery based on CGM data. This system aims to improve glycemic control by responding to glucose levels in real-time, reducing the burden of manual insulin dosing for people with diabetes.

The multicenter pivotal clinical trial included 305 adults aged 18-75 years with type 2 diabetes who were using various insulin regimens (basal-bolus, premix, or basal-only) and had a baseline HbA1c of less than 12.0%. After a 14-day standard therapy phase to establish baseline glycemic control, participants transitioned to 13 weeks of using the Omnipod 5 AID System. The primary endpoint was the change in HbA1c from baseline to 13 weeks. The study population was also notably diverse, with 24% Black and 22% Hispanic/Latino participants.

Key findings from the trial showed that the use of the Omnipod® 5 AID System led to a significant reduction in HbA1c levels, from a baseline average of 8.2±1.3% to 7.4±0.9% at the end of the study (treatment effect: -0.8%, 95% CI: -1.0 to -0.7, p<0.001). The greatest improvements were observed in participants with the highest baseline HbA1c.

"The results from the SECURE-T2D trial underscore the potential of the Omnipod 5 AID System to transform diabetes management for adults with type 2 diabetes,” said Francisco J. Pasquel, MD, MPH, Associate Professor of Medicine and Global Health at Emory University, and lead author of the study. “The substantial improvements in glycemic control and quality of life, particularly among minority populations, are promising steps toward more equitable diabetes care."

Future research will focus on long-term outcomes and the potential of a new solution to address other aspects of diabetes management. The authors also note that studies may explore its effectiveness in different populations and its impact on quality of life for people with type 2 diabetes. Additionally, ongoing analyses will aim to refine and enhance the system's algorithms to maximize its benefits for users.  

Improved Glycemic Outcomes with Continuous Glucose Monitoring (CGM) in Type 2 Diabetes Patients: Real-World Analysis Reveals Significant Benefits

Findings from an oral presentation, Glycemic Outcomes with CGM Use in Patients with Type 2 Diabetes—Real-World Analysis, showcase the significant impact of continuous glucose monitoring on patients with type 2 diabetes, revealing the use of CGM substantially improves glucose control in type 2 diabetes patients across all therapeutic treatments.

The study evaluated the impact of CGM on adults with type 2 diabetes using non-insulin therapies (NIT), basal insulin (BIT), and prandial insulin (PIT). This 12-month retrospective analysis used data from a large claims database of over 7.1 million type 2 diabetes patients and compared HbA1c levels before and after CGM use, focusing on the change closest to 12 months post-CGM acquisition.

Among the 6,030 adults with type 2 diabetes (NIT: 1,533; BIT: 1,375; PIT: 3,122), with a mean baseline HbA1c of 8.8% and a mean age of 59 years, significant HbA1c improvements (by 1% across all therapies) were observed across all therapy groups after 12 months. The study underscores CGM's potential to enhance glycemic control and reduce healthcare costs in both insulin and non-insulin-treated type 2 diabetes patients.

"These results suggest that CGM can play a crucial role in enhancing health outcomes for all diabetes patients, regardless of their treatment regimen," said Satish K. Garg, MD, University of Colorado Denver, and lead author of the study. "The real-world analysis underscores the potential of CGM to not only improve glycemic outcomes but also reduce healthcare resource utilization and overall healthcare costs."

Looking ahead, longer-term studies and randomized controlled trials are recommended to further validate these results and explore the broader implications of CGM use in diabetes care. Future research will focus on confirming the sustained benefits of CGM and understanding its impact on various patient subgroups to tailor diabetes management strategies effectively.

Using the same database, findings from a related late-breaking abstract reveal that CGM use in type 2 diabetes results in more than a 50% reduction in all-cause hospitalizations and acute diabetes-related hospitalizations. Dr. Garg presented the results of the late-breaking abstract, Impact of Continuous Glucose Monitoring Use on Hospitalizations in People with Type 2 Diabetes—Real-World Analysis , as an e-theatre poster on Sunday, June 23, 2024.

Continuous Glucose Monitoring (CGM) Improves Glycemic Control in Adults with Type 2 Diabetes Not Using Insulin

Findings from a new study demonstrate that CGM significantly enhances glycemic control in adults with type 2 diabetes who are not using insulin. These results, presented during the general poster session and simultaneously published in Diabetes Technology and Therapeutics , underscore the potential of CGM to improve diabetes management and support expanding CGM access for adults with type 2 diabetes not using insulin.

The real-world study analyzed data from over 3,800 adults using Dexcom G6 and G7 sensors. The participants, initially not meeting their glycemic targets, showed significant improvements after six months of CGM use, with further progress at one year.

Key findings include a 0.5% reduction in the glucose management indictor, a CGM approximation of A1C, and a 17% increase in Time in Range (TIR), which translates to an additional four hours per day spent within the target glucose range. The study also highlighted the advantages of the Dexcom High Alert feature, which notifies users when glucose levels exceed their selected targets. Participants who used this feature showed the greatest improvements in their glucose levels. The consistent CGM use over the year suggests sustained benefits and a positive impact on long-term diabetes care.

“We are encouraged by the significant long-term improvements in glycemic control observed in our study,” said Jennifer E. Layne, PhD, Dexcom. “These findings highlight the importance of CGM for managing non-insulin treated type 2 diabetes for clinicians and for patient self-management.”

Looking ahead, the authors plan to continue studying this cohort and other CGM users not taking insulin to explore ongoing patterns of glycemic improvement and real-world behavior change enabled by CGM. The team also intends to evaluate the impact of other Dexcom system features on glycemic control.

Research presentation details:

Dr. Pasquel will present the findings at the late-breaking poster session presentation sessions: 

• Glycemic Improvement with Use of the Omnipod 5 Automated Insulin Delivery System in Adults with Type 2 Diabetes—Results of the SECURE-T2D Pivotal Trial 
• Presented on Saturday, June 22, 2024 at 12:30 PM EDT
• Presented on Sunday, June 24, 2024 at 1:50 PM EDT  

Dr. Garg will present the findings at the following oral presentation session: 

• Glycemic Outcomes with CGM Use in Patients with Type 2 Diabetes—Real-World Analysis
• Presented on Monday, June 24, 2024 at 8:00 AM EDT  

Dr. Layne will present the findings at the general poster session: 

• Long-Term Improvement in CGM-Measured Glycemic Control in Adults with Type 2 Diabetes Not Treated with Insulin—Real-Word

About the ADA’s Scientific Sessions The ADA's 84th Scientific Sessions, the world's largest scientific meeting focused on diabetes research, prevention, and care, will be held in Orlando, FL on June 21-24. More than 11,000 leading physicians, scientists, and health care professionals from around the world are expected to convene both in person and virtually to unveil cutting-edge research, treatment recommendations, and advances toward a cure for diabetes. Attendees will receive exclusive access to thousands of original research presentations and take part in provocative and engaging exchanges with leading diabetes experts. Join the Scientific Sessions conversation on social media using #ADAScientificSessions. 

About the American Diabetes Association The American Diabetes Association (ADA) is the nation’s leading voluntary health organization fighting to bend the curve on the diabetes epidemic and help people living with diabetes thrive. For 83 years, the ADA has driven discovery and research to treat, manage, and prevent diabetes while working relentlessly for a cure. Through advocacy, program development, and education we aim to improve the quality of life for the over 136 million Americans living with diabetes or prediabetes. Diabetes has brought us together. What we do next will make us Connected for Life®. To learn more or to get involved, 

visit us at  diabetes.org  or call 1-800-DIABETES (1-800-342-2383). Join the fight with us on Facebook ( American Diabetes Association ), Spanish Facebook ( Asociación Americana de la Diabetes ), LinkedIn ( American Diabetes Association ), Twitter ( @AmDiabetesAssn ), and Instagram ( @AmDiabetesAssn ).   

Contact Virginia Cramer for press-related questions.

We've extended the 2x Gift Match timeline!

With your help, we can move closer to finding a cure.

Donate today and DOUBLE your impact.

• Ada Advantages
• ARA Community