Being a mission-critical language, Ada is very strongly typed. There are no implicit conversions as there are in other languages like C. So a statement that is perfectly legal in C like double num = 1; is illegal in Ada because 1 is an integer — it must be specified as 1.0 because Ada doesn’t auto-convert. This gets a bit tedious at times when there are a lot of numbers, but it’s also quite useful in helping avoid (though doesn’t eliminate the possibility of) assigning a value to the wrong variable.

(Actually, there are implicit conversions in Ada — for example, 1 is not an Integer; it is a universal integer value that can be implicitly converted to an Integer — but that doesn’t even count as a conversion in most other languages so…)

There are a LOT of aspects of type conversions in Ada. I’ll just cover the few I think will be needed to do basic operations in the language without going into a ton of detail on the more complex operations that can be done.

To get started, the standard form of type conversion is the explicit conversion. To convert from one type to another, use:

This can be legally done between any two numeric values. For example, to convert an Integer value to Float:

This is equivalent to:

Of course, the latter version is more concise and is generally recommended when it’s possible. However, if the original value is a variable or constant, the explicit conversion in the former version is needed.

Note that when precision is lost (ie. converting from Float to Integer), the result is rounded.

Explicit conversions can also be done on any two types or subtypes derived from the same parent type. For example:

And that’s about all the type conversions I’ll probably be using in the near future. Unchecked type conversions is also possible, but it’s unlikely I’ll use it anytime soon and it seems that there’s generally an alternative so I won’t attempt to understand/use it at this point.

Related to type conversions, and generally considered to be a type conversion in most other languages, is the conversion between string and numeric data. This is done through the use of the Value and Image attributes.

Note that Numeric_String /= New_String_Value. When Integer_Value is converted to a string with Integer’Image, it adds a space in front of non-negative integers. As a result, New_String_Value is actually set to ” 121″. This is used for formatting purposes when both negative and non-negative numbers are outputted into a list. This problem can easily be resolved through using the Ada.Strings.Fixed.Trim function on the result.

First, the library needs to withed and used by the package.

Then,

The Ada.Strings.Left parameter tells the function to remove the extra space on the left, if there is one. This leaves strings with negative values, which do not have an extra space on the left, unaffected.

If the number is guaranteed to be positive, then string slicing can be used which may be slightly faster.

This, however, cuts off the negative sign in the case of negative values. In some cases, I can see this being done intentionally as a quick way to go from a number to a string containing the absolute value of that number.

There is a LOT more on type conversions I skipped right over — perhaps because I just plainly overlooked them; or those features may not be used frequently and I likely would not find a use for them with my relatively simple project; or maybe because they are advanced topics that I should probably save for later when I gain a bit more experience with using the language. Otherwise, I would risk trying to explain something I don’t actually understand which could lead to undue confusion (and I think I may have caused enough of that already).

So this marks the end of the sub-series on types, but only for now. Other useful topics (ie. access types and the like) will be covered as I start with the code for the project (which is a library of astronomical calculations for those who skipped over the overview post). The next post in the Ada series will cover the start of this project and its foundational code. Unfortunately, this happens to be a relatively busy time of year for me so that post may not arrive for quite some time — perhaps a couple of months. Then, the real fun begins.

This is part 2 of the sub-series on types in Ada. A second variety of types in Ada (the first being the enumeration) is the record. When I first learned C a few years back, records (called structures in that language) were what I always associated with user-defined types. They are effectively sets of other types which can be grouped together and incorporated into a single variable (ie. coordinates).

A simple record type is written like this:

(Note the use of boundaries — Float is effectively an enumeration so it can be bounded)

Sometimes, it may also be helpful to have default values for each field.

In Ada, records can be extended into other types with additional fields if they are declared as “tagged”. For example, if the longitude and latitude data isn’t enough and a new type that includes elevation is needed, it’s as simple as:

The above declaration of “Position” is equivalent to:

There is no such thing as a “class” in Ada like there is in Java and C++. Instead, tagged records can be used to do the equivalent with its ability to be added on much as classes can be extended in Java and C++.

There are also discriminated records — records which work a lot like generics in other languages (as well as in Ada itself).

To use such records, the discriminants of the type must be specified when creating an object of the type.

