• Orion Reed

    Orion Reed

    6 months ago
    Been thinking today about “handoff mechanisms” and how they're essential in networking/communications infrastructure, but we don't have a similar notion in software (that I know of). This came up while working on an Obsidian plugin to replace the built-in “graph view”. One of the design constraints was that it handles different scales appropriately, from deterministic approaches at small scales -> physically simulated at medium scales -> probabilistic/heuristic at large scales. I didn't want there to be any modes and I wanted there to be consistent observed behaviour, so I started referring to this as “pixel-perfect handoff”. It's made me wonder what else there is to explore here. Imagine interface systems that are able to switch backends without you noticing; tools that can be “dragged” into other software which appear to continue uninterrupted; data transformations switching to faster approaches when the context allows. What other examples might there be? Where else could this idea go? What infrastructure could be developed? Is this just another lens on interoperability, or something else?
    Orion Reed
    Srini K
    +1
    3 replies
    Copy to Clipboard
  • karki

    karki

    6 months ago
    I recently came across this interesting piece of programmable tech :

    https://www.youtube.com/watch?v=ip641WmY4pA

    Other than capturing my attention for being an interesting product, it got me thinking of new hardware extensions (or complete systems) that would enhance/change the coding experience. We always discuss what kind of digital UIs would make programming simpler and more intuitive, so I was wondering if someone has looking into new kind of hardware I/O which would change how we program today. In fact new hardware could spur new mental models and digital interfaces for programming! (Think of how a mouse / touchscreen is central to something like Blocky/ MIT Scratch). I have no experience in this field, just wanted to get a discussion going and see if someone with a bit more familiarity could chime in!
    karki
    Florian Schulz
    4 replies
    Copy to Clipboard
  • Mariano Guerra

    Mariano Guerra

    5 months ago
    Is there a "grammar/pattern/algebra of parser combinators" somewhere? Something that describe the common parts that most parser combinators have, choice, iteration and so on
    Mariano Guerra
    g
    +2
    4 replies
    Copy to Clipboard
  • m

    Mark Dewing

    5 months ago
    I'm interested in using call graphs/control flow in a hierarchical way to understand programs better. The problem is there seems to be two extremes - high level diagrams done manually and low level call graphs generated by tools. A manual drawing with boxes and arrows is often used when describing a program at the highest level. While it works, one question is how to move to the next level of detail? Someone has to do that manually as well. These diagrams aren't connected to the source and can get out of date. The structure is going to change slowly at the highest level and so keeping up-to-date manually isn't that much trouble. More detailed levels, though, can change more frequently and keeping them up-to-date is more work. At the other extreme, tools to generate callgraphs give all the functions. They can filter by time, number of calls or call stack depth, but those doesn't necessarily correlate to what's important conceptually. I'm wondering if there's any work on anything between these two extremes? Both in generating it and visualizing it. (Searching online for 'hierarchical call graph' gives research on automated and machine learning approaches to discovering a hierarchy - interesting as research, but not what I'm after here. I would prefer something manual like adding program annotations or creating filtering terms - something that can be automated as part of a build or CI process.)
    m
    c
    +1
    3 replies
    Copy to Clipboard
  • e

    Eric Gade

    5 months ago
    Anyone here know about in-browser ML tools for building models using images? In this case, we'd like to annotate ("draw" where relevant lines are present) some subset of an image corpus to build a model, and to do so interactively, feeding this training data into some easily configurable NN tool. Is there anything like this that is simple from a UI point of view?
    e
    karki
    +2
    8 replies
    Copy to Clipboard
  • Joakim Ahnfelt-Rønne

    Joakim Ahnfelt-Rønne

    5 months ago
    Inspired by the recent post on Crosscut, I started thinking about geometric programming, and what it might look like. I came up with the idea of using areas and line segments of 2D shapes as inputs and outputs. For example, a rectangle gives us addition (the half circumference), multiplication (the area), square root (using area as an input and measuring one of the sides): (image 1) One could imagine an iteration construct ala the one in Bret Victors computational drawing program, or similar to the one in Crosscut, that allowed expressing e.g. Fibonacci iteratively: (image 2) Here the green arrows connect inputs lines to output lines, and the dots show where line segments begin and end. The dotted rectangles represent iteration, where the first rectangle is used to specify the relation to previous rectangles (exactly how is a bit vague, I know). The green line sets the distance between each iteration. Similarly, a unit circle could show the angle as a bent line (in radians, as the circumference is 2*pi), and sin/cos as shown. Using sin/cos as inputs and measuring the bent line you get asin and acos: (image 3) Thoughts? Maybe it already exists?
    Joakim Ahnfelt-Rønne
    i
    +2
    5 replies
    Copy to Clipboard
  • Chris Knott

    Chris Knott

    5 months ago
    People admire Lisp's "elegance" in that it only has a single built-in datastructure - lists
    (a b c)
    . Clojure, on the other hand is generally admired for being more "practical". One of the main things Clojure introduced is vectors
    [a b c]
    , and maps
    {:a b, :c d}
    as first class syntax. I was reading some Lisp this week and my brain kept grating/complaining because I was seeing what are conceptually hashmaps written as what I was interpreting as a lists of pairs, something which I "know" to be different. Conversely, I have always thought it was annoying that C++ has three different operators (
    ::
    ,
    .
    ,
    ->
    ) that all essentially mean "member of". Would C# be better if you had to say
    System::Console.Print()
    instead of
    System.Console.Print()
    ? No, I think most people would rarely feel the need to conceptually distinguish between these things, the C++ syntax is just annoying noise to me. What is it that distinguishes Clojure's brilliant decision to expand the syntax, from C# brilliant decision to compress the syntax? It implies to me that if there is a scale of simplicity-to-expressiveness, then humans just happen to sit at particular point on it. There's no particular "reason" for why these changes were right other than "they'd gone too far that way, go back this way". There's a local maximum somewhere in the middle. I have been thinking about this simplicity-to-expressiveness scale recently as it irrationally annoys me that on WikiData, "instance of" is "just another relationship" (it's P31 - "citizen of" is P27!). I think that RDF is far too far towards the "elegance" end of the spectrum and would greatly benefit from a Clojure-style acknowledgement that some things are more different, and should be more differentiated. Yeah, it's mildly interesting that Node-Rel-Node triples is all you need to describe an ontology, but that's not actually how people think about the world...
    Chris Knott
    ibdknox
    +4
    8 replies
    Copy to Clipboard
  • j

    Josh Justice

    5 months ago
    Has anyone heard of anyone trying to build end-user-modifiable apps with Electron? For those who are up for working in JS, it seems like you could have the same Electron app both run code and allow you to edit the code that's run in-app. Could even use VS Code's editor.
    j
    i
    3 replies
    Copy to Clipboard
  • Mariano Guerra

    Mariano Guerra

    5 months ago
    What's the intersection between future of coding and distributed computing? I'll go first: unison and t2tile, are there more?
    Mariano Guerra
    g
    +6
    15 replies
    Copy to Clipboard
  • s

    Steve Dekorte

    5 months ago
    Was recently looking into "annotations" in Self and Java, as well as the related concepts of "property wrappers" and "function builders" in Swift. Are there other languages with similar features? Also, what are the most interesting uses of annotations you've run across?
    s
    Mariano Guerra
    +4
    14 replies
    Copy to Clipboard