Please my friends
Can you answer these questions related to the Julia programming language ?
Classify your language (imperative, functional, logic, OO, your choice).
Is the scoping static or dynamic?
Is type checking static, dynamic, neither, or some combination? What are the
built-in types? Which are primitive?
- When are two types equivalent? Are there exceptions? Be sure to include user
defined types in your consideration.
- What parameter modes are available? Comment on whether or not these
modes are adequate for good programming practice.
- 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
- 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?
- 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
- 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?
- 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
- 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.
- 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?
- 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
- Find 3 classes of errors which your translator alerts you to and 3 which it does
- In what ways are user-defined types treated differently from built in types?
In what ways are they treated the same?