Note that I’ve named the discriminants (Min_Lon, Max_Lon, …). This isn’t necessary — it’s possible to do just:

However, that is a lot less readable to someone looking over the code. It’s also far more prone to errors — if you screw up the order and you’ve named the discriminants, you’re okay, but if you screw up the order and you don’t name the discriminants, you’re just plain screwed. Naming is also supported with procedure/function calls where you name the parameters.

A Quick Note on Naming
I have used parameters in the wrong order on more than one occasion with function calls in other languages that don’t support naming. Each occasion cost me a good hour’s worth of debugging and trying to figure out where my problem is. As a result, I find naming to be a very welcome feature.

Naming can and should also be when assigning values to objects that are record types: (note that this uses the none-discriminated records)

My_Coord_1 : Coord := (Longitude => -22.5, Latitude => 89.5);
My_Coord_2 : Coord := (-22.5, 89.5); -- equivalent to above

Note how unreadable the latter version is. You would have to pull up the specification of Coord to see what each number means. Is -22.5 the longitude or the latitude? A look at the specification says longitude. However, a look at the first version immediately says which is which — without having to look up the specification.

Getting back to discriminate types, it’s also possible to have one type be completely different types depending on the discriminate. Confused? The code should explain better than I can. These, by the way, are called variant records:

The case statement uses the same format as case statements in procedure and function bodies (and does the same thing). It checks the discriminant and sends it to the correct when statement depending on its value.

Unlike many other languages, the case statement (or switch/case) does not require a break statement at the bottom. The break statement (inside switch statements) is one of my most common errors I make with languages that require it. Even after working with perhaps hundreds of switch/case statements in C, I still frequently forget to add the break at the end. The result is that execution simply continues to the next option without giving me an error. It’s usually months later, long after the code has been released when the problem is discovered. My guess is that this is the reason why switch statements are considered “evil” in such languages.

So far, of these, I plan to make use of standard, tagged and variant records in my astronomical calculations library. I don’t see anything that plain discriminated records could be used for… yet.

Coming next should be type conversions. Ada seems to be particular strict on these as it’s part of what makes it mission-critical.

When I first looked at the Ada language, one thing I found to be very attractive was the type system — unlike some other languages, it just “made sense” to me.

There are actually a lot of different kinds of types in Ada. The generic one that first caught my attention is the enumeration. Enums exist in C/C++ as well (and perhaps many other language), but an enum declaration in C hardly tells you what it means. In C, an enum would be declared like this:

I have never understood enums in C particularly well despite several years of experience in the language. As a result, the most I have done with them is to use them as an equivalent of a series of constants like:

I’m sure that C is more powerful than that, but the more advanced features, based on a quick Google search, require memorizing a lot of extra syntax. One reason I chose C back in 2009 is its simple syntax — at least for the simple tasks I needed to do. C++ had ugly <brackets> and Fortran was…well, to say the least, unreadable. This was, naturally, several years before I even heard of Ada so it was not an option — which meant C was the most understandable language of its type I knew of. And that is how I became a C programmer. Then in came the features like enums and…

Well, enough of that — it’s time to return to the language that solves all (or at least a few) problems. Enumerations in Ada are MUCH more understandable. Compare the above to:

Now THAT just makes sense, regardless of whether you know any Ada or not! Sunday, Monday, …, Saturday are all of the type “Day_of_Week” — no confusing “enum” keyword or resemblance to a function call. With this, a procedure or function can accept an argument of type “Day_of_Week” and be passed a Sunday, …, Saturday.

Perhaps more interesting is the ability to have subtypes which include just a portion of the main enumerated type. For example,

Now there’s something that should be very useful — especially with catching errors. I am a big fan of organization in code — mainly because if the code isn’t organized in a standardized and strict manner, I quickly lose track of which code does what. And when that happens, it’s quite easy to screw up. Organizing it this way also lets the compiler double check your work to make sure you organized correctly — because if you organized wrong, you probably made a mistake somewhere that wouldn’t be caught in a language like C.

I was originally planning on writing about the entire type system in this post. Those of you who are Ada programmers probably laughed just now at that statement. A quick look at the features of the type system show that one can probably write a whole book on it and this post would have ended up being upwards of 20 pages long. So, to keep things short and understandable, I’ll break it up into 20 posts instead.

