• e

    elbear

    1 year ago
    does anyone know of a knowledge management tool (Tiddlywiki, Roam) that allows you make linkable identifiers in code blocks? for example, if I have this code
    data Path a = Path Bool [PathSegment a] a
    I want to make
    PathSegment
    linkable and have its definition in another tiddler/block/entry, etc.
    e
    j
    +3
    7 replies
    Copy to Clipboard
  • Mo

    Mo

    1 year ago
    Has anyone stumbled upon interesting research around visual statecharts and state machines. Trying to come up with a really intuitive visual that captures the total power of something like x-state (fancy stuff like parallel state machines, recorded history on state machines....)
    Mo
    Tim Lipp
    +7
    27 replies
    Copy to Clipboard
  • Breck Yunits

    Breck Yunits

    1 year ago
    Has anyone seen a study on "how a DSL becomes a GPL"? Or, alternatively, "what is the most common path travelers take before arriving at Greenspun's 10th rule?" Is there something like "DSLS either die or eventually add identifiers, then functions, then branching, then macros, etc"? I'm curious if you can look ahead and say "well if this is successful, it will eventual require so many things, so might as well not do a DSL in the beginning and instead start with a GPL and build a library"
    Breck Yunits
    Alex Chichigin
    +2
    7 replies
    Copy to Clipboard
  • curious_reader

    curious_reader

    1 year ago
    I’m so grateful to @Jack Rusher or was it @Konrad Hinsen ? For introducing me to Ivan Illich. Here is a interesting piece by him on technology (computers) and how it relates to the concept of commons. https://dlc.dlib.indiana.edu/dlc/bitstream/handle/10535/5962/Silence%252520is%252520a%252520Commons.html?sequence=1&isAllowed=y
    curious_reader
    1 replies
    Copy to Clipboard
  • Rob Haisfield

    Rob Haisfield

    1 year ago
    Anybody know of a solid GPT-3 generator for GraphQL queries?
    Rob Haisfield
    m
    4 replies
    Copy to Clipboard
  • Denny Vrandečić

    Denny Vrandečić

    1 year ago
    When designing a programming language, what are good resources for designing the error / exception system?
    Denny Vrandečić
    a
    +7
    56 replies
    Copy to Clipboard
  • Nick Smith

    Nick Smith

    1 year ago
    Huge idea: what if tensors are the next-generation replacement for RAM? Classic RAM (I'm talking about the software abstraction, not the physical hardware) is just a vector with 2^64 cells, most of which are zero and not backed by physical memory. This is commonly known as a sparse vector. The current AI boom has made it obvious that higher-dimensional memory chunks, known as tensors, are an important idea, especially sparse ones. Other than being higher-dimensional, key differences between tensors and RAM include: • An AI app will typically work with multiple tensors, but a classical app will only work with one RAM. (Though Wasm can have multiple RAMs, known as "linear memories", and of course, you can pretend to have multiple memories using abstractions like malloc). • Tensors can be subjected to unary operations such as slicing, permuting, and aggregation (min, max, sum, product), that generalize the boring read and write operations on RAM. • Tensors can be subjected to binary operations such as multiplication/contraction (generalizing matrix multiplication), convolution, and element-wise addition. The data of everyday programs is often very heterogeneous, which corresponds to having lots of sparse tensors. Sparse tensors need good support in software and ideally in hardware. Thankfully, there is AI hardware being developed that is designed to operate on sparse tensors, by way of dedicated circuits that can compress and decompress them. Tenstorrent is probably the leader here. Here's a fun fact: multiplication of sparse Boolean tensors is equivalent to a database equi-join. So if you think databases are important, then maybe you should give tensors some thought. And relatedly: operations on tensors are typically massively-parallelizable, thus could be a good foundation for a high-performance programming language that compiles to AI hardware.
    Nick Smith
    Shubhadeep Roychowdhury
    +5
    29 replies
    Copy to Clipboard
  • Florian Schulz

    Florian Schulz

    1 year ago
    When @Ivan Reese talks about the data model in Hest (Hest Podcast, Episode 25), he mentions things like: • AOS: Array of Structs • SOA: Struct of Arrays He also mentions a way to organise data where each property (name, color, position, …) is stored in its own Array – in contrast to an Array of Objects of Properties. This reminded me of a talk I had seen at Unite (Unity Conference) about “Data-Oriented Design”. While it makes a lot of sense in terms of memory usage, caching and lookup performance, I barely see data-oriented design today. What are examples of programming languages or software that are using/promote data-oriented design outside of game development?
    Florian Schulz
    Konrad Hinsen
    +4
    7 replies
    Copy to Clipboard
  • Nick Smith

    Nick Smith

    1 year ago
    Calling all software engineers who know basic category theory: some applied category theorists in the US are organizing a hackathon to explore how the theory of polynomial functors can be applied to software development (new programming libraries and/or languages). The attendees would be a mix of software engineers (who know category theory) and category theorists. If you'd be interested in attending or brainstorming about such a hackathon let me know. I've offered to help organize it, but we need more input from software engineers. 🙂 This would be an in-person event in the US, taking place ~March next year. There is a short course and book draft on the category of polynomial functors, outlining its applicability to interactive systems and databases. I expect these applications will be the focus of the hackathon.
    Nick Smith
    Don Abrams
    6 replies
    Copy to Clipboard
  • i

    Ivan Reese

    1 year ago
    I'm thinking more about the sensation of time, as it pertains to the execution of code. (Yeah, back on my bullshit.) I see a spectrum here — a spectrum of different sensations of time for different ways we interact with computation. On one end of the spectrum, we have raw math. There's not supposed to be any sensation of time in the evaluation of math. A variable always has a specific value; relationships either exist or they don't. It might take you (or a computer) some time to crunch values and arrive at a result, but that's absolutely not supposed to be part of the aesthetic. Conal Elliot's Denotational Design is an application of this sort of thinking to software design. Lambda calculus, Curry-Howard, and some of the more hardcore FP languages all exist — infinitely, suspended frozen in midair — over here. Of course, no computer language is actually timeless (that violated physics, and this is addressed in Church-Turing and related work, and we all agree never to try that again), but the desired sensation — the aesthetic — is one in which time is not a constraint or concern. On the other end of the spectrum, we have mechanical computers. There's no avoiding the sensation of time when operating these clockwork beasts. You're required to think about the passage of time as you plan an execution, or else the result will be nonsense, or malfunction. Nothing is instant, nothing exists until you build it. Here we find the CAP theorem, Turing machines, and Rich Hickey's The Language of the System, all of them toiling, sweating, grinding, churning. [Aside: note that Functional Programming is orthogonal to this spectrum — it is not bound to the math side. On either extreme and anywhere in between, you can have programming that's about immutable values (or not), static vs dynamic binding, data & behaviour co-located (or not), for-each vs map, place-oriented vs value-oriented, and so forth.] I've spent all my time over in the mechanical labour camp — this is where Hest lives. So I don't have much insight at all into the crystal tower of pure evaluation. So beyond just suggesting "Hey, talk about this spectrum" (which, granted, I am suggesting), I'd also like to know what examples you can point to that obviously violate this common alignment of aesthetics. For example: what's the most I feel the passage of time in execution you can get to when working with something like Coq, or Haskell, or APL? Is there some step debugger for SML that really lets you feel the iterative progress through execution? Or on the other side, what's out there that takes a process rooted in time — like CAP — and makes it shake that feeling of temporality? Look at something like Erlang/OTP — they take Prolog (timeless) and reify the sensation of process ("let it fail"). Who else is doing that? Is anyone doing it in the other direction?
    i
    Cole
    +7
    26 replies
    Copy to Clipboard