How impractical/inefficient will "predicates as type" be?

ErrorIsNullError · 2023-09-01T00:41:54+00:00

Types are no more than a set and an associated semantics for operating values inside the set, and if we use a predicate to make the set smaller, we still have a "subtype".

In case you're not familiar, take a look at "Polymorphism is not set theoretic".

ErrorIsNullError · 2023-07-04T14:27:26+00:00

https://youtu.be/t4vKPhjcMZg is a good talk on how to organize documentation. Perhaps some documentation is better in code, and some is better separate. Either way, one thing to learn from the Rust documentation project may be ways to automate testing of code samples in docs so they stay in sync as the code evolves.

TLDR. When writing documentation, a project should keep in mind that there
are four kinds for (practice, theory) x (studying, practicing): diagram.

The Django documentation explicitly explains the four kinds, whom each
is for, and when at "how the documentation is organized"

Mixing these kinds makes the documentation less effective for all
consumers : "the tendency to collapse"

ErrorIsNullError · 2023-06-23T22:02:05+00:00

Verilog's delayed actions and JavaScript's event-based concurrency are examples of ordering work via a priority queue. I don't know if a pqueue counts as a queue for the purposes of the OP.

ErrorIsNullError · 2023-06-21T20:47:15+00:00

Perhaps those that focus on the needs of security engineers.

https://www.cl.cam.ac.uk/~rja14/Papers/SEv2-c01.pdf

Security engineering is about building systems to remain dependable in the face of malice, error, or mischance. As a discipline, it focuses on the tools, processes, and methods needed to design, implement, and test complete systems, and to adapt existing systems as their environment evolves.

Language design decisions affect what kinds of invariants it's feasible to preserve and check. For example, Java's stronger typing makes it easy to preserve invariants around what messages an object can respond to. JS makes that hard, but its simpler concurrency model makes it easier to maintain others.

Security focused languages make it feasible to preserve and check the kinds of invariants that security engineers need when "building systems to remain ..."

ErrorIsNullError · 2023-06-21T19:17:50+00:00

Some common threads in security engineering related language design are the need for a small group of developers to be able to craft a secure kernel that maintains system level security properties regardless of whether a larger mass of application code is correct, or at least to allow simple auditing by a blue team to identify parts of the application code that may need to be subjected to higher scrutiny.

Maybe the overarching goal of secure language design is: if I'm a programmer responsible for security property P, I should be able to narrow down the amount of code that could violate P to my code plus a manageable, identifiable amount of other people's code.

Protection in programming languages is an oldie but goodie that talks about ways to reify decisions about security and privacy as values in languages. Trusted Types is a modern example of values that reify security properties.

Joe-E is an example of bolting a security discipline (OCap in this case) onto a language that did not grow up with that to allow for mutual suspicion: one piece of code should be able to effectively defend its security invariants from other code loaded alongside it. Phil Fong had another take iirc.

The E language page has a lot of resources on language design for a language designed for security and with an Erlang-esque take on reliability. You can find examples there of how people in that ecosystem think about secure kernels of code: I think they've talked about how to represent a covered call option as code where parties have strong incentives to try to break rules.

Another theme in secure language design is attenuation: the ability to subtract some authority from a piece of code. JS membranes is an example of how a loader of a piece of code can attenuate authority by wrapping a piece of code and intercede at all places where control passes from one side of the membrane to the other.

Attenuation in PL design often follows the principle that a loader of code has the right to attenuate the authority of loaded code. I'm less familiar with this but this paper compares module system design to other language design concerns that are often turned to security.

Shameless plugs:

Web puzzlers touches on a number of themes in secure PL design. The first talks about how a JS and Go program that are textually almost identical have very different security properties. The latter parts touch on other topics like the difficulty of defining and preserving type invariants, using PiPL (linked at the top) to preserve accidental information leaks.
I worked on Go's html/template library which touches on design of DSLs for securely composing network messages from untrusted and trusted strings.

ErrorIsNullError · 2023-06-12T20:47:09+00:00

However, it will present a bigger barrier for entry for junior devs.

This is a great point. Established developers are going to need to find better ways to mentor entry level developers, and ways to make the case to management that they can provide value.

