Everything is foldable in IDEs so long as the IDEs make them foldable.

What about chained dotted access? foo.bar.baz is probably okay as bar.baz @ (the Foo) (or even @the Foo), but probably not if it takes the form bar.baz from the Foo. (It just doesn't look reasonable to me.)

Alternatively, what about @bar.baz for the Foo?

This is indeed very good (for the reasons stated here).

how important is the concrete syntax of their language in contrast to the abstract concepts behind them what I mean they say can someone somewhat awkward concrete syntax be an obstacle when it comes to the acceptance

.

Obnoxious.

As someone recently pointed out on HN, it's very common nowadays to encounter the no-one-knows-else-what-they're-doing-here refrain as cover—I don't have to feel insecure about not understanding this because not only am I not alone, nobody else understands it either.

Secondly, if your code is hard to understand regarding its use of this, then your code his hard to understand. this isn't super easy, but it's also not hard. Your code (or the code you're being made to wade into) probably just sucks. The this confusion is making you confront it, though, instead of letting it otherwise fly under the radar.* So fix it and stop going in for the low-effort, this-centric clapter.

* Not claiming here that this is unique; there are allowed to be other things that work as the same sort of indicator.

This is an excellent property. It's not a weakness.

• https://www.object-oriented-security.org/lets-argue/singletons
• https://dl.acm.org/doi/pdf/10.1145/62084.62095
• https://gbracha.blogspot.com/2008/02/cutting-out-static.html
• http://www.erights.org/

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

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

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.

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.

Were parens taken?

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).

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.

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

Tommy Shane on Twitter. (n.d.). Twitter. Retrieved 14 February 2021, from https://twitter.com/tommyshane/status/1357385093514461184

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