So, next up in this sub-series on Ada types are records — the equivalent of structures in C.

It’s been another couple of days. To be honest, I haven’t done much with Ada in these recent days but here are some more findings as a result of my experimentation and research.

Last time, we had packages. Now, it’s time to deal with some child packages which are exactly what they sound like — a sub-package of a parent package. All of the standard packages are child packages of the “Ada” package. GNAT also provides some child packages under the “GNAT” package.

Besides the obvious benefit of organization, child packages also provide some inheritance benefits. For example, every child package automatically has access to everything in the parent package. Normally, that requires a “with” statement at the top. Therefore, the following is redundant:

An even bigger benefit is the ability for child packages to access the private declarations of the parent package. For example, if a parent is declared as:

then any other package can call Public_Foo (after using a with statement as shown above). However, only the package itself and all child packages can use Private_Foo.

Sometimes, it’s useful to have private child packages.

The declarations in such private packages are only accessible to other private units such in the bodies of sibling packages (ie. other child packages of the same parent).

Next time, it’s time to take a look at Ada’s highly sophisticated type system — effectively, the system that makes the language what it is.

Our ultimate goal is to learn how to assemble a program together. Assembling a program is very difficult for beginners, so practice is necessary. This is just like learning physics. Physics is a difficult subject for beginners, but with practice, it becomes easier over time.

On the command line, I notice a MS-DOS like screen where I begin to write code on the command line.

So where do I start? Click here.

For example, I type in: print (“Hello world”), and I get Hello world as the output value. Another example is to type: print (6868^2), and I get 47169424 as the output value. This is just another branch of mathematics, applied to the real world.

But this is just the first step. Some vocabulary terms must be mentioned here, to get oriented with the Lua. That is what you do when you learn a new language.

However, in order to thoroughly learn Lua, the first step is to visit the Lua online handbook to find out the terminology. That is where I will begin my studies using the Lua language.

As I am learning Lua, I will also be coming across different resources.

At this time, I have just come across a video demonstration on Youtube, explaining how to program in Lua. Here you can learn how to use the Lua program to successfully create your first program. I will be using this resource often in order to learn how to make programs using the Lua language. It is easier rather than reading the online handbook because it actually demonstrates how to compile a program. I think it is very useful for programmers who have virtually no programming experience (like me).

But, let’s get back to the “Hello world” example.

Installation – The Overall Process

Disclaimer: If you are operating your Lua software on a non-Windows operating system, please visit the Lua website for further information on how to install your Lua software. Also, use Youtube as a resource to guide you in the installation process.

This post applies to all Windows operating systems (particularly Windows XP and 7, as these operating systems are popularly used).

First, search “Lua for Windows” on Google, and then you will see a link to the Lua for Windows page. Then, you will be asked to download your Lua for Windows software from Google Code, which can be accessed here.

When downloading, you will want to save the file under the Downloads folder (if using Windows 7). For XP users, please find a folder that you feel comfortable using to save your files.

Downloading your Lua for Windows.

When prompted to download, click on Save. Here is what will happen…

Sometimes, anti-virus providers will cause the program to ”not be verified”. In that case, you just click “Run”.

Installing Lua

Installation now begins. You click “Next.”

Then…

Installing Lua 2

You now choose where to save your installed files. In this case, I use my Downloads folder (Windows 7). Then click “Next”.

Now you choose what to install. I recommend full installation. When you are finished, click “Next” for further instructions.

Make sure to follow all the prompts to install your Lua for Windows software.

After installing, you should see an “Installation Complete” page like the screenshot below.
You check the box next to “Run a simple introduction to Lua” if you need to learn how to use it. Otherwise, click “Finish” and begin enjoying your time learning Lua!

Learning Lua is tricky at first, but once you master the basics of Lua, everything else is simple.

Well, it’s been a few days and it’s now time to report back with some findings. Note that this isn’t the first time I’ve seen Ada code so I may appear to be going a bit faster than someone completely new to the language would.

Comments

There is only one type of comment in Ada — those prefixed by “–”.

Semicolons

Yes, there are semi-colons after just about every complete statement. That’s quite standard among all the major compiled languages. The fact that it shows up in a language known for helping programmers avoid mistakes and improving readability — which semi-colons do help with, as annoying as they are to type.

