ADA and it's grandfather Pascal!

Flashback

Pascal is a procedural programming language that was developed by Niklaus Wirth in the late 1960s and early 1970s. The language was named after French mathematician and philosopher, Blaise Pascal. Initially designed as a language for teaching programming, Pascal quickly gained popularity among programmers due to its simplicity and readability.

The early versions of Pascal were implemented on mainframe computers, but later it was also available for microcomputers. The language was widely used in academic settings and was popular among hobbyists who had access to personal computers. In the 1980s, a version of Pascal called Turbo Pascal was released by Borland International, which became very popular due to its fast compiling times and compatibility with IBM PC-compatible computers.

In the early 1990s, Borland released Delphi, an object-oriented version of Pascal that included a visual development environment and a powerful class library. Delphi was designed to be an easy-to-use, rapid application development tool for Windows, and it quickly gained a large following among Windows developers. Its popularity eventually led to the creation of the open-source Lazarus project, which aims to recreate the Delphi IDE and class library using free and open-source software.

The philosophy behind the creation of the Ada programming language was quite different from that of Pascal. Ada was specifically designed for large-scale, safety-critical systems, such as those used in the military and aerospace industries. The language was created by a team of experts from government, industry, and academia, who collaborated to create a language that would be safe, reliable, and scalable.

One of the key design principles of Ada was its support for modularity and abstraction. The language includes features such as packages, generics, and tasking, which allow code to be organized into reusable units and executed concurrently. This makes it well-suited for complex systems that require high levels of reliability and maintainability.

While there are some similarities between Delphi and Ada, such as their support for object-oriented programming and their use of Pascal-like syntax, the two languages have different goals and design principles. Delphi is focused on rapid application development for Windows, while Ada is focused on safety-critical systems. However, both languages demonstrate the versatility of the Pascal language family and its ability to adapt to a variety of different programming paradigms and application domains, 

Which one is influenced by the other?

Ada was influenced by Pascal.

Ok, it's Enough! Show me the code!

let's compare the syntax of ADA and Delphi with some sample code!

// Sample Pseudocode
if (x > y) then
    z := x + y;
else
    z := x - y;
endif;

In ADA, the equivalent code would look like this:
-- ADA Code
if x > y then
    z := x + y;
else
    z := x - y;
end if;
In Delphi, the equivalent code would look like this:

// Delphi Code
if x > y then
    z := x + y
else
    z := x - y;

As you can see, there are some syntactical differences between the three languages: 
In ADA, statements are terminated with semicolons (;), 
while in Delphi they are terminated with optional semicolons.
ADA uses the end if keyword to terminate conditional statements, 
while Delphi uses the end keyword.
 In Delphi, the then keyword is followed by a new line instead of a space.

Overall, ADA and Delphi have similar syntax structures for 
their control flow statements, but there are some minor differences 
in how they handle keywords and semicolons.

Here are some more complex examples of code in both ADA and Delphi along with 
an explanation of the differences in their syntax:

Example 1: Looping through an array

// Sample Pseudocode
for i = 0 to len(array)-1 do
    print(array[i])
end for 

In ADA, the equivalent code would look like this:

