Please help, I study computer science at the university

qais
Mon, 11 May 2020 05:02:06 +0000
New to Julia

Please my friends
Can you answer these questions related to the Julia programming language ?

1. Classify your language (imperative, functional, logic, OO, your choice).

2. Is the scoping static or dynamic?

3. Is type checking static, dynamic, neither, or some combination? What are the

built-in types? Which are primitive?

4. When are two types equivalent? Are there exceptions? Be sure to include user

defined types in your consideration.

5. What parameter modes are available? Comment on whether or not these

modes are adequate for good programming practice.

6. What kinds of parameters can be passed, i.e., can functions or procedures be

passed? Comment on any deficiencies and give suggestions for addressing those

deficiencies.

7. If there is a case (switch) statement, what happens when an unspecified choice

is evaluated for the expression controlling the case statement? What kinds of

expressions are permissible for controlling the case statement and why?

8. How are cartesian products supported? Are there variant records? If so, what

happens if you ask to print a value that a given record should not have? If not, is

there some way to compensate? Comment on the desirability of variant records

and suggest how they might be implemented. Can an array contain entries of

different types or must they all be of the same type? How much about the

implementation does a programmer need to know in order to use arrays and

records efficiently?

9. If there are for loops, does the language permit jumping into the loop?

Modifying the loop control variable inside the loop? Jumping out of the loop?

10. What kinds of iteration are supported? For example, while , repeat-until , do ,

etc. Are they all equivalent? Explain how they differ and how they are alike by

writing code in each of the syntactic possibilities for a single problem with an

iterative solution.

11. Is it possible to exit from any of these iterative constructs before the natural

end is reached? If so, how and where does the control resume? If not, tell how

such an exit might be added to the language.

12. How are dynamic variables ( pointers ) handled? Are there dynamic arrays?

If so, how are they implemented? Is this a good idea? Why or why not?

13. What happens if you write A := B (or A = B) when both A and B are arrays?

when both A and B are records? when both A and B are of the same user defined

type? Note: the answer may depend on operator overloading depending on the

language. Give reasons why it might be a good idea to allow variables of user

defined types to be assigned to each other and reasons why it might not be a good

idea.

14. Find 3 classes of errors which your translator alerts you to and 3 which it does

not.

15. In what ways are user-defined types treated differently from built in types?

In what ways are they treated the same?

10 posts - 5 participants