Assignment vs Equality Check

Many newcomers to programming get confused by the statement “i = i + 1″ which is a common way to increment a variable in some languages. That’s because we have long learned that “=” means the two sides are the same when obviously i cannot equal i + 1. That’s because the “=” in that statement means assignment and changes the value of i to i + 1 rather than specifies that they are equal. That leads to the next big mistake many newcomers make: using the “=” instead of “==”. Nowhere in math is “==” ever used despite its appearance as a mathematical operator. It means, in many languages, the equivalent of what “=” means in math and the rest of the world.

Ada resolves this issue with a simple change: by making the assignment operator “:=” rather than just “=” which it uses in place of “==”. Yes, it’s one extra character to type, but at least it now makes sense to the rest of the world.

I should also point out that the errors generated when you forget that assignment is “:=” and equality is “=” are very helpful and concise in located what you did wrong. Unlike the error system in most C compilers which would say something like “Expected ‘:=’ near ‘=’”, or, even worse, “Unexpected character near ‘=’”, the Ada compiler actually says “‘=’ should be ‘:=’”.

Functions & Procedures

Ada is one of those languages that distinguish between functions and procedures. A function returns a value and cannot modify any arguments passed to it. A procedure does not return a value but can modify arguments.

Packages

All Ada programs are written as packages. Packages are like classes in object-oriented languages where everything inside is static — so no initializing objects from them.

Packages are typically broken into a spec file and a body file. These resemble the header and code files in C/C++ with one distinct difference — they absolutely must match up. A package body cannot have any public functions or procedures that do not appear in the package spec. This makes sense — a public function/procedure is expected to be used by functions/procedures in other packages which requires inclusion in the spec file.

Package spec:

Package body

Even the entry point (“main” program) is included in a package. The entry point has the same name as the package it is included in. Naturally, not every package NEEDS an entry point just as there aren’t multiple “main” functions in C.

The package containing main is specified in the build file. The following program does…well, nothing.

–

Well, that’s it for now. I’ll be back to update with some more interesting features of Ada.

But with the rapid advancement of technology comes huge challenges. One challenge that our younger generation will have to face is learning a programming language. As North mentions, “some colleges require students to take computer literacy classes in order to graduate.” But why is that? Is that designed to distract students from their focus of study?

Not at all. In fact, just like a good working knowledge of economics and accounting is crucial to successful survival in a capitalist society, a good working knowledge of computer programming is just as crucial as having a good working knowledge of economics and accounting, since our future life will revolve around computers. Computers in the future will be ubiquitous, so having a sufficient command of programming language is equally advantageous to understanding economics and accounting, for survival purposes.

So, what is Lua? Lua is a powerful, fast, embeddable, and lightweight scripting language. It combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode for a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.

Lua has advantages. It is a proven, robust language, and it is fast, portable, embeddable, powerful (but simple), small and of course, FREE!

It is used in many industrial applications, with emphasis on embedded systems and games. It is currently a leading scripting language in games. It has a deserved reputation for its fast performance, and it is distributed in a small package. In addition, it is compatible with all operating systems.

For more information about Lua’s syntax, please click here.

More information can be found on the Internet.

In the past years of my life, I have zero programming experience. My websites are pre-made, using Drupal CMS. But, that will all change when I begin learning Lua, an important programming language. The Internet is a great resource for Lua, and it also will provide great resources for me as I learn the language. And of course, whenever you have something you don’t understand, try to help yourself, and then ASK! This is the key to learning anything, from being able to pass a test, to of course, learning a language like Lua.

HAVE FUN! And of course, come back here for links to more posts.

The Beginning of a Lua Program

First Findings of Lua

Yet, with computers dominating much of the future, it may become a necessity in the future to be able to write good, working code much as it’s a necessity today to be able to speak a language. Despite the vast number of software available already, it hardly covers everything. It’s not because these tasks are hard, but rather, because there are endless possibilities that it’s impossible to implement them all.  Many of the tasks existing software can’t do yet can be accomplished with just a couple lines of code any novice programmer can write.

Just as those with the ability to understand texting linguo (ie. lol, rofl, lmao, etc..) have left the older generations behind, there’s a real possibility that those who write code and think programmatically will leave those of the present behind. Many universities in the US are already requiring students of all majors to take an introductory computer science course to graduate.

