By Stephane Carrez2018-07-15 21:17:00
To celebrate the France's victory at World Cup, and also because I've not made new releases for a long time, several new releases are available for several Ada projects.
By Stephane Carrez2018-02-18 09:17:00
Writing and maintaining documentation is always a pain for a developer. Most of the time, the documentation is not updated after some changes are made in the code and the documentation becomes out of date. What is described here is not a miracle but it helps in promoting to have an accurate documentation together with the implementation.
By Stephane Carrez2017-10-08 18:32:00
The OpenAPI initiative aims at defining a standard for the specification of REST API. The OpenAPI Specification (OAS) defines a programming language-agnostic interface to describe a REST API. The Swagger Codegen generator supports more than 28 different languages (including Ada) and it is able to read an OpenAPI document and generate either the documentation or the client and server REST code for several target languages.
By Stephane Carrez2017-06-25 17:00:00
The Gnome and KDE desktop environments have designed a shared service API to allow applications to protect, retrieve and manage their secret data such as passwords and private keys. The Secret Service API defines the mechanisms and operations that can be used by applications to use the service.
By Stephane Carrez2017-03-21 22:55:00 3 comments
Arcadius Ahouansou from Menelic.com made an interesting benchmark to compare several Java Web servers: Java REST API Benchmark: Tomcat vs Jetty vs Grizzly vs Undertow, Round 3. His benchmark is not as broad as the TechEmpower Benchmark but it has the merit to be simple to understand and it can be executed very easily by everyone. I decided to make a similar benchmark for Ada Web servers with the same REST API so that it would be possible to compare Ada and Java implementations.
By Stephane Carrez2017-03-18 17:27:00
Atlas is a small application intended to show various features provided by the Ada Web Application framework.
By Stephane Carrez2016-12-04 23:01:00
Writing a simple UDP server in Ada for a STM32F746 ARM controller is now easy with the use of the Ada Embedded Network stack. The article describes through a simple UDP echo server the different steps for the implementation of an UDP server.
By Stephane Carrez2016-09-30 19:19:00
EtherScope is a monitoring tool that analyzes the Ethernet traffic. It runs on a STM32F746 board, reads the Ethernet packets, do some real-time analysis and displays the results on the 480x272 touch panel.
By Stephane Carrez2016-09-29 19:19:00
The Ada Embedded Network is a small IPv4 network stack intended to run on STM32F746 or equivalent devices. This network stack is implemented in Ada 2012 and its architecture has been inspired by the BSD network architecture described in the book "TCP/IP Illustrated, Volume 2, The Implementation" by Gary R. Wright and W. Richard Stevens.
This article discusses the Ethernet Driver design and implementation. The IP protocol layer part will be explained in a next article.
By Stephane Carrez2016-04-30 16:07:00
The Ada Wiki Engine is a small Ada library that parses a Wiki text in several Wiki syntax such as MediaWiki, Creole, Markdown and renders the result either in HTML, text or into another Wiki format.
By Stephane Carrez2016-04-29 12:35:00
GCC 6.1 release has been announced recently by Jakub Jelinek and it is now time to build a new Ada compiler with it. The process to do that is not complex but contains a few pitfalls.
By Stephane Carrez2015-12-30 22:00:00
A new release is available for several Ada projects.
By Stephane Carrez2015-12-16 10:25:00
liblzma is a public domain general-purpose data compression library with a zlib-like API. liblzma is part of XZ Utils which includes a gzip-like command line tool named xz and some other tools. XZ Utils is developed and maintained by Lasse Collin. Major parts of liblzma are based on Igor Pavlov's public domain LZMA SDK. The Ada LZMA library provides an Ada05 thin binding for the liblzma library and it allows to use all the operations provided by the compression and decompression library.
By Stephane Carrez2014-07-27 17:59:44
Ada Web Application is a framework to build web applications.
The new version of AWA provides:
<awa:tagList> and <awa:tagCloud> components for tag displayAWA can be downloaded at http://blog.vacs.fr/vacs/download.html
A live demonstration of various features provided by AWA is available at http://demo.vacs.fr/atlas
A small tutorial explains how you can easily setup a project, design the UML model, and use the features provided by the Ada Web Application framework.
By Stephane Carrez2014-07-27 14:48:28
A maintenance release is available for the following Ada packages:
Download: http://download.vacs.fr/ada-util/ada-util-1.7.1.tar.gz
Download: http://download.vacs.fr/ada-el/ada-el-1.5.1.tar.gz
Download: http://download.vacs.fr/ada-security/ada-security-1.1.1.tar.gz
Download: http://download.vacs.fr/ada-asf/ada-asf-1.0.1.tar.gz
Download: http://download.vacs.fr/ada-ado/ada-ado-1.0.1.tar.gz
Download: http://download.vacs.fr/dynamo/dynamo-0.7.1.tar.gz
By Stephane Carrez2014-07-26 17:14:18 2 comments
This short article is a reminder to know the steps and actions in order to add a Ubuntu 14.04 build machine for Jenkins.
The steps are very similar to what I've described in Installation of FreeBSD for a jenkins build node. The virtual machine setup is the same (20G LVM partition, x86_64 CPU, 1Gb memory) and Ubuntu is installed from the ubuntu-14.04.1-server-i386.iso image.
The following commands install the GNAT Ada compiler with the libraries and packages to build various Ada libraries and projects including AWA.
# GNAT Compiler Installation
sudo apt-get install gnat-4.6 libaws2.10.2-dev libxmlada4.1-dev gprbuild gdb
# Packages to build Ada Utility Library
sudo apt-get install libcurl4-openssl-dev libssl-dev
# Packages to build Ada Database Objects
sudo apt-get install sqlite libsqlite3-dev
sudo apt-get install libmysqlclient-dev
sudo apt-get install mysql-server mysql-client
# Packages to build libaws2-2-10
sudo apt-get install libasis2010-dev libtemplates-parser11.6-dev
sudo apt-get install texinfo texlive-latex-base \
texlive-generic-recommended texlive-fonts-recommended
The libaws2-2-10 package was not functional for me (see bug 1348902) so I had to rebuild the Debian package from the sources and install it.
When the Ada build node is intended to create Debian packages, the following steps are necessary:
sudo apt-get install dpkg-dev gnupg reprepro pbuilder debhelper quilt chrpath
sudo apt-get install autoconf automake autotools-dev
Before adding the build node in Jenkins, the JRE must be installed and a jenkins user must exist:
sudo apt-get install openjdk-7-jre subversion
sudo useradd -m -s /bin/bash jenkins
Jenkins will use ssh to connect to the build node so it is good practice to setup a private/public key to allow the Jenkins master node to connect to the slave. On the master, copy the jenkins user's key:
ssh-copy-id target-host
The Ada build node is then added through the Jenkins UI in Manage Jenkins/Manage Nodes.
The jenkins master is now building 7 projects automatically for Ubuntu 14.04: Trusty Ada Jobs
By Stephane Carrez2014-07-20 14:00:00
After the creation and setup of the AWA project and the UML model design we have seen how to create a review for the review web application. In this new tutorial, you will understand the details to list the reviews that have been created and published.
By Stephane Carrez2014-06-14 18:29:00
In previous tutorials we have seen how to create and setup the project, design the UML model to generate the Ada implementation and the database schema. In this tutorial we will see how to design the page to create a review, implement the operations to create and populate the database with the new review.
By Stephane Carrez2014-05-18 12:42:00
In the Ada Web Application: Setting up the project we have seen how to create a new AWA project. In this second article, we will see how to design the UML model, generate the Ada code and create the database tables from our UML design.
A Model driven engineering or MDE promotes the use of models to ease the development of software and systems. The Unified Modeling Language is used to modelize various parts of the software. UML is a graphical type modelling language and it has many diagrams but we are only going to use one of them: the Class Diagram.
The class diagram is probably the most powerful diagram to design, explain and share the data model of any application. It defines the most important data types used by an application with the relation they have with each other. In the class diagram, a class represents an abstraction that encapsulates data member attributes and operations. The class may have relations with others classes.
For the UML model, we are going to use ArgoUML that is a free modelization tool that works pretty well. For the ArgoUML setup, we will use two profiles:
These UML profiles are located in the /usr/share/dynamo/base/uml directory after Dynamo and AWA are installed. To configure ArgoUML, go in the Edit -> Settings menu and add the directory in the Default XMI directories list. Beware that you must restart ArgoUML to be able to use the new profiles.
The UML model must use a number of Dynamo artifacts for the code generation to work properly. The artifact describes some capabilities and behavior for the code generator to perform its work. Stereotype names are enclosed within markers. Dynamo uses the following stereotypes:
DataModel stereotype must be applied on the package which contains the model to generate. This stereotype activates the code generation (other packages are not generated).Table stereotype must be applied to the class. It controls which database table and Ada type will be generated.PK stereotype must be defined in at most one attribute of the class. This indicates the primary key for the database table. The attribute type must be an integer or a string. This is a limitation of the Ada code generator.Version stereotype must be applied on the attribute that is used for the optimistic locking implementation of the database layer.
In our UML model, the Review table is assigned the Table stereotype so that an SQL table will be created as well as an Ada tagged type to represent our table. The id class attribute represents the primary key and thus has the PK stereotype. The version class attribute is the database column used by the optimistic locking implementation provided by ADO. This is why is has the Version stereotype. The title, site, create_date, text and allow_comments attributes represent the information we want to store in the database table. They are general purpose attributes and thus don't need any specific stereotype. For each attribute, the Dynamo code generator will generate a getter and a setter operation that can be used in the Ada code.
To tune the generation, several UML tagged values can be selected and added on the table or on a table attribute. By applying a stereotype to the class, several tagged values can be added. By selecting the Tagged Values tab in ArgoUML we can edit and setup new values. For the Review table, the dynamo.table.name tagged value defines the name of the SQL database table, in our case atlas_review.
The text attribute in the Review table is a string that can hold some pretty long text. To control the length of the SQL column, we can set the dynamo.sql.length tagged value and tell what is that length.
Once the UML model is designed, it is saved in the project directory uml. Dynamo will be able to read the ArgoUML file format (.zargo extension) so there is no need to export the UML in XMI.
The final UML model of our review application is fairly simple. We just added a table and a bean declaration. To benefit from the user management in AWA, we can use the AWA::Users::Models::User class that is defined in the AWA UML model. The reviewed-by association will create an attribute reviewer in our class. The code generator will generate a Get_Reviewer and Set_Reviewer operation in the Ada code. The SQL table will contain an additional column reviewer that will hold the primary key of the reviewer.
The Review_Bean class is an Ada Bean abstract class that will be generated by the code generator. The Bean stereotype activates the bean code generator and the generator will generate some code support that is necessary to turn the Review_Bean tagged record into an Ada Bean aware type. We will see in the next tutorial that we will only have to implement the save and delete operation that are described in this UML model.
The Makefile.in that was generated by the Dynamo create-project command must be updated to setup a number of generation arguments for the UML to Ada code generator. Edit the Makefile.in to change:
DYNAMO_ARGS=--package Atlas.Reviews.Models db uml/atlas.zargo
The --package option tells Dynamo to generate only the model for the specified package. The db directory is the directory that will contain the SQL model files.
Once the Makefile.in is updated, the Makefile must be updated by using the following command:
./config.status
Or if you prefer, you may run again the configure script to re-configure the whole project.
To run the generator, we can use the generate make target:
make generate
The Dynamo code generator reads the file uml/atlas.zargo and the UML model it contains and generates:
Atlas.Reviews.Models which contains the definition of the Review table. The model files are created in the directory src/models which is separate from your Ada sources.db/mysql and db/sqlite directories.Until now we designed our application UML model, we have our Ada code generated, but we need a database with the tables for our application. We can do this by using the create-database command in Dynamo. This command needs several arguments:
db.If the MySQL server is running on your host and the admin account does not have any password, you can use the following command:
dynamo create-database db 'mysql://localhost/demo_atlas?user=demo&password=demo' root
The create-database creates the database (demo_atlas) with the tables that are necessary for the application. It also creates the demo user and give it the necessary MySQL grants to connect to the demo_atlas database.
To help you in building the UML model and see who the whole process looks like in reality, I've created the following short video that details the above tutorial steps.
Thanks to ArgoUML and Dynamo, generating the Ada model and database tables becomes a simple and fun task. We have not written any line of code yet in this Review Web Application project, everything has been generated but we achieved a big progress:
The next tutorial will explain how to design the review form, implement the operations to create and populate the database with the new review.
By Stephane Carrez2014-05-12 19:28:07
Dynamo is a code generator used to generate Ada Web Application or database mappings.
add-form and add-module-operationYou can download the new version at http://download.vacs.fr/dynamo/dynamo-0.7.0.tar.gz
