User Alexis King

176 votes

How should I read type system notation?

answered Aug 13, 2023 at 2:18

104 votes

Accepted

Why do common Rust packages depend on C code?

answered Nov 26, 2023 at 7:35

64 votes

What language design features made Lisp useful for Artificial Intelligence research?

answered Jul 19, 2023 at 2:56

61 votes

Accepted

What are the ways compilers recognize complex patterns?

answered Jul 16 at 23:05

57 votes

Accepted

What programming languages implement memory safety?

answered Oct 10 at 16:05

56 votes

Accepted

Why are volatile objects so difficult to work with in C++?

answered Dec 1, 2023 at 0:39

45 votes

Avoiding student confusion about the meaning of `x == a or b`

answered Jul 18, 2023 at 21:06

34 votes

Accepted

Why does Rust choose not to provide `for` comprehensions?

answered Sep 1, 2023 at 0:48

33 votes

Why is it so hard to evaluate functions with constant arguments at compile-time?

answered Jul 2, 2023 at 23:43

31 votes

What are the pros and cons of single-pass compilers?

answered Jul 2, 2023 at 20:49

29 votes

Accepted

Does using Rust eliminate the need to implement garbage collection in a language?

answered Sep 27, 2023 at 18:13

27 votes

Accepted

Why does Haskell use the bind operation instead of Kleisli composition?

answered Aug 8, 2023 at 1:22

25 votes

How to prevent undecidable type systems?

answered Jul 5, 2023 at 21:37

25 votes

What obstacles prevented C and C++ from standardizing π?

answered Jul 6, 2023 at 1:13

22 votes

Accepted

What is a Global Interpreter Lock, and why would an interpreter have it?

answered Jul 2, 2023 at 18:10

22 votes

How to ensure that an optimising compiler will terminate?

answered Aug 25, 2023 at 19:41

21 votes

How does one transpile valid code that corresponds to undefined behavior in the target language?

answered Jun 28, 2023 at 23:41

20 votes

How do precise garbage collectors find roots in the stack?

answered Jun 28, 2023 at 4:03

20 votes

When do we need complex type inference?

answered Jul 18, 2023 at 17:21

19 votes

What are the other potential downsides, if any, of making `<$>` and `<*>` (but not `pure`) implicit?

answered Aug 3, 2023 at 23:18

19 votes

Accepted

What are denotational semantics, and what are they useful for?

answered Jul 4, 2023 at 23:34

18 votes

Pros and cons of "anything-can-happen" UB versus allowing particular deviations from sequential program execution

answered Jul 17, 2023 at 17:11

17 votes

Accepted

To what extent is type theory relevant to dynamically typed languages?

answered Aug 14, 2023 at 21:18

16 votes

What is an arrow and what powers would it give as a first class concept in a programming language

answered Jul 13, 2023 at 18:49

15 votes

Why do most languages use the same token for `EndIf`, `EndWhile`, `EndFunction` and `EndStructure`?

answered Jul 3, 2023 at 0:18

15 votes

Accepted

What are the pros and cons of a compiler with a single-pass parser?

answered Jul 2, 2023 at 23:11

14 votes

Accepted

How, if at all, do kinds fit into the type universe hierarchy?

answered Jul 13, 2023 at 12:41

13 votes

Accepted

Tail-recursive detection and conversion

answered Jul 5, 2023 at 7:32

13 votes

How to ensure correct transformations with `break`, `continue` and other context-dependent statements?

answered Aug 5, 2023 at 15:08

13 votes

Accepted

How could a language with a C-style syntax implement homoiconicity?

answered Jun 28, 2023 at 16:44

Stack Exchange Network

51 Answers

How should I read type system notation?

Why do common Rust packages depend on C code?

What language design features made Lisp useful for Artificial Intelligence research?

What are the ways compilers recognize complex patterns?

What programming languages implement memory safety?

Why are volatile objects so difficult to work with in C++?

Avoiding student confusion about the meaning of `x == a or b`

Why does Rust choose not to provide `for` comprehensions?

Why is it so hard to evaluate functions with constant arguments at compile-time?

What are the pros and cons of single-pass compilers?

Does using Rust eliminate the need to implement garbage collection in a language?

Why does Haskell use the bind operation instead of Kleisli composition?

How to prevent undecidable type systems?

What obstacles prevented C and C++ from standardizing π?

What is a Global Interpreter Lock, and why would an interpreter have it?

How to ensure that an optimising compiler will terminate?

How does one transpile valid code that corresponds to undefined behavior in the target language?

How do precise garbage collectors find roots in the stack?

When do we need complex type inference?

What are the other potential downsides, if any, of making `<$>` and `<*>` (but not `pure`) implicit?

What are denotational semantics, and what are they useful for?

Pros and cons of "anything-can-happen" UB versus allowing particular deviations from sequential program execution

To what extent is type theory relevant to dynamically typed languages?

What is an arrow and what powers would it give as a first class concept in a programming language

Why do most languages use the same token for `EndIf`, `EndWhile`, `EndFunction` and `EndStructure`?

What are the pros and cons of a compiler with a single-pass parser?

How, if at all, do kinds fit into the type universe hierarchy?

Tail-recursive detection and conversion

How to ensure correct transformations with `break`, `continue` and other context-dependent statements?

How could a language with a C-style syntax implement homoiconicity?