4 added 32 characters in body
source | link

I see two very different reasons to use pseudo-code.

First, being precise. You want to describe an algorithm in details, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. Maybe you avoid a language war, but then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, being vague. You want to explain ideas on how to do things, with more or less details. Maybe what you want to show, butis a succession of intermediary steps that lead to an algorithm, and later a program. Because you want to teach, not the version of algorithm X published by Y in 19xx, but how to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

Pseudo-code allows discussion of approaches to a problem, without solving it entirely. For example the (in)famous "find the largest difference between 2 elements from an array".

One approach is

largest = 0
for each pair (i,j) of indices
   if the difference between t[i] and t[j] is > largest
       change largest

and another

find the min and the max of the array
largest is the difference

such pseudo-code is precise enough to discuss the 2 solutions.

Same kind of discussion about "should we use incomplete/incorrect UML diagrams when teaching" ?

I see two very different reasons to use pseudo-code.

First, being precise. You want to describe an algorithm in details, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. Maybe you avoid a language war, but then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, being vague. You want to explain ideas on how to do things, with more or less details. Maybe you want to show, but steps that lead to an algorithm, and later a program. Because you want to teach, not the version of algorithm X published by Y in 19xx, but how to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

Pseudo-code allows discussion of approaches to a problem, without solving it entirely. For example the (in)famous "find the largest difference between 2 elements from an array".

One approach is

largest = 0
for each pair (i,j) of indices
   if the difference between t[i] and t[j] is > largest
       change largest

and another

find the min and the max of the array
largest is the difference

such pseudo-code is precise enough to discuss the 2 solutions.

Same kind of discussion about "should we use incomplete/incorrect UML diagrams when teaching" ?

I see two very different reasons to use pseudo-code.

First, being precise. You want to describe an algorithm in details, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. Maybe you avoid a language war, but then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, being vague. You want to explain ideas on how to do things, with more or less details. Maybe what you want to show, is a succession of intermediary steps that lead to an algorithm, and later a program. Because you want to teach, not the version of algorithm X published by Y in 19xx, but how to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

Pseudo-code allows discussion of approaches to a problem, without solving it entirely. For example the (in)famous "find the largest difference between 2 elements from an array".

One approach is

largest = 0
for each pair (i,j) of indices
   if the difference between t[i] and t[j] is > largest
       change largest

and another

find the min and the max of the array
largest is the difference

such pseudo-code is precise enough to discuss the 2 solutions.

Same kind of discussion about "should we use incomplete/incorrect UML diagrams when teaching" ?

3 added 507 characters in body
source | link

I see two very different reasons to use pseudo-code.

First, being precise. You want to describe an algorithm in details, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. Maybe you avoid a language war, but then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, being vague. You want to explain ideas on how to do things, with more or less details. Maybe you want to show, not an algorithm, but steps that lead to an algorithm, and later a program. Because you want to teach how to, not the version of algorithm X published by Y in 19xx, but buildhow to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

Pseudo-code allows discussion of approaches to a problem, without solving it entirely. For example the (in)famous "find the largest difference between 2 elements from an array".

One approach is

largest = 0
for each pair (i,j) of indices
   if the difference between t[i] and t[j] is > largest
       change largest

and another

find the min and the max of the array
largest is the difference

such pseudo-code is precise enough to discuss the 2 solutions.

Same kind of discussion about "should we use incomplete/incorrect UML diagrams when teachingteaching" ?".

I see two very different reasons to use pseudo-code.

First, being precise. You want to describe an algorithm in details, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. Maybe you avoid a language war, but then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, being vague. You want to explain ideas on how to do things, with more or less details. Maybe you want to show, not an algorithm, but steps that lead to an algorithm, and later a program. Because you want to teach how to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

Pseudo-code allows discussion of approaches to a problem, without solving it entirely. For example the (in)famous "find the largest difference between 2 elements from an array".

One approach is

largest = 0
for each pair (i,j) of indices
   if the difference between t[i] and t[j] is > largest
       change largest

and another

find the min and the max of the array
largest is the difference

such pseudo-code is precise enough to discuss the 2 solutions.

Same kind of discussion about "should we use incomplete/incorrect UML diagrams when teaching?".

I see two very different reasons to use pseudo-code.

First, being precise. You want to describe an algorithm in details, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. Maybe you avoid a language war, but then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, being vague. You want to explain ideas on how to do things, with more or less details. Maybe you want to show, but steps that lead to an algorithm, and later a program. Because you want to teach, not the version of algorithm X published by Y in 19xx, but how to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

Pseudo-code allows discussion of approaches to a problem, without solving it entirely. For example the (in)famous "find the largest difference between 2 elements from an array".

One approach is

largest = 0
for each pair (i,j) of indices
   if the difference between t[i] and t[j] is > largest
       change largest

and another

find the min and the max of the array
largest is the difference

such pseudo-code is precise enough to discuss the 2 solutions.

Same kind of discussion about "should we use incomplete/incorrect UML diagrams when teaching" ?

2 added 507 characters in body
source | link

I see two very different reasons to use pseudo-code.

First, youbeing precise. You want to describe an algorithm preciselyin details, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. ButMaybe you avoid a language war, but then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, youbeing vague. You want to explain ideas on how to do things, with more or less details. Maybe you want to show, not an algorithm, but steps that lead to an algorithm, and later a program. Because you want to teach how to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

Pseudo-code allows discussion of approaches to a problem, without solving it entirely. For example the (in)famous "find the largest difference between 2 elements from an array".

One approach is

largest = 0
for each pair (i,j) of indices
   if the difference between t[i] and t[j] is > largest
       change largest

and another

find the min and the max of the array
largest is the difference

such pseudo-code is precise enough to discuss the 2 solutions.

Same kind of discussion about "should we use incomplete/incorrect UML diagrams when teaching?".

I see two very different reasons to use pseudo-code.

First, you want to describe an algorithm precisely, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. But then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, you want to explain ideas on how to do things, with more or less details. Maybe you want to show, not an algorithm, but steps that lead to an algorithm. Because you want to teach how to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

I see two very different reasons to use pseudo-code.

First, being precise. You want to describe an algorithm in details, without being dependent of the particularities of some programming language. That's the way algorithms are presented in the CS literature. Maybe you avoid a language war, but then, you are dependent of the particularities of your notations anyway, so it sort of defeats its own purpose.

Second, being vague. You want to explain ideas on how to do things, with more or less details. Maybe you want to show, not an algorithm, but steps that lead to an algorithm, and later a program. Because you want to teach how to build algorithms, and this generally requires several steps of refinement with, in the middle, some yet-no-so-well-defined actions.

Pseudo-code allows discussion of approaches to a problem, without solving it entirely. For example the (in)famous "find the largest difference between 2 elements from an array".

One approach is

largest = 0
for each pair (i,j) of indices
   if the difference between t[i] and t[j] is > largest
       change largest

and another

find the min and the max of the array
largest is the difference

such pseudo-code is precise enough to discuss the 2 solutions.

Same kind of discussion about "should we use incomplete/incorrect UML diagrams when teaching?".

1
source | link