The Study of Programming Languages

Hello! Since you are here, you are probably wondering if the study of programming languages a worthy pursuit. “What’s in it for me?” you may ask. You’ve come to the right place. “How should I study them?” you may ask. You’ll find that out, too.

Welcome

Do you find it interesting that humans have so many different ways to express themselves? Even a single thought can be communicated in a multitude of ways.

How many ways can you express the computation of summing the squares of the even numbers in a list? Let’s look at a few ways. One approach is to explicitly iterate through the list, checking each element to see if it is even, and if so, squaring it and accumulating the square into the final answer.

int sum_of_even_squares(int* a, unsigned int length) {
    int total = 0;
    for (unsigned int i = 0; i < length; i++) {
        if (a[i] % 2 == 0) {
            total += a[i] * a[i];
        }
    }
    return total;
}

func sumOfEvenSquares(a []int) int {
    total := 0
    for _, x := range a {
        if x % 2 == 0 {
            total += x * x
        }
    }
    return total
}

function sumofevensquares(a)
  local total = 0
  for _, x in ipairs(a) do
    if x % 2 == 0 then
      total = total + x * x
    end
  end
  return total
end

Another approach is to first filter (a.k.a. ”select”) the even numbers, then map the squaring operation over each of them, and finally reduce (a.k.a “fold”) the plus operation over the filtered-and-squared values to produce the result. For example:

Most major programming languages have these operations built-in.

function sumOfEvenSquares(a) {
  return a.filter(x => x % 2 === 0).map(x => x**2).reduce((x, y) => x + y, 0)
}

def sum_of_even_squares(a)
  a.select{|x| x % 2 == 0}.map{|x| x * x}.reduce(0, :+)
end

func sumOfEvenSquares(_ a: [Int]) -> Int {
    return a.filter{$0 % 2 == 0}.map{$0 * $0}.reduce(0, +)
}