So here’s the challenge for you: If haven’t already, learn to write code. There are countless practical applications for writing code from extending your website in a way no one else has to solving a repetitive and boring problem your professor or boss assigned. You’ll save yourself a lot of work and might even get yourself a promotion!

Space Socket Dev blogger proms74 will be tackling this challenge head-on by learning to script in Lua over the next month or so. Like many of you, he has had no prior experience working with any programming language. Along the way, he will be offering helpful hints and advice to save you some time when trying it for yourself.

Meanwhile, many others will already have significant programming experience whether it’s Fortran, C or PHP. To those readers, your challenge is this: learn a new programming language. While it’s true that one should always aim to be good at one language than decent in many, picking up new languages is a good way to think differently when you write code. Often, coding styles and methods in one language are equally applicable in another yet they never surface in that second language simply because of the way it was designed. For example, Python is a language that strictly conforms to a standard of coding with certain “rules” that come naturally with its design. But such “rules” may be equally applicable in, say, Lua. I am taking up this second challenge by learning Ada, a mission-critical language frequently used in airplanes, rockets and spacecraft.

Time for me to get started (or rather, continue where I left off)! Are you up to the challenge? If so, ready, get set, GO!

The standard compiler for the Ada language today is the GNAT compiler which is part of GCC. There are actually 3 different versions of GNAT: GNAT-GPL, GNAT Pro and GNAT-GCC. GNAT-GPL and GNAT-Pro are released by AdaCore, the company that develops Ada-related products. GNAT-GCC includes a runtime library licensed under the GPL requiring all binaries compiled by it to be released under the GPL. GNAT Pro and GNAT-GCC (included in the GCC distribution) includes a runtime under the GMGPL (GNAT Modified GPL), a license equivalent to the LGPL.

I decided to start off with GNAT-GPL, which includes an IDE (GNAT Programming Studio) then later switch the compiler to GNAT-GCC as needed. So I downloaded a copy of GNAT-GPL 2012 for x86 Windows from the Libre website of AdaCore and installed it. Note that although it shows a field for email before you download, you do not need to fill it in for the downloads to show.

At 108 MB, it was a pretty big download and took several minutes to download. The per-user installation went smoothly as I had expected and within a few more minutes, GNAT was successfully installed. Or so I had thought. The first logical step was to load up GNAT Programming Studio and take a look around the environment. The splash screen loaded and, for a few seconds, the program appeared to be loading, but when the splash screen closed, the program did not load. A peek at task manager shows that the gps.exe process quits after the splash screen exits so something must not have been right with the installation or my machine.

The splash screen loaded…a good sign. But when it closed, GNAT Programming Studio didn’t start.

I was not in the mood to debug the problem and just moved on to the second option: GNATbench. GNATbench is a plugin for Eclipse that turns it into a complete Ada development environment. This was another 57 MB to download. Naturally, I also needed Eclipse so I went and downloaded that as well — another 192 MB.

I followed the instructions in the readme for GNATbench and installed it through Help->Install New Software…except it wouldn’t install. It was missing a dependency. Rereading the readme said that I needed the C/C++ Development Tools so I installed that through the dialog — it didn’t say how many MB it was but I assume it was about 5 MB based on how long it took to install. I restarted Eclipse and tried installing GNATbench again — still with no luck. I went into the dialog again and installed everything having to do with C/C++ — probably another 10 MB of downloads. Once more, GNATbench failed to install.

Reading  the deceptively simple readme even more closely, it said that GNATbench needed Eclipse 3.6 or 3.7…hmm, what version do I have? Eclipse 4.2???!!!??? Apparently, Eclipse 4.2 Juno was only recently released this June and GNATbench had not been updated to support it. Eclipse 3.7 was the previous version as they skipped 3.8, 4.0 and 4.1 so at least I would only be 1 version behind so I went and downloaded Eclipse 3.7 Indigo — this time, the C/C++ version so I wouldn’t have to go through the trouble of installing them afterwards. It was another 114 MB to download but at long last, GNATbench was up and running.

So long story short, it took me 486 MB of downloads to get it working, but at least it works! Now if only this code will work…but that’s for next time.