-- ADA Code
for i in 0..array'Length-1 loop
    Put_Line(Integer'Image(array(i)));
end loop;

In Delphi, the equivalent code would look like this:

// Delphi Code
for i := 0 to Length(array)-1 do
    WriteLn(array[i]);

As you can see, there are several differences between the two languages 
in this example:In ADA, the for loop uses the in keyword to define 
the range of the loop.
ADA uses the Put_Line procedure to print output to the console, 
while Delphi uses the WriteLn function.
In ADA, the array'Length syntax is used to get the length of the array, 
while in Delphi, the Length function is used.

Example 2: Creating a function with parameters
Here's some pseudocode to create a function that takes in two integers 
and returns their sum:


// Sample Pseudocode
function addNumbers(num1, num2) {
    return num1 + num2;
}

In ADA, the equivalent code would look like this:
-- ADA Code
function Add_Numbers (Num1 : Integer; Num2 : Integer) return Integer is
begin
    return Num1 + Num2;
end Add_Numbers;


In Delphi, the equivalent code would look like this:

// Delphi Code
function Add_Numbers(num1, num2: Integer): Integer;
begin
    Result := num1 + num2;
end;


In this example, there are a few differences between the ADA and Delphi syntax:
In ADA, the function is defined using the function keyword and the return type is
specified after the parameter list. In Delphi, the return type is specified before
the function name.
In ADA, the return keyword is used to return a value from a function, 
while in Delphi, the Result variable is used.
Both languages use semicolons to terminate statements, but in ADA they are required.

Overall, both ADA and Delphi have similar syntax structures for creating functions 
with parameters, but they have some minor differences in how they handle keywords, 
semicolons, and return values.


Example 3: tasking in ADA and modern Delphi.
In ADA, tasking is an essential feature for concurrent programming. 
Here's an example that demonstrates the use of tasks in ADA:


-- ADA Code
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Task_Example is
   task type Worker_Task is
      entry Set_Value (New_Value : Integer);
      entry Get_Value (Result : out Integer);
   end Worker_Task;

   task body Worker_Task is
      My_Value : Integer := 0;
   begin
      loop
         select
            when Set_Value'Event =>
               accept Set_Value (New_Value : Integer) do
                  My_Value := New_Value;
               end Set_Value;
               
            when Get_Value'Event =>
               accept Get_Value (Result : out Integer) do
                  Result := My_Value;
               end Get_Value;
         end select;
      end loop;
   end Worker_Task;

   W1 : Worker_Task;
   W2 : Worker_Task;
begin
   W1.Set_Value(10);
   W2.Set_Value(20);
   
   Put("W1's value is: ");
   W1.Get_Value(Result => Integer'Image(Result));
   Put_Line(Result);
   
   Put("W2's value is: ");
   W2.Get_Value(Result => Integer'Image(Result));
   Put_Line(Result);
end Task_Example;
In this example, we define a task type called Worker_Task that has two entries: 
Set_Value and Get_Value. 
The Set_Value procedure sets the value of a private integer variable called 
My_Value, while the Get_Value procedure returns the current value of My_Value.
The task then enters a loop where it accepts incoming requests to either 
set or get the value of My_Value.


Two instances of the Worker_Task task type are then created (W1 and W2), 
and their Set_Value entries are called to set their respective values. 
Finally, the Get_Value entries are called for both tasks to retrieve 
their current values.
In modern Delphi (version XE7 and later), tasking is implemented using the 
TTask class. 

Here's an example of how tasks can be used in Delphi:

program Task_Example;
// Delphi Code
{$APPTYPE CONSOLE}

uses
  System.Threading,
  System.SysUtils;

procedure Worker_Task(Value: Integer; var ResultVar: Integer);
begin
  // Perform some work here...
  
  ResultVar := Value * 2;
end;

var
  T1, T2: ITask;
  Result1, Result2: Integer;
begin
  T1 := TTask.Create(
    procedure
    begin
      Worker_Task(10, Result1);
    end
  );
  
  T2 := TTask.Create(
    procedure
    begin
      Worker_Task(20, Result2);
    end
  );
  
  T1.Start;
  T2.Start;
  
  T1.Wait;
  T2.Wait;
  
  Writeln('Result1 = ', Result1);
  Writeln('Result2 = ', Result2);
  
  Readln;
end.


In this example, we define a procedure called Worker_Task that performs some work
 and sets the value of a passed-in variable called ResultVar.
Two instances of the ITask interface are then created (T1 and T2) using the TTask.
Create a constructor and pass in anonymous procedures that call Worker_Task 
with different values.
The tasks are started using the Start method and then waited for using the
Wait method.
Finally, the results of both tasks are printed to the console.


Is it worth learning and investing in ADA programming language in 2023?
(Answered by ChatGPT) 
Is there any job for that out there?

In 2023, Ada programming language is still widely used in industries 
such as defense, aerospace, transportation, and healthcare, where safety
and reliability are critical concerns.
Therefore, learning and investing in the Ada programming language can be valuable 
if you are interested in pursuing a career in these industries.

There are several job opportunities available for Ada programmers, 
particularly in the defense and aerospace sectors.
Job titles may include software engineer, systems engineer, 
embedded software developer, and safety-critical software developer.

However, it's worth noting that while Ada remains relevant in certain industries, 
its popularity has waned in recent years with the rise of newer languages 
like Rust, Swift, and Kotlin. Therefore, before investing your time and effort 
in learning Ada, it's worth considering the demand for Ada programmers in your
target industry and assessing whether learning other languages might offer 
better job prospects.

Is it worth learning Delphi programming language in 2023?
(Answered by ChatGPT)
Is there any job for that out there?
Delphi is a programming language that has been around for many years 
and has been widely used in various industries, especially for developing 
desktop applications. 
However, its popularity has decreased over time, and it's not as widely used 
today as it once was.

That being said, there are still some job opportunities available for Delphi 

developers, particularly in industries where legacy systems are still 

running on Delphi codebases. 
For instance, some companies might need to maintain an existing application

 or upgrade it, which requires knowledge of the Delphi language. 

Additionally, some government agencies and defense contractors still use Delphi

for developing certain applications.

So, while Delphi may not be as popular as other languages like Java, Python,
or JavaScript, there are still opportunities for Delphi developers. 
However, if you're new to programming and looking to learn a new language, 
you might want to consider learning one of the more in-demand languages 
to increase your job prospects.