#+TITLE: Programming Languages

* Languages
- [[https://www.jsoftware.com/#/][J]] :: A high-performance language for data processing and parallel computing.
  [[https://github.com/pitr/jj][J implementation in Nim]]
- [[https://github.com/zetzit/zz][Z]] :: A dialect for C that's immutable by default, resolves undefined behavior and uses an SMT solver to guarantee reference stability 
- [[https://chapel-lang.org][Chapel]] :: A parallel programming language that claims to have some novel ideas.
- [[https://github.com/CatalaLang/catala][Catala]] :: A DSL for representing laws by construction, designed to enable lawyers to certify laws. Interested in formal verification of legal documents, potentially.
- [[https://raku.org][Raku]] :: A descendent of Perl, it features lots of additional features including fun grammar specifications.
- [[https://github.com/jfecher/ante][Ante]] :: 'The compile-time language'. Made by a Northeastern undergraduate.
- [[https://github.com/adam-mcdaniel/oakc][Oak]] :: Designed as a simple replacement for C.
- [[https://github.com/topshell-language/topshell][Topshell]] :: A functional, reactive scripting language.
- [[https://github.com/MosheWagner/PyChefInterpreter][Chef]] :: An esoteric programming language designed to simultaneously represent recipes and programs.
- [[https://github.com/bakpakin/Fennel][Fennel]] :: Lisp for Lua.
- Whitespace :: A programming language designed with only whitespace characters, ignoring all others. Any program that disregards whitespace can express a whitespace program within it. Fun to represent in laugnages that aren't indent-aware - these programs can also encode Whitespace within them!
- [[https://github.com/LuxLang/lux][Lux]] :: A statically typed Lisp-like language for the JVM.
- [[https://github.com/einaregilsson/While-Language][While]] :: A language used in textbooks such as 'Principles of Program Analysis'.
- [[https://github.com/kwanghoon/polyrpc][PolyRPC]] :: A 'multi-tier' functional programming language.
- [[https://github.com/musikinformatik/Steno][Steno]] :: livecoding metalanguage
- [[https://en.m.wikipedia.org/wiki/Unlambda][Unlambda]] :: A minimal functional programming language based on combinatory logic meant to be a demonstration of pure functional programming
- Vodka :: A creative coding environment and language for structured editing for writers. 
- [[play-lang.dev][Play]] :: A statically typed Forth!

** DSLs
- [[https://gitlab.inria.fr/verifisc/mlang][MLang]] :: A DSL created to represent and calculate the French tax code.
- [[http://bloom-lang.net/bud/][Bloom]]
- [[https://dhall-lang.org/][Dhall]] :: langauge for system configuration
- https://microformats.io/ html dsl in classes to add meaning
- [[https://www.puzzlescript.net/][puzzlescript]] :: language for puzzles!
- [[http://frinklang.org/][Frink]] :: [[https://hillelwayne.com/post/frink?utm_source=hillelwayne&utm_medium=email][The Frink is Good, the Unit is Evil]]
[[https://github.com/Ahnfelt/funk][Ahnfelt/funk: PROTOTYPE: A minimal scripting language - OOP via lambda func]]
[[https://parentheticallyspeaking.org/articles/pls-nature/][Programming Languages as Objects in Nature]]
https://www.colm.net/open-source/ragel/ state machine compiler
https://www.openpolicyagent.org/docs/latest/policy-language/ policy lang
http://inform7.com/ dsl for text based adventures
http://ebblang.org/ dsl for physical simulations
http://terralang.org/ systems prog lang embedded in Lua
http://optlang.org/ embedded lang for nonlinear least squares optimization
https://hackage.haskell.org/package/accelerate embedded lang for array processing
- also see https://jrslepak.github.io/publications/
  https://tracery.io/ :: simple graphics programming language
- [[https://www.unisonweb.org/][Unison]] :: A distributed programming language and editing environment for the modern web.
  A major inspiration for the projectional [[file:text-editors.org][Text Editors]] project.
https://faust.grame.fr/
https://en.m.wikipedia.org/wiki/Datalog
http://pepijndevos.nl/2018/10/03/behavior-trees-are-concatenative-programs.html
behavior trees
http://coconut-lang.org/
https://www.dangermouse.net/esoteric/piet.html
https://effekt-lang.org/ effekt polymorphism

* Work
https://hmc-cs111-fall2016.github.io/ class on DSLs
https://github.com/google/evcxr
https://github.com/hengestone/lua-languages programming languages targeting lua
https://github.com/jeanqasaur/dsl-syllabus-fall-2016 class on dsls

* Research
https://github.com/jdublu10/icfp2020-papers ICFP 2020 conf
https://github.com/melling/ComputerLanguages someone's notes on computer languages

* Lean
This'll be factored out when I learn more about Lean.
https://github.com/uwdb/Cosette automated sql solver
https://github.com/ImperialCollegeLondon/group-theory-game group theory in lean

* blurring the curry howard line
https://www.youtube.com/watch?v=jrVPB-Ad5Gc&t=1870s&app=desktop
works on autonomous vehicles, fun stuff

typically using languages iwth proof assistants. however, actuation systems
in carshave real time constraints, so lazy evaluation or nondeterministic
memory management is not valid. this is typically done in c or cpp.
pulling a c program from a coq proof ?

programs :: foramlized syntactically, but modeled semantically.
denotational semantics
map number to some set :: ie some u8 integer fits within one set. map
syntactic objects to universal mathematics with such denotational semantics

typing rules:
tau - a : A, f:A -> B
---------------
tau |- a

cannot capture everything with type theory?
dependent types end up capturing everything. can provide complete
specification of a program's behavior in the dependent type theory.

curry-howard correspondance :: a correspondence between program and proof!
we know we can reason about our programs from a dependent type theory, but
what is this gap called?
specifying program in the types: can make assertions about the correctness of
this code.

/why dependent types matter/ paper.
rust provides subset for representing dependent typed behavior in our
programs.
type level definition of the natural numbers, for example!

these programs can be fully represented in state machines! the entire system
and communication protocols can be captured with such a state machine, and
this state machine can be represented in a rust type system

state :: sum type. type family adjacency; types that are members of the type
family are adjacent to each of these states.

can use demotational semantics to convert rust semantics to agda :: and as
agda has full dependent types. using agda allows us to mechanize semantic
function !
agda has a notion of proofs and may soon have a notion of tactics. proving
things foundationally in agda could be doable once we have the specification
of the program in its own domain

state machines :: behold the program counter as everything is tracked at
compile time. not easy in this representation to track a state machine in
terms of program handlers.

church numerals :: general way of using a function to produce numbers
program that extracts information from a rust program and stick the semantics
in agda

* blurring the curry howard line
https://www.youtube.com/watch?v=jrVPB-Ad5Gc&t=1870s&app=desktop
works on autonomous vehicles, fun stuff

typically using languages iwth proof assistants. however, actuation systems
in carshave real time constraints, so lazy evaluation or nondeterministic
memory management is not valid. this is typically done in c or cpp.
pulling a c program from a coq proof ?

programs :: foramlized syntactically, but modeled semantically.
denotational semantics
map number to some set :: ie some u8 integer fits within one set. map
syntactic objects to universal mathematics with such denotational semantics

typing rules:
tau - a : A, f:A -> B
---------------
tau |- a

cannot capture everything with type theory?
dependent types end up capturing everything. can provide complete
specification of a program's behavior in the dependent type theory.

curry-howard correspondance :: a correspondence between program and proof!
we know we can reason about our programs from a dependent type theory, but
what is this gap called?
specifying program in the types: can make assertions about the correctness of
this code.

/why dependent types matter/ paper.
rust provides subset for representing dependent typed behavior in our
programs.
type level definition of the natural numbers, for example!

these programs can be fully represented in state machines! the entire system
and communication protocols can be captured with such a state machine, and
this state machine can be represented in a rust type system

state :: sum type. type family adjacency; types that are members of the type
family are adjacent to each of these states.

can use demotational semantics to convert rust semantics to agda :: and as
agda has full dependent types. using agda allows us to mechanize semantic
function !
agda has a notion of proofs and may soon have a notion of tactics. proving
things foundationally in agda could be doable once we have the specification
of the program in its own domain

state machines :: behold the program counter as everything is tracked at
compile time. not easy in this representation to track a state machine in
terms of program handlers.

church numerals :: general way of using a function to produce numbers
program that extracts information from a rust program and stick the semantics
in agda

* future reading
** toy lang
[[https://h.christine.website/][powerful programming language]]
[[http://willcrichton.net/notes/][type level programming]]
[[https://2020.ecoop.org/home/iwaco-2020][aliasing and ownership]]
[[https://www.youtube.com/watch?v=6avJHaC3C2U&app=desktop][the art of code]]
[[https://pldi20.sigplan.org/details/pldi-2020-papers/65/Question-Selection-for-Interactive-Program-Synthesis][prog synth at pldi]]
** ???
https://www.reddit.com/r/gorillaz/comments/g980ui/rock_the_house_animation_by_%E3%83%96%E3%83%AB%E3%83%BC%E3%83%8F%E3%83%A0%E3%83%8F%E3%83%A0/
-- how do i do animations like this?

https://www.linkedin.com/mwlite/in/christopher-choquette-choo who is this dude?
https://copetti.org/projects/ -- does writing on console architecture
https://pydanny.blogspot.com/2011/08/github-is-my-resume.html?m=1 -- making a
resume for github
http://mjb.io/ -- wild!

* Programming Languages
useful resources: https://github.com/wilbowma/pl-thesaurus -- too advanced for me
** Adjunction
Whnen categories are Posets, adjunction is a Galois connection

** Strong Monad
** Monad

Kleisli trible, s4 possibility mdality
when category is defined as poset, monad is a closure operator

** Reflection

when categories are posets, this is a galois surjection

** Right Adjoint

In order theory, right adjoint of Galois connection is upper adjoint
in abstract interpretation, this is Concretization function

** Left Adjoint

in order theory: left adjoint of galois connection is lower adjoint
in abstract interpretation, this is abstract function

** Galois Connection
* term rewriting
https://www21.in.tum.de/~nipkow/TRaAT/ -- book benjamin had, it's a description
of term rewriting problems, universal algebra, unification theory
https://en.wikipedia.org/wiki/Rewriting

* pl random link spit
https://www.reddit.com/r/ProgrammingLanguages/comments/fzu00x/naming_functional_and_destructive_operations/
https://www.reddit.com/r/haskell/comments/60r9hu/proposal_suggest_explicit_type_application_for/
https://www.amazon.com/gp/product/1555580416?ie=UTF8&tag=ucmbread-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1555580416
https://felleisen.org/matthias/4400-s20/lecture27.html
https://www.cambridge.org/core/journals/journal-of-functional-programming/article/effect-handlers-via-generalised-continuations/DF590482FEE2F6888CD68B4B446E31D5
https://www.reddit.com/r/ProgrammingLanguages/comments/f75y79/what_is_modal_logic_and_what_is_it_good_for_flash/
https://projectfluent.org/
https://arxiv.org/abs/1605.06640
https://brianmckenna.org/blog/
https://arxiv.org/abs/1905.09381
https://www.reddit.com/r/ProgrammingLanguages/comments/fp7sko/10_mostly_dead_influential_programming_languages/
https://www.reddit.com/r/ProgrammingLanguages/comments/fvx72d/i_analyzed_wikipedia_documents_of_programming/
https://www.reddit.com/r/ProgrammingLanguages/comments/fc274s/whats_your_favorite_programming_language_why/
http://journal.stuffwithstuff.com/2020/04/05/crafting-crafting-interpreters/
http://dot.planet.ee/yeti/intro.html#structures
https://www.quantamagazine.org/formal-verification-creates-hacker-proof-code-20160920/
https://www.reddit.com/r/ProgrammingLanguages/comments/8ud5am/what_are_the_poison_pills_to_avoid_when_designing/
https://www.reddit.com/r/ProgrammingLanguages/comments/8vcrzb/what_are_some_interesting_language_features_that/
https://www.reddit.com/r/ProgrammingLanguages/comments/cuwy29/plam_now_supports_lists_with_list_library_check/
https://www.reddit.com/r/ProgrammingLanguages/comments/cx4hea/so_i_developed_an_interpreted_language_in_c/
https://www.reddit.com/r/ProgrammingLanguages/comments/dpnmzl/the_next_7000_programming_languages/
https://www.cis.upenn.edu/~bcpierce/courses/670Fall04/GreatWorksInPL.shtml --
overview of great works in pl to know before diving in!
https://softwarefoundations.cis.upenn.edu/ -- software foundations
https://plfa.github.io/ -- foundations in agda! for free!
https://blog.janestreet.com/whats-in-a-name/ -- excellent essay on the
importance of naming
https://arxiv.org/abs/1809.10756 -- intro to probabilistic prgrammign !
https://www.defmacro.org/ramblings/lisp-in-haskell.html -- writing a quick lisp
interpreter in haskell
http://dev.stephendiehl.com/fun/ -- building modern functional compiler from
first principles
parsing
https://golem.ph.utexas.edu/category/2020/05/in_further_praise_of_dependent.html
https://stackoverflow.com/questions/232682/how-would-you-go-about-implementing-off-side-rule
--basically indenting and dedenting with lexer just like any other parens
https://en.wikipedia.org/wiki/Earley_parser -- context-free parsing of strings
algorithm
https://mitpress.mit.edu/books/little-prover -- introduction to writing proofs
about computer programs
https://en.wikipedia.org/wiki/Idris_(programming_language) -- haskell-inspired
purely functional programming language with dependent types
https://en.wikipedia.org/wiki/Brzozowski_derivative -- derivatives of language
constructs - whoah!
https://github.com/adjoint-io/bulletproofs -- proofs that require no trusted
setup
https://en.wikipedia.org/wiki/Titchmarsh_convolution_theorem
designing a simple racket dsl
https://course.ccs.neu.edu/cs2500accelf17/lab12.html
https://felleisen.org/matthias/4620-s18/index.html -- hack your own language /
building extensible systems : learn more about it! please!
https://craftinginterpreters.com/ -- the book on crafting interpreters
https://groups.google.com/forum/#!msg/racket-users/vN_1uUJZnXo/5bXiMEBvCgAJ --
arguments aboutsurface syntax of racket
https://blog.racket-lang.org/2020/02/racket-on-chez-status.htmlhttps://blog.racket-lang.org/2020/02/racket-on-chez-status.html
-- racket on chez scheme for performance optimizations!
https://blog.acolyer.org/2020/01/17/synthesizing-data-structure-transformations/
synthesizing programs from input and output!! wow!! program synthesis looks like
such a cool thing
https://www.reddit.com/r/ProgrammingLanguages/comments/ev0zzv/growing_a_language_by_guy_steele/
https://www.youtube.com/watch?v=agw-wlHGi0E&app=desktop
https://www.reddit.com/r/ProgrammingLanguages/comments/b2a61l/what_are_some_niche_features_youd_like_to_see_in/
https://thosakwe.com/blog/aot-compilation-and-other-dart-hackery/
https://www.reddit.com/r/ProgrammingLanguages/comments/dwt8xu/what_is_your_favourite_academic_paper_on/
http://craftinginterpreters.com/closures.html
https://jadon.io/blog/row-polymorphism

** fun languages

https://github.com/adam-mcdaniel/oakc fun alternative to c langauge
https://github.com/psg-mit/smooth
http://bloom-lang.net/
https://www.reddit.com/r/ProgrammingLanguages/comments/g2hhq0/statically_typed_language_with_a_flexible_macro/

https://www.reddit.com/r/ProgrammingLanguages/comments/ehqlay/announcing_the_frost_programming_language/
https://www.reddit.com/r/ProgrammingLanguages/comments/exl0h5/free_a_programming_language_with_an_unusual/
https://www.reddit.com/r/ProgrammingLanguages/comments/g0k14m/is_copyonmodify_semantics_for_variables_used_in/
https://quorumlanguage.com/evidence.html
https://www.reddit.com/r/ProgrammingLanguages/comments/g0n2bd/from_scala_monadic_effects_to_unison_algebraic/https://www.reddit.com/r/ProgrammingLanguages/comments/g0n2bd/from_scala_monadic_effects_to_unison_algebraic/
https://v8.dev/
http://logitext.mit.edu/main
http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/
https://www.sifive.com/
https://www.wolframphysics.org/
https://daniel.haxx.se/
http://matt.might.net/articles/
http://matt.might.net/articles/best-tools-for-using-and-learning-linux-and-unix/#wms
https://dlang.org/
https://web.obarun.org/
https://en.m.wikipedia.org/wiki/Malbolge
https://eta-lang.org/
https://www.scala-lang.org/
https://www.amazon.com/gp/product/1555580416?ie=UTF8&tag=ucmbread-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1555580416
https://www.reddit.com/r/ProgrammingLanguages/comments/f30wxi/github_marcpaqb1fipl_a_bestiary_of_singlefile/
https://www.reddit.com/r/ProgrammingLanguages/comments/elbt5u/introducing_the_beef_programming_language/
https://www.reddit.com/r/ProgrammingLanguages/comments/e8a42b/new_programming_language_concurnas/
https://www.reddit.com/r/ProgrammingLanguages/comments/ba9l0k/nomsu_a_dynamic_language_with_naturallanguagelike/
https://www.reddit.com/r/ProgrammingLanguages/comments/bcmhkn/ldpl_300_and_why_you_should_work_on_silly_things/
https://www.reddit.com/r/ProgrammingLanguages/comments/ez9k1g/zz_is_a_modern_formally_provable_dialect_of_c/
http://www.philipzucker.com/computational-category-theory-in-python-3-monoids-groups-and-preorders/
https://dl.acm.org/doi/10.1145/75277.75283
https://www.reddit.com/r/ProgrammingLanguages/comments/ftied4/idris_2_version_010_released/

https://www.reddit.com/r/ProgrammingLanguages/comments/avvma5/atto_an_insanely_tiny_selfhosted_functional/
https://www.reddit.com/r/haskell/comments/fz7heq/accidentally_exponential_in_a_compiler/
https://blog.josephmorag.com/posts/mcc2/
https://dl.acm.org/doi/abs/10.1145/301618.301637
https://github.com/mcoblenz/Obsidian
https://adamant-lang.org/
http://www.mlton.org/
http://matt.might.net/articles/best-programming-languages/
https://chrisseaton.com/truffleruby/
https://futhark-lang.org/blog/2020-04-13-statically-linking-the-futhark-compiler.html
https://www.reddit.com/r/ProgrammingLanguages/comments/awr3th/i_made_a_programming_language_based_on_cobol/
https://github.com/seanbaxter/circle
http://blog.hydromatic.net/2020/02/25/morel-a-functional-language-for-data.html
https://www.reddit.com/r/ProgrammingLanguages/comments/ecc1fo/design_flaws_in_futhark/
https://github.com/Storyyeller/IntercalScript
https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-programming-a-comedy-of-errors-3/

*** haxe!

https://www.reddit.com/r/programming/comments/do220a/haxe_4_has_been_released/
cross platform language toolkit!
https://www.reddit.com/r/ProgrammingLanguages/comments/eh1sfy/carpentry_compiler/
https://blog.darknedgy.net/technology/2020/05/02/0/

https://en.m.wikipedia.org/wiki/RenderMan_Interface_Specification
https://en.m.wikipedia.org/wiki/RenderMan_Interface_Specification
https://www.reddit.com/r/ProgrammingLanguages/comments/9esm8t/multiple_return_values_from_functions/
bytecode interpreter
comments
https://www.reddit.com/r/ProgrammingLanguages/comments/g2ae36/crafting_interpreters_vs_build_your_own_lisp_the/
https://www.reddit.com/r/algorithms/comments/fjock1/which_is_the_best_sat_solver/https://www.reddit.com/r/learnmath/comments/fo5itb/riemanns_functional_equation_new_solution_found/
https://www.reddit.com/r/learnmath/comments/fo5itb/riemanns_functional_equation_new_solution_found/
https://www.reddit.com/r/ProgrammingLanguages/comments/fxrmho/the_best_ways_to_compile_functional_programming/
https://www.reddit.com/r/ProgrammingLanguages/comments/g0j1um/simple_but_powerful_pratt_parsing/
https://www.reddit.com/r/ProgrammingLanguages/comments/g0j1um/simple_but_powerful_pratt_parsing/
https://www.reddit.com/r/ProgrammingLanguages/comments/fxrp6e/languages_with_structural_typing/
https://www.reddit.com/r/ProgrammingLanguages/comments/g0po6x/types_over_strings_extensible_architectures_in/
https://www.reddit.com/r/dartlang/comments/f4d07x/poll_should_the_angel_framework_be_merged_into_a/

** verification

https://www.cs.princeton.edu/~appel/certicoq/
https://vst.cs.princeton.edu/ building verified software

** parsing

https://www.reddit.com/r/ProgrammingLanguages/comments/dszj7b/parse_dont_validate/
https://nothings.org/computer/lexing.html -- lexing
https://softwareengineering.stackexchange.com/questions/338665/when-to-use-a-parser-combinator-when-to-use-a-parser-generator
https://www.reddit.com/r/perl6/comments/73tjdo/an_outline_of_federico_tomassettis_a_guide_to/
shunting yard algorithm : used to parse expressions in infix notation !
in parser generator: .mly file uses infix things with Shunting Yard Algorithm under the hood !!

** type systems

https://www.typescriptlang.org/docs/handbook/advanced-types.html#index-types-and-index-signatures
http://reasonableapproximation.net/2019/05/05/hindley-milner.html
http://prl.ccs.neu.edu/gtp
https://ncatlab.org/nlab/show/pure+type+system
https://blog.sigplan.org/2019/10/17/what-type-soundness-theorem-do-you-really-want-to-prove/
great writeup about pa paper

** redex

https://www.youtube.com/watch?v=BuCRToctmw0 -- run your research - talk on redex
https://redex.racket-lang.org/
a dsl for specifying and debugging operational semantics

** compilers

[[https://en.m.wikipedia.org/wiki/Duff%27s_device][compiler neat thing]]
[[https://www.youtube.com/watch?v=de8Ak0nY1hA&app=desktop][improving compiler correctness using formal methods]]
http://www.keystone-engine.org/
https://jamespackard.me/
https://ollef.github.io/blog/posts/speeding-up-sixty.html
https://whalesalad.com/blog/doing-python-configuration-right
https://en.m.wikipedia.org/wiki/Multi-pass_compiler
https://en.m.wikipedia.org/wiki/Data-flow_analysis
https://www.reddit.com/r/ProgrammingLanguages/comments/a60i0m/unlike_ordinary_jit_compilers_for_other_languages/

https://gist.github.com/cellularmitosis/1f55f9679f064bcff02905acb44ca510#simple-compiler-codebases-to-study
crazy compilers good stuff

https://zserge.com/posts/jvm/ how to write a toy jvm -- try this and put it
on github! fun small thing to mess around with. add more to it, add new
things, mess aroundand have fun!
https://www.cs.cmu.edu/~janh/courses/411/16/ compiler design course at cmu.
supposedly good material

https://stackoverflow.com/questions/6264249/how-does-the-compilation-linking-process-work#6264256
https://www.cprogramming.com/compilingandlinking.html

https://www.youtube.com/watch?v=Os7FE3J-U5Q&app=desktop writing a nanopass
compiler
https://en.m.wikipedia.org/wiki/Intermediate_representation good reading
https://en.m.wikipedia.org/wiki/Three-address_code
https://en.m.wikipedia.org/wiki/Static_single_assignment_form
https://catalog.princeton.edu/catalog/SCSB-8534958 -- benjamin's favorite
compilers book
http://www.ocamlpro.com/2020/03/23/ocaml-new-best-fit-garbage-collector/
http://www.aosabook.org/en/llvm.html -- on llvm
https://en.wikipedia.org/wiki/Alan_Perlis -- pl research, won turing award or something
type preserving compilation for large scale optimizing object oriented compilers
how efficient can objects be?
https://v8.dev/blog/pointer-compression -- pointer compression in v8
https://en.wikipedia.org/wiki/Optimizing_compiler
https://dl.acm.org/doi/10.1145/1375581.1375604
https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html
https://www.cs.cornell.edu/courses/cs4410/2014fa/
https://www.reddit.com/r/ProgrammingLanguages/comments/fqt0fo/the_strange_case_of_dr_function_and_mr_type/fm0vurc/?context=1
http://prl.ccs.neu.edu/blog/2020/01/15/the-typed-racket-optimizer-vs-transient/
https://docs.racket-lang.org/ts-guide/index.html
https://www.reddit.com/r/ProgrammingLanguages/comments/f3ekao/i_built_a_2d_gridbased_esoteric_language_with_a/
https://esolangs.org/wiki/2014 esolang only working in 2014
https://esolangs.org/wiki/Efghij esolang that interacts with the physical world via a jenga-based game, manually interpreted and executed by the programmer according to the specification
https://esolangs.org/wiki/Ziim 2d language reliant entirely on unicode arrows
https://matklad.github.io/2020/04/15/from-pratt-to-dijkstra.html
https://www.reddit.com/r/ProgrammingLanguages/comments/e1vv55/c3_a_clike_language_now_has_a_domain/
https://www.reddit.com/r/ProgrammingLanguages/comments/a0yyfc/plam_for_anyone_exploring_%CE%BBcalculus/

https://www.reddit.com/r/ProgrammingLanguages/comments/g1wd0v/but_what_if_we_put_modifiers_after_the_keyword/

https://blog.sigplan.org/2020/07/29/increasing-the-impact-of-pl-research/
a meta article on impactful pl research
http://craftinginterpreters.com/
https://github.com/glaretechnologies/winter

https://www.zinkov.com/posts/2019-02-17-why-program-synthesis/ program synthesis why?
https://loglo.app/ turn yaml into cnc
https://tixy.land/ fun language for creative code golfing

run your research paper is probably cool!
https://m.youtube.com/watch?v=jdn617M3-P4 hitchhiker trees: cool functional data structure
https://wiki.xxiivv.com/site/fractran.html

https://ziglearn.org/ learn zig

[[https://news.ycombinator.com/item?id=21967668][Hobby kernel written in Zig]]
https://malleable.systems/catalog/

[[https://www.sciencedirect.com/science/article/pii/016764239190036W][On the expressive power of programming languages - ScienceDirect]]
https://github.com/iitalics/Opal

[[https://github.com/marcpaq/b1fipl][single file implementations of various programming languages]]
https://www.ponylang.io/

[[https://github.com/Beluga-lang/Beluga][Contextual types meet mechanized metatheory!]]
https://github.com/lasp-lang/lasp
https://github.com/NicklasBoto/BruSKI debrujin to ski unlambda compiler
https://github.com/Storyyeller/IntercalScript intercalscript programming language
https://github.com/taichi-dev/taichi differentiable programming languages
https://github.com/jasonhemann/microKanren
https://github.com/mame/quine-relay
https://github.com/lasp-lang/partisan distributed computing with [[file:elixir.org][Elixir]]


[[https://github.com/halide/Halide][halide]]: language for fast and portable data parallel computation
[[https://github.com/factor/factor][factor programming language]]: concatenative programming thats stack based
https://github.com/Gwion/Gwion: strongly typed[[file:music.org][Music]]  programming language
https://github.com/unisonweb/unison a friendly web programming language

https://github.com/thesephist/schrift an experimental runtime for ink lang
[[https://github.com/alpaca-lang/alpaca][alpaca]]:: ml style functional programming for the erlang vm
[[https://github.com/kragen/stoneknifeforth][self hosted forth implementation]]

[[https://github.com/kragen/tokthr][bytecode interpreter in x86 asm]]
[[https://github.com/monsonite/Z80_Forth][multitasking Z81 forth]]
[[https://github.com/wilbowma/pl-thesaurus][pl thesaurus]]
- [[https://colorforth.github.io/hopl.html][forth in the early years]]
  - evolved throughout the 60s, only a single programmer!
  - "unique combination of ingredients"
  - context free text based language combining words that have a variety of (arguably) advanced features, and runnable on small embedded systems with sufficient


[[https://github.com/zesterer/atto][atto]]:: super simple self hosted programming language
[[https://github.com/skx/gobasic][BASIC interpreter in Go]]
[[https://github.com/witheve/Eve][Eve]], a 'human first' programming language
[[https://github.com/rems-project/sail][SAIL]]: architecture definition language (in[[file:coq.org][Coq]]) for describing ISAs of processors
[[https://github.com/tree-sitter/tree-sitter][incremental parsing system for programming tools]]

https://github.com/meilisearch/MeiliSearch typo tolerant search engine
https://github.com/Shen-Language/shen-sources shen programming language
https://news.ycombinator.com/item?id=23252448
[[http://alloytools.org/][alloy - os lang and analyzer for software modeling]]

[[http://willcrichton.net/notes/][type level programming]]
[[https://www.forth.com/forth/][What is the Forth programming language?]]
[[https://en.m.wikipedia.org/wiki/Total_functional_programming][Total functional programming - Wikipedia]]

[[https://github.com/adam-mcdaniel/oakc][adam-mcdaniel/oakc: A portable programming language with an incredibly comp]]
[[https://github.com/psg-mit/smooth][psg-mit/smooth: An arbitrary-precision differentiable programming language.]]
[[https://www.hillelwayne.com/post/influential-dead-languages/][on influential dead languages]]
https://www.reddit.com/r/cscareerquestions/comments/9ujawa/programming_language_theory_jobs/
[[https://github.com/masaeedu/ulc][masaeedu/ulc: Untyped lambda calculus]]
[[https://ruslanspivak.com/lsbasi-part1][Let’s Build A Simple Interpreter. Part 1.]]
[[https://m.youtube.com/watch?v=RVDCRlW1f1Y][William E Byrd - Relational Interpreters, Program Synthesis, and Barliman -]]
[[https://ruslanspivak.com/lsbasi-part1/][Let’s Build A Simple Interpreter. Part 1. - Ruslan's Blog]]
[[https://www.reddit.com/r/ProgrammingLanguages/comments/hyhc7b/which_languages_have_weak_references/][Which languages have weak references? - ProgrammingLanguages]]
[[https://www.hillelwayne.com/post/frink/?utm_source=hillelwayne&utm_medium=email][The Frink is Good, the Unit is Evil • Hillel Wayne]]
[[https://www.reddit.com/r/ProgrammingLanguages/comments/hz2mcw/a_few_questions_about_parser_design/][A few questions about parser design - ProgrammingLanguages]]

[[https://chapel-lang.org/][Chapel: Productive Parallel Programming]]
[[https://www.jsoftware.com/#/][Jsoftware]]

[[https://www.dangermouse.net/esoteric/piet.html][DM's Esoteric Programming Languages - Piet]]

[[https://mobile.twitter.com/sarahjeong/status/1313876899546898434][sarah jeong on Twitter: "If they think declaring code is creative enough to merit copyright protection, aren't we left with the conclusion that *languages* are protectable?" / Twitter]]
[[https://github.com/gluon-lang/gluon][gluon-lang/gluon: A static, type inferred and embeddable language written i]]

[[https://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X][Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming L]]

[[https://www.reddit.com/r/ProgrammingLanguages/comments/hm700t/underappreciated_programming_language_concepts_or/][Underappreciated programming language concepts or features? : ProgrammingLa]]

[[https://raku.org/][Raku Programming Language]]
https://www.classes.cs.uchicago.edu/archive/2020/spring/32001-1/
[[https://synthese.wordpress.com/2010/08/21/prologs-death/][the death of prolog]]
https://en.m.wikipedia.org/wiki/Simula
[[https://dl.acm.org/doi/10.1145/2034773.2034801][Parsing with derivatives | Proceedings of the 16th ACM SIGPLAN international conference on Functional programming]]
[[https://m.youtube.com/watch?feature=youtu.be&v=aO9nOCqNdfQ][Robby Findler: Concolic Testing with Higher-Order Inputs - YouTube]]
[[https://arxiv.org/abs/1911.04523][[1911.04523] A Simple Differentiable Programming Language]]
[[https://dl.acm.org/doi/10.1145/268946.268976][The SLam calculus | Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages]]
[[https://vvvvalvalval.github.io/posts/what-makes-a-good-repl.html][Val on Programming: What makes a good REPL?]]
[[https://digitalmars.com/articles/b90.html][on writing a pl]]

https://www.reddit.com/r/ProgrammingLanguages/comments/fxc504/do_you_know_any_interesting_talks_about_pl/

[[https://zserge.com/posts/jvm/][writing a toy jvm]]
[[https://cs.princeton.edu/research/techreps/TR-554-97][The Zephyr Abstract Syntax Description Language]]
[[https://oilshell.org/blog/2016/12/11.html#its-used-to-describe-the-structure-of-python][What is Zephyr ASDL?]]
[[https://github.com/purcell/icfpc2019][ICFP Contest 2019]]
[[https://pharo.org/?utm_source=hillelwayne&utm_medium=email][Pharo - Welcome to Pharo!]]
[[https://en.m.wikipedia.org/wiki/Expression_problem][The expression problem]]

[[https://www.reddit.com/r/ProgrammingLanguages/comments/9ffiky/how_to_get_a_job_in_programming_languages/][how to get a job in programming languages]] [[file:employment.org][Employment]]

[[https://parentheticallyspeaking.org/articles/pls-nature][Programming Languages as Objects in Nature]]
[[https://legacy.cs.indiana.edu/dfried_celebration.html][Daniel P. Friedman: A Celebration]]

[[https://github.com/jfecher/bidirectional][jfecher/bidirectional]]
[[https://github.com/jfecher/ante][jfecher/ante]]

[[https://github.com/jfecher/simplelang][simplelang]]
[[https://aidungeon.medium.com/ai-dungeon-dragon-model-upgrade-7e8ea579abfe][ai dungeon dragon program]]
https://amp.reddit.com/r/AIDungeon/comments/hpkqij/using_the_dragon_module_i_just_generated_what_is
https://www.p-ai.org/ interdisciplinary applications of artificial intelligence
https://www.reddit.com/r/ProgrammingLanguages/comments/hz2mcw/a_few_questions_about_parser_design/
https://github.com/Ahnfelt/funk a fun minimal scripting language
[[https://arxiv.org/abs/1605.06640][programming with a differentiable forth interpreter]]

[[https://www.reddit.com/r/ProgrammingLanguages/comments/i3eyg5/effekt_a_language_with_effect_handlers_and_a/][Effekt: A language with effect handlers and a lightweight effect system - P]]
https://shriram.github.io/pl-hci-school-2020/
* meta
[[https://blog.sigplan.org/2020/07/29/increasing-the-impact-of-pl-research/][increasing the impact of pl research, connecting it to reality!]]


http://www.alexwong.tech/projects/ [[file:hardware.org][Hardware]]  dsls
https://www.williamjbowman.com/#depmacros dependent type systems aas macros paper : )
https://koronkevi.ch/ cool phd student of will bowman!
https://vale.dev/blog/zero-cost-refs-regions work on the Vale language
https://sites.google.com/site/steveyegge2/tour-de-babel whirlwind tour of lagnauges with some opinions
https://technomancy.us/185 [[file:racket.org][Racket]]  cool ideas, reducing the cost of structured data, etc.
https://legacy.cs.indiana.edu/~dfried/mex.pdf
[[https://news.ycombinator.com/item?id=875688][Factor vs. Forth (from a Forth programmer) | Hacker News]]
[[https://en.wikipedia.org/wiki/Joy_(programming_language)][Joy (programming language) - Wikipedia]]
[[https://en.wikipedia.org/wiki/Self_(programming_language)][Self (programming language) - Wikipedia]]
https://chrisdone.com/posts/z/ simple and clever programming language
https://github.com/pikelet-lang/pikelet
[[https://github.com/hazelgrove/hazel][Hazel]]: A live functional programming environment
https://github.com/LeifAndersen/interactive-syntax-clojure
[[https://www.hillelwayne.com/post/influential-dead-languages/][history of dead languages pl]]
[[http://www.zifyoip.com/wysiscript/sigbovik.html][programming with syntax highlighting]]
https://news.ycombinator.com/item?id=24480504 parsing strategies
https://news.ycombinator.com/item?id=24263117 test case generation
https://www.reddit.com/r/compsci/comments/69h3vb/rank_polymorphism_for_array_languages/ !!
https://www.cis.upenn.edu/~bcpierce/courses/670Fall04/GreatWorksInPL.shtml tons of great reading material.
http://www.is.ocha.ac.jp/~asai/Black/ :: an extension of scheme that not only allows for metaprogramming, but also meta-modification of the interpreter it's running on! any program can modify the behavior of the _interpreter_. nuts!
* Esolangs
[[https://esoteric.codes/blog/david-madore][interview about unlambda]]

[[typetheorypodcast.com]] probably a good podcast

https://mitpress.mit.edu/books/reasoned-schemer-second-edition: excellent book co authored by northeastern prof jason hemann
https://abby.how/posts/cubical-type-theory.html: this is probably good but way too hard for me to understand