Learning Objectives

With this assignment you will demonstrate:

• The ability to write and test scripts, functions, and user-defined data types in Lua, JavaScript, and Python.
• The ability to apply concepts such as declarations, expressions, statements, static scope, constants, variables, types, functions, modules, assignments, function calls, higher order functions, closures, polymorphism, sequencing, selection, iteration, recursion, exceptions, generators, coroutines, and async-await.

Readings and Videos

Please:

• Read Chapters 2, 3, and 5 of Programming Language Explorations, 2nd edition.
• Locate, and keep handy, reference material for Lua, JavaScript, and Python. For JavaScript, the MDN tutorials and guide are good, as is any book by Axel Rauschmayer. Familiarize yourself with these materials, browsing sections related to the learning objectives for this unit.
• Review the course notes for Values, Entities, Binding, Expression Evaluation, and Control Flow. Follow as many of the links on those pages as is reasonable.

Instructions

Work in teams of 1 to 4 students.

Do all work in the GitHub repository you created in the previous assignment.

Remember: There must be only one official repository per group.

Repository

Add files according to the folder structure below. You will be implementing the assigned functions and classes from scratch. The test files have been written for you; follow the links to obtain them.

.
├── code/
│   ├── python/
│   │   ├── exercises.py
│   │   └── exercises_test.py
│   ├── javascript/
│   │   ├── exercises.js
│   │   └── exercises.test.js
│   ├── lua/
│   │   ├── exercises.lua
│   │   └── exercises_test.lua

Code

Implement—for Lua, Python, and JavaScript—modules that contain:

• A function that when given a sequence of strings $a$ and a predicate $p$, and a function $f$, returns $f(x)$ where $x$ is first element of $a$ that satisfies $p$, or if there is no such $x$, a representation of its non-existence.
• A generator that yields successive powers $b^0, b^1, \ldots$ of base $b$ going up to, but not exceeding, a given limit.
• A function that accepts a filename and returns the number of text lines in the file that are neither (1) empty, nor (2) made up entirely of whitespace, nor (3) whose first nonwhitespace character is #.
• A “chainable” function that accepts at most one string per call and that when called without arguments, returns the words previously passed, in order, separated by a single space:

  say("Hello")("my")("name")("is")("Colette")()
      "Hello my name is Colette"
  
  say()
      ""
  

• A user-defined datatype for quaternions. You should be able to (1) construct, (2) add, (3) multiply, (4) obtain the list of coefficients, (5) compute the conjugate, (6) support value-based equality, and (7) produce the string representation.

Further instructions can be found in the unit tests, which serve to define the names and desired behaviors of the functions and classes, sometimes including the names of files and parameters, and how exactly the parameters should be passed. But keep in mind not every detail will be captured in the tests! The following requirements will be inspected during manual grading:

• All Python functions and methods must employ type hints for their parameters and return types.
• For the generator problem, your JavaScript solution must destructure its argument and your Python solution must accept keyword arguments only.
• For the say function, your Python solution must be written to accept a single, default, positional argument only.
• For the file-reading function, the Python solution must take a positional argument only. In addition, we will be checking that you properly close the file after reading it. If your language has a mechanism for auto-closing, you must use it; otherwise, you must explicitly close the file.
• For the Quaternion datatype, your JavaScript and Python objects must be frozen, and the Lua solution must follow the exact pattern used in the course notes on Entities.

Strive to use the most idiomatic constructs of each language in your solutions.

Generative AI is permitted for this assignment; however, there is no guarantee that it will produce code that meets all of the requirements. Do not try to prompt your way to working solutions. Make sure to thoroughly review and test any code produced by AI tools.

To use the supplied unit tests, you should create a folder called test-data (as a sibling of code and exercises), that contains a single file called test-for-line-count.txt with the following contents:

  hello

😁👩🏽‍🎤 👩🏽‍🎤🧑🏻‍🔧 🧑🏻‍🔧     🧑🏻‍🔧

    # hash1
# hash2 ####

  hash is not at the beginning # ⇐⇐⇐ but here





                     ----
last

Run the tests in their corresponding code folders, with the following commands:

• lua exercises_test.lua
• node --test exercises.test.js
• python exercises_test.py

Exercises

In the file exercises/hw2.md, provide solutions to the following problems. You will need to do research, as not all of these topics were covered in class. For exercises that ask you for prose answers, please be comprehensive and demonstrate a broad understanding. But avoid long-winded, silly gen-ai answers. Expect deductions for verbatim copies of AI slop. Be precise and concise.

1. Why is the null reference so hideous?
2. Why did Tony Hoare introduce the null reference, even though he felt like it was wrong and his friend Edsger Dijkstra said it was a bad idea?
3. In JavaScript 3**35 = 50031545098999710 but in Python 3**35 = 50031545098999707. Which one is right and which is wrong? Why? Explain exactly why the right value is right and the wrong value is that particular wrong value.
4. What is the Python equivalent of JavaScript’s {x: 3, [y]: 5, z}?
5. Why is it best to not call JavaScript’s == operator “equals” (even though people do it all the time)?
6. Write a Lua function called arithmeticsequence that accepts two arguments, start and delta, that returns a coroutine such that each time it is resumed it yields the next value in the arithmetic sequence starting with start and incrementing by delta.
7. What does this script print under (a) static scoping and (b) dynamic scoping?

   var x = 1
   function h() {var x = 9; return g();}
   function f() {return x;}
   function g() {var x = 3; return f();}
   print f() * h() - x
   

8. Why does shallow binding not make much sense when combined with static scoping?

Please use professional and well-structured Markdown formatting for your answers. Take pride in your work. Show you care.

Submission

To submit your work, choose one and only one team member to submit to BrightSpace (1) the names of all team members, (2) the URL of your private repository, and (3) an affidavit for each team member stating that they have done the assigned book readings and reviewed the aforementioned course notes pages.

Teamwork

Remember that, when working in teams, all team members should participate in generating solutions and are responsible for understanding all submitted answers. Ideally, each team member should produce individual answers for all exercises, and the team should combine them to produce the ultimate submissions.

Grading

You will be graded both on the correctness of your solutions, adherence to each language’s conventions, the following of the assignment instructions, and the cleanliness of the repository. Feedback will be in the form of deductions for such things as:

• Not following the spacing, indentation, and capitalization conventions of each language
• Poor names (note that even if the exercise descriptions above use short names, your solutions should use readable names where appropriate)
• Naming an entity in a way that has nothing to do with the variable’s purpose
• Defining variables that are never used
• Unnecessary comments
• Missing necessary comments
• Data that is mutable when immutability is called for
• Lack of information hiding (to the extent allowed by the language)
• Failing to meet any explicitly specified implementation requirement (not every requirement is captured by the unit tests)
• Code that is needlessly inefficient
• Code that does not properly manage resources, such as that which fails to release allocated memory or close open file handles
• Code that is too complex and fails to take advantage of the language features covered in class that are designed to facilitate the assigned task (deductions will be small here: you should, when unsure of the “best” solution, to at least give a solution, since a working substandard solution is better than no solution at all)
• A repository structure that varies from the specified layout
• Extra files in the GitHub repository
• Not following submission instructions; for example, not supplying the names of every group member or not providing the URL of your repository or not including reading affidavits for each group member

This list is not exhaustive, but should help in getting you used to paying attention to your submissions and taking pride in your work. Note that most code editors have plugins that will auto-format your code and even look for suspicious coding practices. You are strongly encouraged to use them.

Your homework submission will be the state of your repository on your main branch, at 18:00 in the America/Los Angeles time zone on the due date.