(defn sum-of-even-squares [a]
  (->> a (filter even?) (map #(* % %)) (reduce +)))

public static int sumOfEvenSquares(int[] a) {
    return IntStream.of(a).filter(x -> x % 2 == 0).map(x -> x * x).sum();
}

fun sumOfEvenSquares(a: Array<Int>): Int {
    return a.filter { it % 2 == 0 }.map { it * it }.sum()
}

function sumOfEvenSquares(a)
  sum(x -> x^2, filter(x -> x % 2 == 0, a), init = 0)
end

sumOfEvenSquares := method(a,
  a select(isEven) map(x, x**2) reduce(x, y, x + y) ifNil(return 0))

fn sum_of_even_squares(a: &[i32]) -> i32 {
    a.iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * x)
        .sum()
}

sub sum_of_even_squares {
    sum0 map { $_**2 } grep { $_ % 2 == 0 } @_;
}

let sum_of_even_squares a =
    a
    |> List.filter (fun x -> x % 2 = 0)
    |> List.sumBy (fun x -> x * x)

Sometimes you can specify the filtering, mapping, and reducing functions without parameters:

sumOfEvenSquares :: [Int] -> Int
sumOfEvenSquares = sum . map (^ 2) . filter even

: sum-of-even-squares ( seq -- n )
    [ even? ] filter [ sq ] map sum ;

Sometimes the filtering and mapping can be expressed in a single construct known as a comprehension:

def sum_of_even_squares(a):
    return sum(x**2 for x in a if x % 2 == 0)

proc sum_of_even_squares(a) {
  return + reduce ([x in a] if x % 2 == 0 then x*x else 0);
}

function Sum_Of_Even_Squares (A : Integer_Array) return Integer is
begin
   return [for X of A when X mod 2 = 0 => X * X]'Reduce ("+", 0);
end Sum_Of_Even_Squares;

Some languages have really, really powerful operators for processing arrays:

sumOfEvenSquares ← {+/((2|⍵)=0)×⍵*2}

sumofevensquares: {+/x[&~x!2]^2}

function sum_of_even_squares(a) result(total)
  integer, intent(in) :: a(:)
  integer :: total
  total = sum((a**2) * merge(1, 0, mod(a, 2) == 0))
end function

function sumOfEvenSquares(a)
  sum((a[a .% 2 .== 0]).^2)
end

Why Study Programming Languages?

Well that was sure a lot of languages. You are now either excited or overwhelmed. But if you have patience and perseverance and take on a study of programming languages, you will reap many benefits, both professional and social.

Professional Benefits

Studying programming languages will help you in many ways! For instance, you will:

Express yourself better

Expertly wielding language allows you to communicate ideas powerfully. Programming is a form of written expression just like novels, short stories, technical manuals, wikis, screenplays, essays, dialogues, articles, and poetry. Just as knowledge of rhetoric can improve your prose, verse, and arguments, knowledge of programming languages improves your ability to express computations elegantly and precisely. Studying not only how-to-program, but the mathematical formalisms underlying language syntax and semantics, leads to expertise in writing precise and unambiguous specifications and implementations of information structures and processes.

Become a better technical decision-maker

Understanding a variety of languages and language paradigms enables you to make informed choices when selecting the most appropriate language for a given task, as some languages do a great job expressing some kinds of tasks and do a terrible job at others. Your study will enable you to describe design tradeoffs (garbage collection or not, compile-time type safety or not) and be able to articulate how exactly languages like Rust, Swift, and Zig compete against C and C++.

Learn new languages more easily

Thinking in terms of language independent concepts (e.g. types, sequencing, iteration, selection, recursion, concurrency, subroutines, parameterization, naming, scope, abstraction, inheritance, composition, binding, method dispatch, and so on), rather than in one particular language’s syntactic constructs (e.g., “if statement,” “while statement,” “virtual function”), enables you to adapt to any programming environment. A time will surely come when you will author programs in a language you never even heard about.

... Mastering more than one language is often a watershed in the career of a professional programmer. Once a programmer realizes that programming principles transcend the syntax of any specific language, the doors swing open to knowledge that truly makes a difference in quality and productivity. — Steve McConnell
Become more productive

If you know how and why a language was designed, you can:

  • use a language’s features effectively, for the purposes they were designed
  • choose the best and most efficient feature for the task at hand
  • utilize some of its non-obvious powerful features
  • simulate useful (and powerful) features from other languages that your language lacks
  • understand obscure features
  • understand weird error messages
  • understand and diagnose unexpected behavior
  • understand the performance implications of doing things a certain way
  • have better conversations with AI code assistants
  • know when to and when not to trust the suggestions of AI code assistants
  • use a debugger effectively
Design (and implement!) your own language

There are many good reasons for creating new languages to solve problems (see this essay by Tom Van Cutsem). Even if you never create a “full programming language,” you might need to write your own little language as part of a larger application, for example:

  • A query language for database access
  • A query language for a search engine
  • A calculator
  • A console interface to an adventure game
Expand your mind

You cannot grow when your thinking about programming is fixed. Study programming languages to encounter fascinating ways of programming you might never have even imagined before, achieving enlightenment as you deeply understand pattern matching, type inference, closures, prototypes, introspection, instrumentation, just-in-time compilation, annotations, decorators, memoization, traits, streams, monads, actors, mailboxes, comprehensions, continuations, wildcards, regular expressions, proxies, and transactional memory.

Exercise: What is a monad? What is a continuation?

Your study will lead you to embrace languages, and programming environments, that may be different than you’ve ever imagined. You do know about eToys, right?

Prepare yourself to build some stunning things

Imagine formally-verified compilers, formally-verified hardware, formally-verified programs, the world’s smartest and fastest IDE, code generators from specifications, block-programming environments that actually work, and so on. To build programs that manipulate and build other programs, you need the deep understanding of what programs are, and this comes from studying the field of Programming Languages.

So basically, you will become happier and make more money.

Social Benefits

Studying programming languages may even enable you to:

Is it Really a Field of Study?

The ACM says yes!

Knowledge AreaCodeSome Topics
Algorithms and ComplexityALAlgorithmic Analysis • Algorithmic Strategies • Data Structures and Algorithms • Automata • Computability • Computational Complexity
Architecture and OrganizationARDigital Logic and Digital Systems • Machine-level Data Representation • Assembly-Level Machine Organization • Memory System Organization and Architecture • Interfacing and Communication • Functional Organization • Multiprocessing and Alternative Architectures • Performance Enhancements
Computational ScienceCNModeling and Simulation • Processing • Interactive Visualization • Data, Information, and Knowledge • Numeric Analysis • Symbolic Computation • Mathematical Modeling • High-Performance Computing
Discrete StructuresDSLogic • Sets, Relations, and Functions • Proof Techniques • Basics of Counting • Graphs and Trees • Discrete Probability
Graphics and VisualizationGVMedia Applications • Digitization • Color Models • Rendering • Modeling • Animation • Visualization
Human-Computer InteractionHCIInteractive Systems • Testing • Collaboration and Communication • Statistical Methods • Human Factors • Mixed, Augmented, and Virtual Reality
Information Assurance and SecurityIASDefensive Programming • Threats and Attacks • Network Security • Cryptography • Web Security • Platform Security • Policy and Governance • Digital Forensics • Secure Software Engineering
Information ManagementIMDatabase Systems • Data Modeling • Indexing • Key-Value, Document, Relational, and Graph Databases • Query Languages • Transaction Processing • Distributed Databases • Physical Database Design • Data Mining • Information Storage and Retrieval • Multimedia Systems
Intelligent SystemsISKnowledge Representation and Reasoning • Search • Machine Learning • Reasoning Under Uncertainty • Agents • Natural Language Processing • Robotics • Speech Recognition and Synthesis • Perception and Computer Vision
Networking and CommunicationNCNetworked Applications • Reliable Data Delivery • Routing and Forwarding • Local and Wide Area Networks • Resource Allocation • Mobility • Social Networking
Operating SystemsOSOperating System Organization • Concurrency • Scheduling and Dispatch • Memory Management • Security and Protection • Virtual Machines • Device Management • File Systems • Realtime and Embedded Systems • Fault Tolerance • System Performance and Evaluation
Platform-Based DevelopmentPBDWeb Platforms • Mobile Platforms • Industrial Platforms • Game Platforms
Parallel and Distributed ComputingPDParallel Decomposition • Communication and Coordination • Parallel Algorithms, Analysis, and Programming • Parallel Architecture • Parallel Performance • Distributed Systems • Cloud Computing • Formal Models and Semantics
Programming LanguagesPLObject Oriented Programming • Functional Programming • Event-Driven and Reactive Programming • Type Systems • Program Representation • Language Translation and Execution • Syntax Analysis • Semantic Analysis • Code Generation • Runtime Systems • Static Analysis • Concurrency and Parallelism • Type Systems • Formal Semantics • Language Pragmatics • Logic Programming
Software Development FundamentalsSDFAlgorithms and Design • Fundamental Programming Concepts • Fundamental Data Structures • Development Methods
Software EngineeringSESoftware Processes • Project Management • Tools and Environments • Requirements Engineering • Software Design • Software Construction • Software Verification and Validation • Software Evolution • Software Reliability • Formal Methods
Systems FundamentalsSFComputational Paradigms • Cross-Layer Communications • State and State Machines • Parallelism • Evaluation • Resource Allocation and Scheduling • Proximity • Virtualization and Isolation • Reliability through Redundancy • Quantitative Evaluation
Social Issues and Professional PracticeSPSocial Context • Analytic Tools • Professional Ethics • Intellectual Property • Privacy and Civil Liberties • Professional Communication • Sustainability • History • Economics of Computing • Security Policies, Law, and Crime

To be honest, this mass of keywords doesn’t really do the topic justice. In fact, this whole table makes computer science look dry, technical, and boring. The PL field is much bigger, and even more fundamental, than the table would suggest.

In fact, you might even find the study of languages, especially in its theoretical side, to be even more fundamental than the favorite of job interviewers—Data Structures and Algorithms (AL). Language theory directly deals with how information itself is expressed, organized, and manipulated. Without a way to represent data or computation, we really wouldn’t have computer science. And the part of compute science that language theory studies is really fun: it’s about people expressing themselves in all kinds of fascinating ways.

How to Study Programming Languages

Self-check time! Make sure you know what a programming language is.

Yes, that link was to a Wikipedia article. Did you read the article? No? Read it. Now? Okay, let’s lay out a study plan.

An effective study of programming languages has these five dimensions:

Case Studies

Learn a bunch of existing languages, and understand how each expresses and implements various concepts.

Concepts

Study the vast array of important concepts, and understand how each is expressed in a variety of languages.

Foundations

Learn the fundamental philosophical and mathematical theories that give rise to language and computation.

History

Understanding history is essential for learning any discipline and the study of programming languages is no exception.

Pragmatics

Programs and Programming Languages are written by people for people. Understanding the human use and perception of languages is crucial.

The rest of these introductory notes provide a whirlwind introduction to each of these five items, in this order:

  1. History
  2. Learning (Specific) Languages
  3. Learning (Language-independent) Concepts
  4. (Mathematical and Logical) Foundational Theories
  5. Pragmatics

History

Your study of programming languages is enhanced when done in a historical and human context. There have been many books and articles written on the History of Programming Languages (HOPL). It’s really fascinating! And super important, too. Perhaps you’ll find it exciting too.

We can’t cover the entire field here, but we can provide just enough of the highlights to give you a sense of where the languages of today came from:

Early History
Prior to the 1940s we have the Jacquard machine and Ada Lovelace's programming of the Analytical Engine. Plankalkül is designed in the early 1940s but never gets popular. It’s a high-level language, yes, but mostly symbolic.
1950s-1960s Rise of natural language-like languages
Grace Hopper leads the COBOL effort (business computing), John McCarthy leads Lisp (AI), John Backus leads Fortran (scientific computing). Early Algol becomes popular and eventually we get behemoth multi-purpose languages like Algol 68 and PL/1.
1970s The structured programming revolution begins
Languages providing information hiding, such as Modula, CLU, Simula, Mesa, and Euclid attempt to address the “software crisis.” Structured and modular features are bolted on to earlier languages.
1980s Object-orientation takes over the world
Though begun in the 1960s with Simula and refined in the 1970s at Xerox PARC with Smalltalk, OO—or approximations to it—explodes in the 1980s with C with Classes (since renamed C++), Objective-C, Eiffel, and Self. Earlier languages such as Lisp and Pascal gain OO features, becoming Common Lisp and Object Pascal, respectively.
1990s The World Wide Web appears
Perl becomes popular. Java, JavaScript, and PHP are created with web applications in mind.
2000s: Interest in established dynamic languages such as Ruby takes off
Scala shows that static languages can feel dynamic. Clojure arrives as a dynamic, modern Lisp, leveraging Java’s virtual machine.
2010s: Old things become new again
Multicore processors and “Big Data” revive interest in functional programming. Older languages such as Python and R, and the newer Julia language, find use in data science. Net-centric computing and performance concerns make static typing popular again as Go, Rust, and Swift challenge C and C++ for native applications.
2020s: People are talking about AI again
Mojo is created with direct support for AI, and particularly machine learning, applications, allowing programmers to not have to employ a variety of external packages to get their work done.

Overviews are nice, but you’ll need to go much deeper. These sources will get you started:

Many people don’t realize what incredible work happened in the 1960s and 1970s. Learn about this era in this informative and entertaining look into what this work could have turned into, so much sooner than it did, if only people had carried out the visions:

Exercise: Watch this video, please. Follow along with the video notes and references.

Follow up with your own web searches for “History of Programming Languages” or “Evolution of Programming Languages.”

Learning Languages

One dimension of the study of programming languages is writing a lot of programs in a lot of languages, and learning each of those languages deeply. By doing so, some of the important linguistic concepts will naturally emerge. But which languages should you learn, and what should you learn about them? A good place to start is to note:

Understanding a language’s motivation for existence is essential. It is unfair to criticize a language for doing a bad job in an area which it was never intended to be used for.

Some Significant Languages

Here are a few languages that for some reason or another rate as significant. The reasons why they are grouped the way they are shown here will be discussed in class:

Motivation

Here are some languages and their motivations for being created. In some cases, the language found a niche outside the purpose for which it was designed. But the point is that some problem was seen as significant enough to warrant a new language.

Exercise: Java is an example of a language whose primary use turned out to be completely different from its original design purpose. What are Java’s niches today?

Where to Learn More

Language lists, comparisons, and taxonomies:

Exercise: Can anyone find more recent lists?

Learning Language Concepts

An important part of language study is a deep understanding of language-independent concepts. The vocabulary around programming languages is massive, so how can you organize all this knowledge you will be gaining?

The Big Picture

Let’s begin with some critically important terminology that underlies the study of programming languages. It is time for a vocabulary fire hose. You can handle it.

Programming languages express computations. A computation generates new information from existing information by mechanical means. What, then, is information? Information is that which informs. All usable information is representable as strings of characters over some alphabet. Today, virtually every information system uses the Unicode alphabet. Here are some example strings that give evidence that Unicode is sufficient for anything of interest to us:

91332.3e-81
⚠️ Stay BEHIND the yellow line! ⚠️
<ul><li>你好</li><li>ᎣᏏᏲ</li><li>ᐊᐃᓐᖓᐃ</li></ul>
/Pecs/Los Angeles/Berlin/Madrid//1 2/3 0/2 2/2 0/3 2///
(* (+ 88 3) (- 9 57))
int average(int x, int y) {return (x + y) / 2;}
{"type": "dog", "id": "30025", "name": "Lisichka", "age": 13}
∀α β. α⊥β ⇔ (α•β = 0)
1. f3 e5 2. g4 ♛h4++

Each character in Unicode can be encoded into bits. The most widely used encoding for characters today is UTF‑8. Information in the form of character strings is good for humans; information reduced to (encoded) bit strings is better for processing and transmission by machines. Example: The character CHEROKEE LETTER O, written as Ꭳ, is encoded in UTF-8 as 111000011000111010100011.

Information is chunked into meaningful units called values. Values can be characters, numbers (e.g., 389.221E-25), or atoms (e.g., true, false, null, north, south, blue), as well as composite values such as tuples, records, lists, sets, dictionaries, references, functions, and more. Values inhabit types which classify values by their shared behavior.

Programs are built from entities such as declarations, expressions, statements, literals, variables, functions, procedures, coroutines, threads, processes, modules, and packages. Entities refer to, store, or manipulate values.

Values vs. entities

It is sometimes easy to get confused between values, literals, and variables. This should help: values are pure information that exist outside of a program. Entities are program constructs that live inside the program: entities are the components from which programs are constructed. Literals and variables (both of which are entities) stand for and contain values, respectively.

The statics of a language defines how to construct programs out of entities, and specifies what we can know about the program before running it.

When a program runs, computational entities generate and respond to events by carrying out actions, some of which produce observable effects upon the world. Internally, computations can be viewed as one or more lines of execution. Within each line, computation proceeds according to various types of control flow (sequential, conditional, iterative, nondeterministic, or disruptive). The study of the communication and coordination between lines of execution is known as concurrency.

The dynamics of the language describe the computational orders and effects.

Our introduction to the basic concepts of programming languages are covered in these notes.

The Big Questions

Now, before we can begin to organize all this knowledge, we’ll want to ask some pretty deep, philosophical questions, that will help to motivate an ontology, or at least the beginnings of one.

Ontologies

When we start examining the little things, it’s nice to organize concepts into an ontology. There are many possible ontologies. Here’s a very rough one with eight top-level study areas. Don’t worry if most of these terms are completely unfamiliar.

Exercise: Make sure you understand the difference between an expression and a statement. Give examples of each.

Theoretical Foundations

A study of just about anything can be enhanced with mathematical and logical precision. For programming languages, we want a way to specify, unambiguously, exactly what are the legal programs in a language, and what exactly they mean. Natural language is open to interpretation and fuzziness and ambiguity, so we would like to bring in some mathematical machinery as expressed in the study of logic and various mathematical and computational theories.

Pragmatics

Pragmatics does not affect the formal specification of programming languages; however, pragmatic concerns must guide your design of a programming language—if you want it to be easy to read, easy to write, and able to be implemented efficiently. Pragmatics encompasses:

Vision and Values

We can think of a language’s value system as what it is that the language wants to be. The values stem from the vision of the designers and ultimately play a role in making a language learnable, usable, and maybe even successful. To get a sense of what this all means, see Ashley Williams’ amazing talk subtitled “How language values shape the features we build and the journeys we take to design them.” It focuses on JavaScript and Rust, but the ideas are universally applicable:

Evaluation Criteria

Reasonable people know that all languages have their pros and cons. But why are some things pros and other things cons? Under what criteria can we evaluate programming languages?

Technical Criteria

There are certain technical criteria. For example, is the language:

Also see Wikipedia’s Programming Language Comparison article.

Non-Technical Criteria

There are non-technical, subjective criteria, too. Good and successful are not the same! Success comes from:

Exercise: What else can you think of that makes people want to use a particular language?

Expressiveness

Expressiveness is a pragmatic concern, too, influencing how a language can be wielded to say what needs to be said. Some languages want to be verbose, low-level, or “close to the machine” and others want to be terse or expressive. At the beginning of these notes, we saw a function to return the sum of the squares of even numbers in a list in a bunch of different languages. Revisit those examples now with an eye toward what you think the designers of each language want you to be able to, or not be able to, express. What constraints are they placing on you?

Related to expressiveness is the idea of code as art, or art as code. Here’s a discussion of what this actually means:

Popularity

There are countless numbers of ways to measure popularity! You really can’t make popularity statements without stating your measure. Then people will argue whether your measure is even valid. 🤷‍♀️ Nevertheless, it’s fun to look at this stuff from time to time.

RedMonk has a language ranking scheme that combines pull requests on GitHub and questions on StackOverflow. (One could argue that this measures how confusing a language is too...maybe most of the StackOverflow questions are language complaints?) Here is the ranking from March, 2024:

redmonk.png

RedMonk gives these rankings:

  1. JavaScript
  2. Python
  3. Java
  4. PHP
  5. C#
  6. TypeScript
  7. CSS
  8. C++
  9. Ruby
  10. C
  11. Swift
  12. Go
  13. R
  14. Shell
  15. Objective-C
  16. Scala
  17. Kotlin
  18. PowerShell
  19. Rust
  20. Dart

Another ranking system, by Tiobe, ends up with a radically different top 20. They say: “The ratings are based on the number of skilled engineers world-wide, courses and third party vendors. Popular search engines such as Google, Bing, Yahoo!, Wikipedia, Amazon, YouTube and Baidu are used to calculate the ratings.”

The YouTube channel Context-Free has a video on language popularity (covering the Languish app):

Interesting how Tiobe ranks Ada as #9 but Languish places it at #161. Go figure.

But what makes a language popular? MPJ has thoughts:

Tradeoffs

You can’t have everything, it seems:

Exercise: Think up some other tradeoffs.
No Competition!

Don’t make the mistake of thinking programming languages are like sports teams—they don’t compete against each other. Don’t root for one to “win.”

Realize that languages serve different purposes and are often used together to build systems.

Recall Practice

Here are some questions useful for your spaced repetition learning. Many of the answers are not found on this page. Some will have popped up in lecture. Others will require you to do your own research.

  1. What Java expression will sum the squares of even numbers in an array?
    IntStream.of(a).filter(x -> x%2==0).map(x -> x*x).sum()
  2. What is the generator expression to sum the squares of even numbers in Python?
    sum(x**2 for x in a if x % 2 == 0)
  3. Which are the languages with these logos?
    Capital F in Purple Square Multicolored K Yin and Yang Lambda Blue and Yellow snakes
    Fortran, Kotlin, Lisp, Python.
  4. What professional benefits can you gain from studying programming languages?
    • Better expressive capacity
    • Better technical decision making
    • Ability to learn new languages more easily
    • Better productivity
    • Ability to create new languages
    • New ways of thinking
    • Ability to create tools to manipulate language and knowledge
  5. Programs are a form of ________________ just like novels, short stories, technical manuals, wikis, screenplays, essays, dialogues, articles, and poetry.
    Literature, writing, or written expression.
  6. “If statements” are a form of ________________ and “while statements” are a form of ________________.
    conditional execution; iteration.
  7. What programming language did Alan Kay demo in his 2013 Video Programming Languages and Programming?
    I’m not telling you. Watch the video. It is worth your time. If you watched the video, you know.
  8. What are five dimensions of an effective study of programming languages?
    1. Learning specific languages
    2. Learning language-independent concepts
    3. Learning mathematical formalisms for the description of languages
    4. Programming Language History
    5. Programming Language Pragmatics
  9. What are three of the most popular programming languages created in the 1950s? What was the primary domain of each?
    Fortran for scientific computation, Lisp for artificial intelligence, and COBOL for business.
  10. What “revolution” in programming characterized the 1970s?
    Structured Programming.
  11. What programming paradigm started taking over the world in the 1980s?
    Object orientation.
  12. What “movements” brought back interest in functional programming in the early 21st century?
    (1) The rise of multicore processors, and (2) the rise of big data.
  13. In Bret Victor’s The Future of Programming, what are the four “predictions” his 1973 persona predicted for 2013 that did not actually take over to the degree one might have wished?
    I really don’t want to share the answer because the video is so important that you need to watch the whole thing yourself. But you know, it’s good to be able to check your recall abilities, so here they are:
    • Direct manipulation of data over writing lines of code
    • Goals (what you want) over procedures (how to get what you want)
    • Spatial representation of data over text representations
    • Parallel execution over sequential execution
  14. When studying individual languages what we must always keep in mind?
    The reason why the language was designed, which is often a particular problem domain for which it was intended to operate in.
  15. Which language was the successor to Objective-C?
    Swift.
  16. Verse was designed for ________________ and Mojo was designed for ________________.
    Metaverse applications; AI and Machine Learning applications.
  17. All usable information can be represented as strings of characters. For most computation today, what alphabet are characters drawn from?
    Unicode.
  18. What are the three basic information units that can be encoded into bits?
    Characters, numbers, and atoms.
  19. Information is chunked into ________________.
    Values.
  20. Values are classified into ________________.
    Types.
  21. What are entities? Name some.
    Entities are constructs within programs that refer to, store, or manipulate values. Examples include: literals, variables, functions, declarations, expressions, statements, coroutines, threads, processes, modules, and packages.
  22. What is meant by the statics of a language?
    The statics of a language defines how programs are constructed.
  23. What is meant by the dynamics of a language?
    The dynamics of a language describe the computational orders and effects.
  24. Name at least five “top-level” ontological areas in the study of programming languages.
    Possible answers include: Naming, Evaluation, Control Flow, Typing, Functional Abstraction, Modularity, Concurrency, and Metaprogramming. There may be others.
  25. What are some areas of philosophy and mathematics that are important in the study of programming languages?
    Logic, Type Theory, Lambda Calculus, Theories of Computation, Syntax, and Semantics.
  26. Syntax deals with ________________ and semantics deals with ________________.
    structure; meaning.
  27. Is it for syntax or for semantics that formal methods are much easier and universally applied?
    Syntax.
  28. What are some concerns of “pragmatics” in programming languages? Name at least five.
    Here are some to choose from; there may be others:
    • Suitability for a given application domain
    • Comparison to other languages
    • Expressiveness
    • Performance capabilities
    • Idioms
    • Environments
    • Implied execution model
    • Standard library
    • Ecosystem
  29. Name at least five technical criteria on which to evaluate programming languages.
    Here are some to choose from; there may be others:
    • Ease of reading
    • Ease of writing
    • Expressiveness
    • Linguistic prevention of mistakes
    • Possibility of quick and incremental computation
    • Possibility of efficient target code generation
    • Portability
  30. Name at least three non-technical criteria on which to evaluate programming languages.
    Here are some to choose from; there may be others:
    • Being the only language suitable for a specific problem
    • Personal preference
    • Good development environments
    • Fast compilers
    • A massive ecosystem
    • Patronage
    • “Everyone else is using it”
    • “The boss made me use it”
    • Economics and Inertia
    • Laziness
  31. What must accompany any claim of language popularity?
    The measure used to determine popularity.
  32. What is the tradeoff surrounding automatic garbage collection?
    It saves billions of dollars in programmer time, but isn’t always a good idea in embedded, life-critical, real-time systems (because it kicks in at unpredictable times).

Summary

We’ve covered:

  • A taste of over a dozen languages
  • The professional benefits to the study of programming languages
  • The social benefits to the study of programming languages
  • Things to know: languages, concepts, formalisms, history, pragmatics
  • A brief history of programming languages
  • Some significant languages and their reasons for being
  • Overview of concepts: big picture, big questions, ontologies
  • Various topics in the field of language foundations
  • Pragmatics: vision, evaluation, expressiveness, popularity