Homework 9: Feature Design
CS 538: Programming Languages
Deadline: May 10 23:59
Objective: This project is designed to challenge your ability to condense complex information into a clear and insightful one-page document. You will explore and compare a specific feature of programming language design against a contrasting approach. Your analysis should provide a mature understanding of the feature, highlight critical differences with the alternative, and offer commentary on the feature’s evolution.
Instructions:
Use the following instructions as a guide to write this report. You may skip, expand or introduce a new section if needed to convey your ideas. The headers and word counts are suggestions.
If you are writing more than 500 words, you are probably not being concise enough.
. Introduction (1 sentence): Introduce the language feature and its importance in the context of programming language design.
. Feature Analysis (100 words): Describe the design axis of your chosen language feature. Provide insight into its theoretical underpinnings and real-world utility.
. Comparative Analysis (200 words): Compare the language feature with an alternative. Identify and succinctly discuss the trade-offs involved (e.g. efficiency, reliability, scalability, developer experience).
. Evolutionary Perspective (200 words): Briefly outline the historical evolution and recent develop-ments or future trends related to the language feature. In particular, how has the design axis changed over time.
. References (in a footer): Cite at least three high quality sources, such as technical papers, books, or expert commentary. Use a short citation format of your choice which I can follow.
Format:
Single page.
Small headings for each section.
Include citations where relevant.
Export your document as a PDF in layout and formatting that enhances readability.
Assessment Criteria:
Depth of analysis and insight
Relevance and accuracy of comparisons
Quality of sources and literature integration
Clarity of expression and adherence to space constraints
Note: I not only allow, but encourage you to use language model assistants when writing this report. I would recommend using them as a form of refinement for your writing process.
Note: If you find yourself writing ”as mentioned above,” you are not being concise. I would recommend beginning by copy-pasting the first paragraph of your topic from wikipedia. Write your page with that at the top (not counting towards page limit). Then, when you are done with your page, delete the wiki paragraph.
Note: An example is worth 300 words. If you can show something with a short example, that is preferable to trying to vaguely describe a concept.
Note: If your paper is summed up with X is er, Y is er, you haven’t written a paper. You’ve written a boring tweet.
Feature List
It is recommended, but not required, that you choose a feature from the list below. Memory management is intentionally omitted from this list because it tends to be lead to low quality submissions.
1. Type Systems:
. Time of Typing (e.g. static, dynamic)
. Strength of Typing (e.g. strong, weak)
. Type Inference
2. Concurrency Models:
. Thread-based Concurrency (e.g., Java threads)
. Event-driven Asynchronous Models (e.g., JavaScript’s event loop)
. Actor Model (e.g., Erlang)
3. Error Handling Mechanisms:
. Exceptions (e.g., Java, Python)
. Return Codes (e.g., C)
. Result Types/Sum Types (e.g., Rust’s Result < T, E >, Haskell)
4. Function Invocation:
. Call by Value vs. Call by Name
. First-class Functions and High-order Functions
. Tail-call Optimization
5. Design Patterns for Code Reusability:
. Inheritance vs. Composition vs. Dependency Injection
. Mixins and Traits (e.g., Scala Traits, Ruby Modules)
. Prototypal Inheritance (e.g., JavaScript)
6. Module Systems and Namespace Management:
. Package Management (e.g., NPM for JavaScript, PIP for Python)
. Modular Programming (e.g., Java Modules)
. Namespaces and Scoping Rules
7. Immutable vs. Mutable Data Structures:
. Benefits of Immutable Data (e.g., in functional languages like Haskell)
. When and Why to Use Mutable Data (e.g., performance considerations in imperative languages)
8. Compiling Strategies:
. Just-In-Time (JIT) Compilation (e.g., JavaScript V8 Engine)
. Ahead-of-Time (AOT) Compilation (e.g., C/C++, Rust)
. Transpilation (e.g., TypeScript to JavaScript)