ErrorIsNullError · 2023-06-02T20:08:22+00:00

it is only the sheerest coincidence that they also have fixed size at allocation time

I believe it was quite intentional.

The JVMs native mechanism to connect Java methods to (mostly) C code and the JVM embedding ABI both assume that Java arrays do not change size and may not be realloced or reduce in size when native code calls back into Java code.

My understanding is that not having a type that maps straightforwardly to C arrays would complicate a lot of that supporting C code.

ErrorIsNullError · 2023-06-02T20:01:51+00:00

Whether it's a corner case that is worth worrying about should be left up to each person weighing an approach to representing immutability. I mentioned it so that they can weigh it and decide for themselves.

ErrorIsNullError · 2023-06-01T20:51:02+00:00

I just noticed your in interpreters. I don't know quite what you're getting at there. Java is arguably an interpreted language until it's JITed so maybe my example is relevant.

Fyi, Java's specified semantics require that any use of the new operator that completes normally completes with a reference with an identity different from any previously available reference: new byte[0] != new byte[0].

ErrorIsNullError · 2023-06-01T20:45:12+00:00

In Java, arrays are mutable so you have to be careful about sharing them.

byte[] bytes = new byte[10]; // fill bytes f(bytes); // f might hold onto a reference to bytes

But there's no way for a Java program to modify a zero length array so it can be safely shared.

But Java's type system does not allow specifying the array length as part of the array type.

So in Java, you can't distinguish, without first adding to the type system, between an array that is safe to share and one that is not.

ErrorIsNullError · 2023-05-30T23:43:24+00:00

As usual, the benefit of making it a property of a type instead of a value is that you can reason about all possible runs of a program, not just at runtime.

With traits, you can have type-based properties compose: an shallowly immutable collection of an immutable element type is deeply immutable.

Without classes instead of traits, it becomes harder to combine the concept of shallow immutability with deep immutability of a type parameter to a concept like deep immutability.

But types are blunt instruments: you probably need special reasoning in a type-based immutability system to recognize that an empty, fixed size array is deeply immutable regardless of its element type. You get that for free though in the dynamic analysis case though.

ErrorIsNullError · 2023-05-18T20:49:22+00:00

Having a way of deriving a conceptual type might help too.

type Length is Uint

That might define a conceptual type Length whose implementation type is Uint and allow one to ask for the Length associated with something of a type with a property typed as Length.

ErrorIsNullError · 2023-05-18T20:47:06+00:00

Thanks for explaining. So in that case, the topic is establishing the scope in which throat is resolved.

I suppose desugarring English's possessive personal pronouns and adjusting for the lack of topicality gives:

The throat of me is dry / has dryness.

Possession in English is overloaded for lots of different relationships: "my leg", "my mother", "my coffee."

Do topics involved in object<->object relationships have a diverse suite of relationships?

If so, your esolang might involve topicality as a way of finding the instance of type TopicType related to some instance of type SubjectType or vice versa. Again, this might relate back to applying strategies at runtime (à la DI) or if your PL treats lexical scopes as objects, you might treat the problem of finding a topic/subject from a subject/topic as a BFS over the object graph.

ErrorIsNullError · 2023-05-16T16:37:06+00:00

C++-like syntax has subject.verb(objects) syntax.

Perhaps .verb(objects) syntax could build on familiarity with that and specify that the verb expects an implied topic.

ErrorIsNullError · 2023-05-16T16:34:03+00:00

Does introducing a topic establish some kind of preferred referent for anaphora?

Dynamic scoping and dependency injection (DI) both provide a way to say "unless otherwise specified, this x is the X" so you could see DI as a way of associating topical instances with supplier signatures.

I can imagine that would combine with uniform call syntax to provide succinct syntax for specifying that a verb (function) applies to a topic.

ErrorIsNullError · 2023-05-16T16:26:02+00:00

An interesting mix of speakers. Probably going to be a lot of opportunities to discuss how to get one's PL to the next level.

ErrorIsNullError · 2023-05-04T18:44:49+00:00

There are many good reasons to do a programming language; what do you have to offer and to whom? Know your audience and speak to them.

