• noahtren

    noahtren

    2 years ago
    A question I've been wondering about recently is why aren't programming languages more... modular? Like, why isn't there a system for using X interpreter/compiler with Y syntax? Every language is bound to a specific runtime environment and syntax, but would it be possible to mix and match these somehow?
    noahtren
    Chet Corcos
    +8
    21 replies
    Copy to Clipboard
  • Stefan

    Stefan

    2 years ago
    I'm working my way through Bob Nystrom's Crafting Interpreters (recommended — extremely approachable guide to creating your own programming language) and this part in chapter 12 just felt super relevant:
    We language nerds have a tendency to fetishize minimalism. Personally, I think simplicity is only part of the equation. What we really want to give the user is power, which I define as:
    power = breadth × ease ÷ complexity
    None of these are precise numeric measures. I’m using math as analogy here, not actual quantification.
    Breadth is the range of different things the language lets you express. C has a lot of breadth—it’s been used for everything from operating systems to user applications to games. Domain-specific languages like AppleScript and Matlab have less breadth.
    Ease is how little effort it takes to make the language do what you want. “Usability” might be another term, though it carries more baggage than I want to bring in. “Higher-level” languages tend to have more ease than lower-level ones. Most languages have a “grain” to them where some things feel easier to express than others.
    Complexity is how big the language is (and its runtime, core libraries, tools, ecosystem, etc.). People talk about how many pages are in a language’s spec, or how many keywords it has. It’s how much the user has to load into their wetware before they can be productive in the system. It is the antonym of simplicity.
    Reducing complexity does increase power. The smaller the denominator, the larger the resulting value, so our intuition that simplicity is good is valid. However, when reducing complexity, we must take care not to sacrifice breadth or ease in the process, or the total power may go down. Java would be a strictly simpler language if it removed strings, but it probably wouldn’t handle text manipulation tasks well, nor would it be as easy to get things done.
    The art, then is finding accidental complexity that can be omitted. Language features and interactions that don’t carry their weight by increasing the breadth or ease of using the language.
    Stefan
    alltom
    +3
    9 replies
    Copy to Clipboard
  • i

    Ivan Reese

    2 years ago
    🎺 Episode 46 of the podcast is now a thing that exists in the world! Oh what's that? 📊 The results of the first ever Future of Coding Community Survey are now published! Can we do one more? 🎙️ I made a 10+ minute long audio piece exploring what the future of coding means. In the bastardized words of the crazy one — Episode 46. Survey results. The true meaning of FoCmass. These are not three separate projects. https://futureofcoding.org/episodes/046 🍰
    i
    Duncan Cragg
    +5
    30 replies
    Copy to Clipboard
  • Mariano Guerra

    Mariano Guerra

    2 years ago
    Mariano Guerra
    i
    10 replies
    Copy to Clipboard
  • Mariano Guerra

    Mariano Guerra

    2 years ago
  • c

    Chris G

    2 years ago
    c
    e
    +1
    7 replies
    Copy to Clipboard
  • Scott Anderson

    Scott Anderson

    2 years ago
    Scott Anderson
    Kartik Agaram
    +1
    9 replies
    Copy to Clipboard
  • i

    Ivan Reese

    2 years ago
    One of the things that I learned while making the 2020 Community Survey is that... it was very hard for me to categorize our interests in a way that produced useful data. This question, "What FoC topics interest you most?" was my attempt at it, and it was a bit of a disaster! I think it would be exhausting to list all our possible interests, but grouping some them together also seems to have caused issues. The more we lean on the fill-in answers, the less we'll be able to identify shared interests because the way we describe them will be different. If we let people select as many answers as they want, we'll have a harder time visualizing the result set because we have to decide how to weight each selection. But if we limit the number of selections, Duncan gets really mad, and (sigh) rightfully so. I hope it's clear what I was interested in learning from this, but I think I bungled the execution. It'd be super interesting to hear how you would go able trying to structure this question. How would you build a survey that attempted to figure out what our most central interests were, and to what degree we were interested in those things? The things to maximize are: how much can we learn, and how efficiently and painlessly can we collect that data from people?
    i
    w
    +9
    25 replies
    Copy to Clipboard
  • p

    Paul Butler

    2 years ago
    I've been thinking lately about a genre (for lack of a better word) of coding pedagogy that involves presenting the learner with a series of tasks of escalating difficulty with very little new content to read/study in between. Some examples I consider to fall under this are: • Project Euler (number theory / recreational math) • rosland.info (bioinformatics) • exercism.io (language-specific tracks) Are there examples of this style of learning in other programming domains? (e.g. 3d graphics, core CS, etc.) Other thoughts on this style of learning?
    p
    shalabh
    +11
    22 replies
    Copy to Clipboard
  • i

    Ivan Reese

    2 years ago
    One of our lurkers, @Alex Wein, whipped up this beautiful interactive display based on the community survey. I think you'll enjoy playing with this. https://observablehq.com/@a-lexwein/what-future-of-coding-topics-interest-you-most
    i
    robenkleene
    +2
    18 replies
    Copy to Clipboard