17 Matching Annotations
  1. Last 7 days
  2. Jun 2022
    1. As my colleague Robin Paige likes to say, we are also social beings in a social world. So if we shift things just a bit to think instead about the environments we design and cultivate to help maximize learning, then psychology and sociology are vital for understanding these elements as well.

      Because we're "social beings in a social world", we need to think about the psychology and sociology of the environments we design to help improve learning.

      Link this to: - Design of spaces like Stonehenge for learning in Indigenous cultures, particularly the "stage", acoustics (recall the ditch), and intimacy of the presentation. - research that children need face-to-face interactions for language acquisition

  3. May 2022
    1. an acknowledgement of network effects: LP is unlikely to ever catch on enough to be the majority, so there needs to be a way for a random programmer using their preferred IDE/editor to edit a "literate" program

      This is part of the reason why I advocate for language skins for comparatively esoteric languages like Ada.

    1. memory usage and (lack of) parallelism are concerns

      Memory usage is a concern? wat

      It's a problem, sure, if you're programming the way NPMers do. So don't do that.

      This is a huge problem I've noticed when it comes to people programming in JS—even, bizarrely, people coming from other languages like Java or C# and where you'd expect them to at least try to continue to do things in JS just like they're comfortable doing in their own language. Just because it's there (i.e. possible in the language, e.g. dynamic language features) doesn't mean you have to use it...

      (Relevant: How (and why) developers use the dynamic features of programming languages https://users.dcc.uchile.cl/~rrobbes/p/EMSE-features.pdf)

      The really annoying thing is that the NPM style isn't even idiomatic for the language! So much of what the NodeJS camp does is so clearly done in frustration and the byproduct of a desire to work against the language. Case in point: the absolutely nonsensical attitude about always using triple equals (as if to ward off some evil spirits) and the undeniable contempt that so many have for this.

  4. www.mindprod.com www.mindprod.com
    1. local a (e.g. aPoint) param p (e.g. pPoint) member instance m (e.g. mPoint) static s (e.g. sPoint)

      This is really only a problem in languages that make the unfortunate mistake of allowing references to unqualified names that get fixed up as if the programmer had written this.mPoint or Foo.point. Even if you're writing in a language where that's possible, just don't write code like that! Just because you can doesn't mean you have to.

      The only real exception is distinguishing locals from parameters. Keep your procedures short and it's less of a problem.

    1. This can get much worse than the above example; the number of \’s required is exponential in the nesting depth. Rc fixes this by making the backquote a unary operator whose argument is a command, like this: size=‘{wc -l ‘{ls -t|sed 1q}}
  5. Mar 2022
    1. Understanding a strange codebase is hard.

      John Nagle is fond of making the observation that there are three fundamental and recurring questions that dominate one's concerns when programming in C.

      More broadly (speaking of software development generally), one of the two big frustrations I have when dealing with a foreign codebase is the simple question, "Where the hell does this type/function come from?" (esp. in C and, unfortunately, in Go, too, since the team didn't take the opportunity to fix it there when they could have...). There's something to be said for Intellisense-like smarts in IDEs, but I think the criticism of IDEs is justified. I shouldn't need an IDE just to be able to make sense of what I'm reading.

      The other big frustration I often have is "Where does the program really start?" Gilad Bracha seems to really get this, from what I've understood of his descriptions about how module definitions work in Newspeak. Even though it's reviled, I think Java was really shrewd about its decisions here (and on the previous problem, too, for that matter—don't know exactly where FooBar comes from? welp, at least you can be reasonably sure that it's in a file called FooBar.java somewhere, so you can do a simple (and cheap) search across file names instead of a (slow, more expensive) full-text search). Except for static initializers, Java classes are just definitions. You don't get to have live code in the top-level scope the way you can with JS or Python or Go. As cumbersome as Java's design decision might feel like it's getting in your way when you're working on your own projects and no matter how much you hate it for making you pay the boilerplate tax, when it comes to diving in to a foreign codebase, it's great when modules are "inert". They don't get to do anything, save for changing the visibility of some symbol (e.g. the FooBar of FooBar.java). If you want to know how a program works, then you can trace the whole thing, in theory, starting from main. That's really convenient when it means you don't have to think about how something might be dependent on a loop in an arbitrary file that immediately executes on import, or any other top-level diddling (i.e. critical functionality obscured by some esoteric global mutable state).

  6. Oct 2021
    1. A retrospective of 50 years as a human being on planet Earth.

      The Art of Noticing

      This is a compilation of articles that I had written as a way to process the changes I was observing in the world and, consequently, in myself as a reaction to the events. I have come to think of this process as the art of noticing. This process is in contrast to the expectation that I should be a productive member of society, a target market, and a passive audience for charismatic leaders: celebrities, billionaires, and politicians.

      • Social: fame
      • Economic: wealth
      • Political: power

      An Agent of Change

      To become an agent of change is to recognize that we are not separate, we are not individuals, we are not cogs in a machine. We are complex and diverse. We are designers. We are a creative, collective, self-organizing, learning community.

      We are in a process of becoming—a being journey:

      • Personal resilience
      • Social influence
      • Economic capacity
      • Political agency
      • Ecological harmony

      This is how we shift from an attention economy to an intention economy. Rather than being oriented toward the failures of the past, the uncertainty of the present, or the worries of the future, in a constant state of anxiety, stress, and fear, we are shifting our consciousness to manifest our intention through perception (senses), cognition (mind), emotion (heart), and action (body). We are exploring how we imagine, design, and build the future together.

      We are the builders collective.

      We are one.

  7. Sep 2021
    1. Haber, N. A., Wieten, S. E., Rohrer, J. M., Arah, O. A., Tennant, P. W. G., Stuart, E. A., Murray, E. J., Pilleron, S., Lam, S. T., Riederer, E., Howcutt, S. J., Simmons, A. E., Leyrat, C., Schoenegger, P., Booman, A., Dufour, M.-S. K., O’Donoghue, A. L., Baglini, R., Do, S., … Fox, M. P. (2021). Causal and Associational Linking Language From Observational Research and Health Evaluation Literature in Practice: A systematic language evaluation [Preprint]. Epidemiology. https://doi.org/10.1101/2021.08.25.21262631

  8. Jun 2021
  9. May 2021
  10. Mar 2021
    1. I love the ideas hiding in some of these design elements. The pieces are very atomic, but can be built up into some fascinating bigger designs.

      I'm curious if there are any mnemonics attached to these that add additional levels of meaning in the art in which they're embedded?

      The attached video was incredibly helpful: https://www.youtube.com/watch?v=Kc3K-MyH3xg

  11. Feb 2021
    1. In programming language design, a first-class citizen (also type, object, entity, or value) in a given programming language is an entity which supports all the operations generally available to other entities. These operations typically include being passed as an argument, returned from a function, modified, and assigned to a variable.