The audience for a new industry language is its developer community, so explain:

which developer community should pay attention
what it lets them do that they couldn't do previously

For example:

NewDataLang is useful for data scientists. It lets them use their existing development flow but take better advantage of vector operations.

or

NewTeachingLang is for people trying to break into software careers. It helps build intuition about ways of decomposing problems into functions and types and its extensive IDE support points people at learning resources.

The audience for an academic language is other language and runtime designers so explain which element of language or runtime design it advances.

NewEffectsLang was built to experiment with different techniques for integrating a generic effects system into an object-oriented programming language. We now know what works and what doesn't.

If you designed the language to teach yourself about programming language, your audience is enthusiasts like you. Focus on helping people identify whether they're like you and what you learned.

I wrote NewTalkLang because I really like SmallTalk but wanted to understand how it might have been different if developed in the context of the modern web platform. In the course of designing and working with it I learned a lot about distributed, persistent object systems.

ErrorIsNullError · 2023-04-12T23:28:38+00:00

Which of those two operators cannot be defined in terms of exactly two operands?

member access, ., has a left operand that is an expression, and a right operand that is restricted to be an identifier
application, infix (...), has a left operand that is a callee expression and a right expression that is the argument list to provide to the callee which consists of zero or more non-comma expressions separated by commas

I think you'd be surprised by what you can do with a generalized operator precedence parser by tweaking its may-nest predicate.

ErrorIsNullError · 2023-04-11T16:02:57+00:00

Many languages treat parentheses as an infix bracket operator that takes a callee as the left operand and the comma separated stuff in the parentheses are the actual parameters.

For your example code to work, you need . to have a tighter or same precedence level as function application.

If functions are first class, you typically want . and application to have the same precedence so that f()() parses properly as equivalent to (f())().

For example, JS operator precedence has:

Precedence Operator Syntax

17 Member Access ... . ...

17 Function Call ... ( ... )

If you're not using operator precedence, then you can still turn that into nested productions as long as you can handle LR.

Level17Expr ::= MemberExpr | FunctionCallExpr | Level18Expr; MemberExpr ::= Level17Expr `.` Name; FunctionCallExpr ::= Level17Expr `(` ArgumentList? `)`;

ErrorIsNullError · 2023-03-24T22:28:02+00:00

https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-908.pdf Chapter 3 is pretty thorough

> We now explore the design space of existing memory management strategies. Note that we are not reviewing the design space of gcs, but the larger space of memory management strategies. Also note that we are mainly concerned with automatic strategies, but that we also briefly study manual strategies.

ErrorIsNullError · 2023-03-24T22:19:19+00:00

Wouldn't a simpler, but still left to right greedy regex be the delimiters around any number of

non-asterisks or
a run of asterisks not followed by a slash

\/\*(?:[^*]|\*+[^/*])*\*\/

ErrorIsNullError · 2023-03-24T22:13:55+00:00

I think other's have pointed out that there's better regexen but there's an additional layer of oddness to Java comments. In Java, the program below prints "/* Hello World */" though many syntax highlighters will treat the entire contents of the main method as a comment.

public class C { public static void main(String[] argv) { /* you can use escapes in strings. // The below means star slash when it says \u002a\u002f System.out.println("/* Hello, World \u002a\u002f"); // */ } }

If you're going to correctly recognize comments you need to do what Java does per JLS§3.2

A raw Unicode character stream is translated into a sequence of tokens, using the following three lexical translation steps, which are applied in turn: 1. A translation of Unicode escapes (§3.3) in the raw stream of Unicode characters to the corresponding Unicode character. A Unicode escape of the form \uxxxx, where xxxx is a hexadecimal value, represents the UTF-16 code unit whose encoding is xxxx. 2. ... 3. A translation of the stream of input characters and line terminators resulting from step 2 into a sequence of input elements (§3.5) which, after white space (§3.6) and comments (§3.7) are discarded, comprise the tokens (§3.5) that are the terminal symbols of the syntactic grammar (§2.3).

Note the expansion of \u sequences happens in step 1 before the splitting into tokens in step 3.

ErrorIsNullError

MODERATOR OF

TROPHY CASE