Lessons/Hello World! - Revision history

Adam Rose: a few spelling mistakes

2024-10-11T07:37:33Z

a few spelling mistakes

← Older revision		Revision as of 09:37, 11 October 2024
Line 15:		Line 15:
	The '''main.pro''' file contains other stuff, which we will currently disregard, and focus solely on the <vp>run clauses</vp> you just wrote.		The '''main.pro''' file contains other stuff, which we will currently disregard, and focus solely on the <vp>run clauses</vp> you just wrote.

	First we have the keyword <vp>clauses</vp>, which ~~simly~~ indicates that what comes after are '''clauses'''. Clauses is where the actual running code is written.		First we have the keyword <vp>clauses</vp>, which simply indicates that what comes after are '''clauses'''. Clauses is where the actual running code is written.

	In this text I will use words like "clause" and "predicate", which all have their origin in formal logic, but for the moment we will simply treat them as the names that happens to be chosen for things in a Prolog program.		In this text I will use words like "clause" and "predicate", which all have their origin in formal logic, but for the moment we will simply treat them as the names that happens to be chosen for things in a Prolog program.
Line 66:		Line 66:
	<vp>Name</vp> acts as a formal parameter representing the actual argument used in the call to <vp>advancedHello</vp>. In this clause we call <vp>stdio::writef</vp> which is a more advanced "writer" predicate. The first argument to <vp>writef</vp> is a format string, which contains a %-character, what happens when <vp>writef</vp> is called is that the actual value of <vp>Name</vp> is substituted into the format string in the place where the %-character is and then the resulting string is written to the standard output.		<vp>Name</vp> acts as a formal parameter representing the actual argument used in the call to <vp>advancedHello</vp>. In this clause we call <vp>stdio::writef</vp> which is a more advanced "writer" predicate. The first argument to <vp>writef</vp> is a format string, which contains a %-character, what happens when <vp>writef</vp> is called is that the actual value of <vp>Name</vp> is substituted into the format string in the place where the %-character is and then the resulting string is written to the standard output.

	This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>~~advacedHello~~</vp> predicate. This ~~perticular~~ declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.		This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advancedHello</vp> predicate. This particular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.

	In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in the declaration and in the clauses can be different, or you can remove it completely from the declaration. I recommend that you always have variable names here and that you use variable names that will make it clearer for the user of the predicate what the arguments represents.		In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in the declaration and in the clauses can be different, or you can remove it completely from the declaration. I recommend that you always have variable names here and that you use variable names that will make it clearer for the user of the predicate what the arguments represents.

	What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little ~~experiement~~:		What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiment:

	{{Lessons/Exercise\|Remove the word <vp>class</vp> from <vp>class predicates</vp> in the declaration of advancedHello. And then build the project.		{{Lessons/Exercise\|Remove the word <vp>class</vp> from <vp>class predicates</vp> in the declaration of advancedHello. And then build the project.

Adam Rose: Fixed bold formatting

2024-10-10T14:06:12Z

Fixed bold formatting

← Older revision		Revision as of 16:06, 10 October 2024
Line 90:		Line 90:
	Run the project in a window.}}		Run the project in a window.}}

	The clause should be understandable, I just want to highlight that we have used '''comma''' to separate the two invocations of <vp>advancedHello</vp>: '''comma" to separate, '''period''' to terminate. I will give a little prediction: Later when you are familiar with Visual Prolog you will from time to time make syntax errors and (the prediction) 9 out of 10 times the syntax error will concern '''comma''' and/or '''period'''.		The clause should be understandable, I just want to highlight that we have used '''comma''' to separate the two invocations of <vp>advancedHello</vp>: '''comma''' to separate, '''period''' to terminate. I will give a little prediction: Later when you are familiar with Visual Prolog you will from time to time make syntax errors and (the prediction) 9 out of 10 times the syntax error will concern '''comma''' and/or '''period'''.

	To summarize:		To summarize:

Adam Rose: Clarification

2024-10-10T14:03:13Z

Clarification

← Older revision		Revision as of 16:03, 10 October 2024
Line 68:		Line 68:
	This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advacedHello</vp> predicate. This perticular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.		This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advacedHello</vp> predicate. This perticular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.

	In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in the declaration and in the clauses can be different, or you can remove it completely. I recommend that you always have variable names here and that you use variable names that will make it clearer for the user of the predicate what the arguments represents.		In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in the declaration and in the clauses can be different, or you can remove it completely from the declaration. I recommend that you always have variable names here and that you use variable names that will make it clearer for the user of the predicate what the arguments represents.

	What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:		What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:

Jonas Sonn Jørgensen at 12:21, 4 February 2020

2020-02-04T12:21:10Z

← Older revision		Revision as of 14:21, 4 February 2020
Line 72:		Line 72:
	What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:		What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:

	{{Lessons/Exercise\|Remove the word <vp>class</vp> from <vp>class predicates</vp> in the ~~delcaration~~ of advancedHello. And then build the project.		{{Lessons/Exercise\|Remove the word <vp>class</vp> from <vp>class predicates</vp> in the declaration of advancedHello. And then build the project.

	Notice the error message and remember that you get this message when you have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.		Notice the error message and remember that you get this message when you have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

Jonas Sonn Jørgensen: Ord

2020-02-04T12:19:26Z

Ord

← Older revision		Revision as of 14:19, 4 February 2020
Line 68:		Line 68:
	This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advacedHello</vp> predicate. This perticular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.		This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advacedHello</vp> predicate. This perticular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.

	In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in ~~teh~~ declaration and in the clauses can be different, or you can remove it completely. I ~~reccoment~~ that you always have names here and that you use names that will make it clearer for the user of the predicate what the arguments represents.		In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in the declaration and in the clauses can be different, or you can remove it completely. I recommend that you always have variable names here and that you use variable names that will make it clearer for the user of the predicate what the arguments represents.

	What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:		What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:

Jonas Sonn Jørgensen: Har bare rettet et par ord

2020-02-04T11:58:35Z

Har bare rettet et par ord

← Older revision		Revision as of 13:58, 4 February 2020
Line 1:		Line 1:
	In this lesson we will ~~where we~~ just write some code disregarding the finer details.		In this lesson we will just write some code disregarding the finer details.

	{{Lessons/Exercise\|Create a console project.		{{Lessons/Exercise\|Create a console project.
Line 40:		Line 40:
	To summarize:		To summarize:

	* The ~~actal runnign~~ code is in <vp>clauses</vp>		* The actual running code is in <vp>clauses</vp>
	* <vp>predicates</vp> is the Visual Prolog name for routines/subroutines/functions/procedures.		* <vp>predicates</vp> is the Visual Prolog name for routines/subroutines/functions/procedures.
	* Predicates are organized in classes, and predicates from other classes is referenced using <vp><class>::<predicate></vp>.		* Predicates are organized in classes, and predicates from other classes is referenced using <vp><class>::<predicate></vp>.

Thomas Linder Puls: summary2

2018-09-25T12:36:02Z

summary2

← Older revision		Revision as of 14:36, 25 September 2018
Line 91:		Line 91:

	The clause should be understandable, I just want to highlight that we have used '''comma''' to separate the two invocations of <vp>advancedHello</vp>: '''comma" to separate, '''period''' to terminate. I will give a little prediction: Later when you are familiar with Visual Prolog you will from time to time make syntax errors and (the prediction) 9 out of 10 times the syntax error will concern '''comma''' and/or '''period'''.		The clause should be understandable, I just want to highlight that we have used '''comma''' to separate the two invocations of <vp>advancedHello</vp>: '''comma" to separate, '''period''' to terminate. I will give a little prediction: Later when you are familiar with Visual Prolog you will from time to time make syntax errors and (the prediction) 9 out of 10 times the syntax error will concern '''comma''' and/or '''period'''.

			To summarize:

			* Predicates must have a declaration (<vp>run</vp> is also declared we just havn't looked at its declaration).
			* Arguments in predicates declarations can be given names that clarify the meaning if the arguments.
			* <vp>stdio::writef</vp> writes text to the standard output stream using a format string.
			* calls are separated by comma and clauses (and predicate declarations) are terminated by period.
			* If I get a syntax error it is likely to be related to comma or period.
			* A certain other error message (can you recall it) probably means that I have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

	[[Category:Lessons\|{{SUBPAGENAME}}]]		[[Category:Lessons\|{{SUBPAGENAME}}]]

Thomas Linder Puls: initial

2018-09-25T12:21:38Z

initial

New page

In this lesson we will where we just write some code disregarding the finer details.

{{Lessons/Exercise|Create a console project.

Double-click the '''main.pro''' file in the project tree to open it in an editor, and update the <vp>run clauses</vp> to look like this:

<vip>
clauses
run() :-
stdio::write("Hello World!\n").
</vip>

Run the program using '''Build -> Run in window Alt+F5'''.}}

The '''main.pro''' file contains other stuff, which we will currently disregard, and focus solely on the <vp>run clauses</vp> you just wrote.

First we have the keyword <vp>clauses</vp>, which simly indicates that what comes after are '''clauses'''. Clauses is where the actual running code is written.

In this text I will use words like "clause" and "predicate", which all have their origin in formal logic, but for the moment we will simply treat them as the names that happens to be chosen for things in a Prolog program.

<vp>clauses</vp> are used to define <vp>predicates</vp>, where a ''predicate'' is a Prolog routine/subroutine/function/procedure (dear child has many names)

This particular clause defines a predicate <vp>run</vp> which takes no arguments (indicated by the empty parentheses <vp>()</vp>).

After the <vp>:-</vp> token we have the code that will be executed when <vp>run</vp> is invoked/called.

In this case we call a predicate named <vp>write</vp> which is defined in the <vp>class</vp> named <vp>stdio</vp>. We will discuss classes later for now we will just consider <vp>stdio::write</vp> as "a long compound name".

We supply one argument, i.e. the string literal <vp>"Hello World!\n"</vp>, to the <vp>stdio::write</vp> predicate. Notice that \n in the string literal represents a line shift.

The clause is terminated by a period (i.e. <vp>.</vp>). Period is used as terminator for many kinds of entities in Visual Prolog.

The predicate <vp>run</vp> is called when the program is run, and acts as our entry point to the program. Actually, the real entry point is the <vp>goal</vp> a further down in the main.pro file, but that entry point is used to make varous initializations, corresponding clean-up, etc and will call the <vp>run</vp> predicate in the right spot, so run can act like your entry point.

So when the program is run the predicate <vp>run</vp> in '''main.pro''' will be called and this will (here) call
<vp>stdio::write</vp> with the argument <vp>"Hello World!\n"</vp>, as a result ''Hello World!'' and a line shift will be written to the console window.

Actually, <vp>stdio::write</vp> writes to the standard output stream, which in a console program is initialized to be the console window. In a default GUI program the standard output stream will write to a message window, but the standard output stream is under programmer control, so what happens when you call <vp>stdio::write</vp> will depend of what has taken place in the program.

To summarize:

* The actal runnign code is in <vp>clauses</vp>
* <vp>predicates</vp> is the Visual Prolog name for routines/subroutines/functions/procedures.
* Predicates are organized in classes, and predicates from other classes is referenced using <vp><class>::<predicate></vp>.
* The <vp>run</vp> predicate in <vp>main.pro</vp> is the (effective) entry to a program.
* <vp>stdio::write</vp> can write to the standard output stream

Now let us extend the program with an extra predicate.

{{Lessons/Exercise|Add this code below the <vp>run</vp> clauses:

<vip>
class predicates
advancedHello : (string Name).
clauses
advancedHello(Name) :-
stdio::writef("Hello %!\n", Name).
</vip>

Build the project using '''Build -> Build Ctrl+Shift+B'''}}

When you build the project you will get a warning stating that the predicate <vp>main::advancedHello</vp> is an unused local predicate. Which is completely correct; we haven't used it for anything. But let us "decipher" it before we go any further.

We notice that we again have a clause in a <vp>clauses</vp> section. The clause is for a predicate named <vp> advancedHello</vp> that takes one argument called <vp>Name</vp>. <vp>Name</vp> is a variable, a variable starts with an uppercase letter and will be green in the editor (variables can also start with an underscore, but we will discuss that later).

<vp>Name</vp> acts as a formal parameter representing the actual argument used in the call to <vp>advancedHello</vp>. In this clause we call <vp>stdio::writef</vp> which is a more advanced "writer" predicate. The first argument to <vp>writef</vp> is a format string, which contains a %-character, what happens when <vp>writef</vp> is called is that the actual value of <vp>Name</vp> is substituted into the format string in the place where the %-character is and then the resulting string is written to the standard output.

This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advacedHello</vp> predicate. This perticular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.

In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in teh declaration and in the clauses can be different, or you can remove it completely. I reccoment that you always have names here and that you use names that will make it clearer for the user of the predicate what the arguments represents.

What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:

{{Lessons/Exercise|Remove the word <vp>class</vp> from <vp>class predicates</vp> in the delcaration of advancedHello. And then build the project.

Notice the error message and remember that you get this message when you have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

Then insert <vp>class</vp> again and build the project again.}}

Now that we have the advancedHello predicate we can use it in our <vp>run</vp> predicate.

{{Lessons/Exercise|Update the run clause to look like this:

<vip>
clauses
run() :-
advancedHello("Dear"),
advancedHello("World").
</vip>
Run the project in a window.}}

The clause should be understandable, I just want to highlight that we have used '''comma''' to separate the two invocations of <vp>advancedHello</vp>: '''comma" to separate, '''period''' to terminate. I will give a little prediction: Later when you are familiar with Visual Prolog you will from time to time make syntax errors and (the prediction) 9 out of 10 times the syntax error will concern '''comma''' and/or '''period'''.

[[Category:Lessons|{{SUBPAGENAME}}]]