5 ms·

I like this explanation. Every year, or so, I'll design a programming language on paper to work through my "latest thoughts" as impacted by languages and ideas

• pjc50 3y ago
  > people, like me, who require a theory to feel comfortable Reminds me of the paper "Programming as Theory Building" https://pages.cs.wisc.edu/~remzi/Naur.pdf https://pages.cs.wisc.edu/~remzi/Naur.pdf
  • mjburgess 3y ago
    Naur is probably the closet computer scientist to my world view -- on many fronts. I'm reminded of his genuine attempt to go into neurobiology, and via William James, take seriously biological adaption and plasticity. I think over the last 20 years, engineers and mathematicians seem to have "taken over" computer science -- against the tradition of "scientific philosophy" which Naur represents.
• proamdev123 3y ago
  Your description of your work process sounds like descriptions I’ve read of language driven development. Could you expand on why this is so powerful for you? Not doubting it’s power, but I’m having a hard time understanding _why_ it’s so powerful for some people.
  • mjburgess 3y ago
    This morning I was sketching how i'd do syntax for affine and linear types, which are (very basically) where variables can be used "at most once" or "only once". In sketching I iterated various designs, my notepad is below. It began trying to think about how to express scopes visually, or using tags/lables -- then moved into how that integrates with other langauge features etc. By doing this I understand much more about what really a language feature is trying to do -- I understand the tradeoffs, etc. program a: let x:a = 10 if 10 < 5 b: let x:b = x print(x) program UseyTypes: x : once = new Resource() # at most once -- rust's default y : never = ... z : once! = ... # only once q : many = ... program MoveSemantics: a = new 10 x = 10 y = move x z = copy y i0 = new(auto) 10 i1 = new(memo.alloc.heap) 10 # default g1 = new(heap) Graph.init({...}) g2 = copy(Graph) g1 # uses Graph's (deep)copy method g2 = copy(Graph.copy) g1 # eqv to above program : global heap = Allocator.tmp(...) if True: local xs = Vec.new(heap) { 1, 2, 3, 4 } memo.lifetimeOf(x) # eg., local scope a = lineno 10 - 20 memo.lifetimeOf(x.data) # eg., global via heap allocator repeat x <= xs: x = 10 # error print(x) repeat i <= int.range(10): x[i] += 1 repeat: const answer = input("What's 2 + 2?").to(int) print(compiler.scope) print(compiler.lineno) const int z = 10 const ref(int) y = ref(z) print(y, deref(y)) const x : global = 10 if 10 < 5: int x : local = 10 int y : parent = 10 # polymorphic .to fn str.to(int): parseInt(.) program EffectSystem: fn[IO] println(const ...data: ...any): repeat d <- data: IO.writeline(d.to(str)) pure fn calc(): # pure = no effects return 10 + 20 # by default, all fns are impure, ie., have IO auto-passed ? println("Hello", "World") with IO = open("output.txt", "w"): println("Into some file!") println[open("output.txt")]("hello world")
    • proamdev123 3y ago
      Thanks! Out of curiosity, have you ever tried developing DSLs in Racket? One of its explicit reasons for existence is to enable fast development of custom DSLs.
      • 3y ago
• specialist 3y ago
  > Every year, or so, I'll design a programming language on paper ... Where do I subscribe? > Each time the design is different, with different priorities etc. Classic trilemmas. Nice. Scott McCloud's triangle for style of illustrations was a eureka moment for me. The tips are ideographic, textual, and realism (IIRC). All comics lie somewhere within that triangle (solution space). Mind blown. There are many either-or tradeoffs: closer to the metal vs abstractions, explicit memory management vs garbage collectors, etc. But there's probably also a few trilemmas, like functional vs imperative vs declarative. Anywho. Just a casual notion. I'd love to see a big list of design decisions for programming languages. Today's embarrassment of riches has reduced the enthusiasm for language jihads. But it'd still be nice to have something more than esthetics and vibes to guide our choices.