Skip to content

Instantly share code, notes, and snippets.

@stevekrouse

stevekrouse/comprehensible-reactivity-07-04-18.md

Created July 4, 2018 20:58
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save stevekrouse/dd90cbee71e0628fc71f3bff1ec708af to your computer and use it in GitHub Desktop.
Save stevekrouse/dd90cbee71e0628fc71f3bff1ec708af to your computer and use it in GitHub Desktop.
Download ZIP
Raw
comprehensible-reactivity-07-04-18.md

Comprehensible Reactivity

  • Title ideas
  • Outline
    • Democratizing media
      • When technology creates new forms of media, at first, there's a very small group that creates with it, but over time technology democratizes it to us all. We can follow this thread for many forms of media.
        • The written word was limited both by the replicability of books, limited until the printing press in the 15th century, and the expense writing materials, which weren't widely available until disposable paper the 19th century. The typewritter, word processing software, Internet blogging, Twitter, and self-publishing, and even texting, have continued to democratize the written word.
        • You can follow similar threads for photography
          • Photo of selfie
          • Instagram
        • And for cinematography
          • YouTube
          • Glitch
      • Democratizing media is (arguably) the most powerful force for good.
        • CP4E quote
          • "In the dark ages, only those with power or great wealth (and selected experts) possessed reading and writing skills or the ability to acquire them. It can be argued that literacy of the general population (while still not 100%), together with the invention of printing technology, has been one of the most emancipatory forces of modern history."
        • The enlightenment
          • The protestant revolution
            • printing press
            • Martin Luther had no idea it would spread so far
          • The scientific revolution
            • journals
            • data plot guy tufte likes
          • American revolution
            • printing press, pamphlets, newspapers
        • More modern examples
          • Arab spring
          • MeToo
          • Black Lives Matter
          • Juan Benet quote
            • In the last 10 years, the iPhone (+ unwittingly, the Telcos) have done more for human rights than the UN. It's kinda crazy, but email, photos, twitter, facebook have stopped more abuses + promoted more global community than the "world government" body.
      • On an individual level, democratizing media is empowering.
    • Democratizing programming "TODO"
      • CP4E quote
        • We compare mass ability to read and write software with mass literacy, and predict equally pervasive changes to society. Hardware is now sufficiently fast and cheap to make mass computer education possible: the next big change will happen when most computer users have the knowledge and power to create and modify software.
      • TODO steal parts of http://futureofcoding.org/essays/app-idea
      • app boundaries "TODO needs a lot of work"
      • past efforts "TODO needs a lot of work"
        • diSessa on medium
        • STEPS project
          • Many of the same goals
          • I want more web/internet than OS
          • I want more restrictive
        • CP4E
          • https://www.python.org/doc/essays/cp4e/
          • What will happen if users can program their own computer?" We're looking forward to a future where every computer user will be able to "open the hood" of their computer and make improvements to the applications inside. We believe that this will eventually change the nature of software and software development tools fundamentally.
          • The tools needed for this new way to look at programming will be different from the tools currently available to professional programmers. We intend to greatly improve both the training material and the development tools available. For example, non-professional programmers should not have to fear that a small mistake might destroy their work or render their computer unusable. They also need better tools to help them understand the structure of a program, whether explicit or implied in the source code.
          • Of course, most children won't grow up to be skilled application developers, just as most people don't become professional authors--but reading and writing skills are useful for everyone, and so (in our vision) will be general programming skills
          • For example, you might want to write a program to customize your PDA or toaster, but you might be discouraged if a small mistake could wipe out your address book or set your house on fire. Safeguards against disasters are needed, as well as ways of backing out of unwanted changes to a system as a whole. ("Undo", while very powerful, usually only applies to one file at a time. Backing out of unwanted global system changes typically requires a reboot or even painful data restoration from back-up media.)
            • Hazelnut and edit semantics are key
        • OOP
          • opaqueness is actually bad?
        • Aspect oriented programming
          • What is this?
    • Customizing, improving the apps you use "TODO - this section needs a lot of work"
      • CP4E quote
        • Rather than writing new programs from scratch, most people will add new code to existing programs. There are three significant challenges that must be addressed by programming tools aimed at this audience.
      • Glench quote
      • Why it's important
        • a world of always improving software
          • open source software would become better than closed source
        • infinitely customizable
          • Firstly, our software will only solves the problems of the masses, one-size-fits-all problems. The problems that affect mere thousands, hundreds, or even one person can’t be directly addressed via software. It’d be too expensive to create custom software, let alone support it as people’s’ needs evolve. Today all the customization we get is a meager settings menu and maybe a few Zapier integrations.
          • CP4E quotes
            • "The open source movement claims that peer review of software by thousands can greatly improve the quality of software. The success of Linux shows the value of this claim. We believe that the next step, having millions (or billions) of programmers, will cause a change of a different quality--the abundant availability of personalized software.... this will cause a massive surge in productivity and creativity, with a far-ranging impact that can barely be anticipated or imagined."
            • " the quantity and quality of available computer software will improve drastically, as the imagination and labor of millions is applied to the problem. Inventive users will be able to improve the software that supports them in their tasks, and share their improvements with their colleagues or--via the Internet--with others far away who are faced with the same tasks and problems. The ability to modify or customize software is important in crisis situations, when experts cannot be appealed to for help."
        • it's so compelling, particularly when you can make changes
      • Requires r0ml's liberal runtime
        • CP4E quotes
          • Our tools will also help users manage and configure software, so that individual components can be replaced or upgraded over time. These tools will help users share new and modified programs by automatically tracking versions and dependencies.
          • When a user makes a change to an application, what assurances are there that a future update to the application by the vendor will be compatible with these changes? How does the user himself keep track of just what changes they've made to an application? What happens when a future version of the product adds a feature, previously missing, that the user has added (in a different form)?
          • Our tools will help users keep track of changes they've made, through successive revisions, and help users merge their changes back when the primary application itself has been modified or updated by the vendor. A key to this approach is identifying each version of software and a simple language for describing its properties and dependencies. For example, we intend to improve version control systems so that they track changes at different abstraction levels and granularities than current systems, e.g. labeling changes based on the features they implement instead of the source files (or parts of files) they modify. The tool will automatically identify dependencies on other libraries and component. We will investigate ways to integrate testing frameworks into the configuration management systems so that when the primary application is upgraded, each feature change a user has installed, will be merged and tested.
          • If users are empowered to modify and customize code, they will be challenged to maintain those changes when the underlying software is upgraded or when system components are replaced.
        • https://lwn.net/Articles/712376/
        • https://youtu.be/i3nJR7PNgI4?t=30m11s
        • A way to mix and match edits
        • "The hard part was getting the source code. We don't live in that world anymore. When you're using a computer, the computer you're using is nowhere near you. The computer is elsewhere. Google Docs, Twitter, Facebook. Anything you're doing with a computer, 99% of the processes are happening somewhere else where you can't download software stuff, and you can't build stuff. What you want to be able to do is.. deploy your code on somebody else's computer, which is the one that you're using. Cause that's that hard part. Replicating Google's 1.2M servers in your basement. That's a bigger impediment than reverse engineering the code."
          • We already have AWS so it's not the servers exactly
        • "GitHub does not work that way. I think it ought to work that way. So how do I make it work that way? There are two theorems. The first says if you have access to the source code, which you don't because it's not open source but that's neither here nor there, what you could do is reproduce all of Github's infrastructure in your basement and tell all your friends to get an account on your Github copy, which has this modification. Or you can convince GitHub that they ought to allow you to push in changes the way Github works for you."
          • It's more access to the resources and that's key
        • liberality on the backend is complex
          • I wonder if the new social web, federation work would help with that
      • Side/foot note: Not just in superficial ways
        • not just a glorified settings menu
        • nor IFFT/Zapier
        • in scratch kids just change one or two parameters
        • in elm, there's a don't go below this line
    • Democratizing interactive interfaces
      • Computer programming is being particularly resistant to democratization.
      • Some forms of programming have been somewhat democratized
        • WYSIWYG tools like webflow, squarespace
        • Mathmatica
        • Even Salesforce/Airtable is a democratized database
      • But not the creation of interactive interfaces
        • You're stuck with Proccessing
          • Learnable Programming
        • React, Redux, Elm, CycleJS, etc, etc
        • Or limiting your expressiveness with a tool like Bubble
          • TODO contextualize this
      • This is particularly important
        • Interactive interfaces power the democratization of all forms of media
          • meta unlocking superpowers
        • The majority of the photons that hit our waking eyes come from software user interfaces
          • TODO
      • Side/footnote: That's not to say that the backend doesn't need democratization too.
        • so much of the backend is incidental complexity
          • increasing the performance of things
        • the essential complexity of backend is
          • authentication
            • this seems mostly abstracted away with OAuth, etc
          • storage
            • you could bring your own cloud (dropbox) or local store with you
            • permissioning
    • Comprehensible User Interface Code "TODO - this section needs a lot of work"
      • Aside: this is distinct from "learnable programming"
        • spiritual
        • Paul Chiusano's argument that learnability is a 1-time cost
          • brain interface to x86 or text to haskell
        • Analogy: learning decimal vs roman numerals
          • Maybe need a better analogy
        • Learnability is important, but we optimize for comprehensibilty in complex applications, because that's what people use
      • http://futureofcoding.org/essays/casual "TODO"
      • http://glench.github.io/fuzzyset.js/ui/ "TODO"
      • two ways to get to FRP "needs work"
        • visual -> restrict -> FRP
        • local, equational reasoning -> FRP -> hard to read / debug -> visual
      • CP4E quotes
        • another concern for beginning programmers who are interested in customizing their computer is the daunting task of trying to understand a large piece of existing software. We need to look into user-friendly tools for program analysis
          • Program slicing and program paths
            • Turns out there’s a whole field about static analysis of what hits what.... relevant to /essays/casual
        • We will develop tools to help users understand the structure of large programs so that they can identify where to make changes and what impact those changes will have.
      • We need to rule out parts we don't have to read
      • We need to see the live data
        • Makes it concrete
        • Can cite the articles that show programmers need to set breakpoints to see this in the end of the Debugging Rx article
      • We need visual http://futureofcoding.org/essays/visual "TODO"
        • CP4E quote
          • Another intellectual challenge is visualization of (application-generated) data in ways that help novices. Spreadsheets are of great value here, but not all data fits the matrix form.
        • Why are visuals important
          • Metaphors/analogies
            • The best thinkers think visually in their heads
          • Tufte
          • Glench legible mathematics
        • we can only do visuals with a simplified model
          • without simplified, we're stuck with
            • python tutor
          • which is why origami is so great
            • but we need to restrict more to make it scale
              • pulses
          • Rxmarbles
    • Eventually, a tool for comprehensible editing
      • Live
        • Water hose, not firing arrows "TODO quote person"
      • Paul Chiusano hash based deps
      • glench quote
        • What if the result of programming wasn't a bunch of text files but a human-understandable explanation of a complex system? What if that's the way we programmed in the first place — in a UI that explained how the system we were building worked in detail using the best tools we have from systems theory, data visualization, and our knowledge about human learning?
    • Casual editing
      • Casual is the pinnacle of democratization "Do I need this section?"
        • The picture above (bottom right) shows professional tools, which is a step in the right direction, but not the final step.
        • Final Cut Pro democratized the creation of movies to my 12-year-old self. Yet it's still a tool for "professionals." iMovie democratized for even more people, and Snapchat is pushing it even further.
        • The pinnacle of democratized media is Twitter, Instagram, Facebook live streaming - as compared to messing with ink and paper or old school photography equipment, lighting, etc.
        • It's the difference between webflow and universe
      • in the course of using an app
      • No dev env setup
        • CP4E quote
          • First, the environment must significantly ease the burden of writing, installing, and debugging new programs. The current generation of development tools can be cumbersome for expert users, let alone novices
      • This will be a challenge on mobile but I don’t see why not
        • Universe / Hopscotch
    • My next steps
      • Reflex visualizations, todomvc, maybe cyclejs devtools "TODO!!!"
      • You can follow the progress on futureofcoding.org/log
      • I’m always looking for collaborators
  • todos
    • let's try to simplify
      • All forms of media start out inaccessible but are democratized over time.
        • The democratization of media is arguably the greatest force for good in the world.
      • people (don't even know they) want to improve and customize the software they use
        • /app-idea
        • /power
        • It's important to democratize programming, because it democratizes all media.
      • it'd lead to a world of infinitely improving and customizable software
        • CP4E quotes
      • yes, yes there are many things in the way
        • r0ml liberal
      • let's just focus on one particular problem
        • casual
          • because needs to repay investment
        • comprehensibility
        • programmers
          • glench files and folders
        • user interfaces
          • photons
      • Comprehensible User Interface Code
      • edit this way too
        • glench programmed in the first place quote
    • another simplification
      • We have a few problems
        • software can be expensive to make
        • software is 1-size-fits all, uncustomizable
        • software is often shitty to use
      • The solution to all of these problems is make software easier to improve
        • Not make, because there is no make, there's only improve
          • and things are complex anyways
        • The lower we decrease the cost of making an improvement, the more people who use apps will be able to improve them
          • Imagine if you could improve an app in the course of using it
        • the better they will get
        • and also customize-able
        • and for free (intrinsic motivation)
      • There are a lot of things that make software difficult and expensive to improve
      • But there's one showstopper in particular, I'd like to discuss: code comprehensibility
    • starting from glen
      • code comprehensibility is unsolved and important
      • one way to solve it is by showing the data (glen)
      • another way is by changing the model (my FP refactor)
      • TODO combine this in a Flowsheets like tool
      • This becomes even harder to computations that react to inputs over time
      • We need to apply both insights, show the data and change the model = FRP + Viz
  • People to send to for review
    • Glen Chiacherri
    • Jonathan Edwards
    • Stream visualizations
      • David K Piano
      • James Somers
    • Paul Chuisano
    • Christopher Anand
    • Jonathan Leung
    • Brent Yorgey
    • Aidan Cunniffe
    • Scott Mueller
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment