What if it’s a function of age, rather than amount of tech we’re exposed to?
For example, I feel younger people are able to focus for longer periods of time on reading long form texts, and an older person may benefit more from finding specific sections from a longer work that they may find interesting or useful that they can read.
As you age there is much more repetition in things than you are consuming. Maybe it’s not bad to be filtering out certain repetitions while hopefully not filtering out things that go against any personal biases.
Furthermore, the books I’m interested in reading now I feel require more time, maybe even a year or two, whereas when I was younger I was really interested in reading massive amounts just for the sake of it.
Young adults read the most books, statistically. It is biggest market. They read less then previous generation used to read at their age, but they still read more then previous generation reads now.
Absolutely. When I was a kid, I'd skip tutorials, I'd skip text in RPGs. I just wanted to get to the ACTION.
As I'm older, I'm actually able to sit down and appreciate slower-form / long-form RPGs with lots of text that adds the real texture to the graphics--which only really form a symbolic / tactical representation of the world, and the flavors, the smells, all come from text. In many ways, the game mechanics of most games are all the same and the flavor is what sets them apart.
Exile 3: Ruined World for example. (And the two remakes Avernum 1 and 2 series.) Are legendary for their novel length text and story.
When I was a kid, I spent my time playing with character options, trying out new diseases (more diseases = less XP per level--neat idea) and skipping texts to explore. But then I'd always get stuck at some point because I missed a key piece of text when I skimmed
(That's actually one "game sin" I hate in many games. If you're going to have important text buried in tons of flavor text, COLOR or EMPHASISE IT. The last thing you want is a player who gets tired one night, skips ONE line that was important, and then hates your game because they're frustrated without information they should have had.)
Not saying it's the closest to what you have in mind, but you could look at the Emacs Tuareg mode for OCaml. Here is a reference card: http://www.ocamlpro.com/files/tuareg-mode.pdf
If you are a SLIME fan, you might notice that some of the key bindings to interact with the toplevel (the OCaml word for "REPL") are identical in Tuareg.
That said, although this will sound tongue-in-cheek: Having used Isabelle and Coq with their interactive editors, I find their approach better than a REPL. In these systems, you execute code directly from your source file, as opposed to (conceptually) sending snippets of code to a REPL. There is no concept of code you have written in the source (or the REPL) which is not synced up with the state of the REPL (or the source code, respectively). I wish other languages had modes like this. There seems to be one for Prolog, but I've never used it and don't know how well it works in practice: https://www.metalevel.at/ediprolog/
I've been happy with it. It's a good place to isolate your type issues and figure out how to plug things together. It helped me learn a lot about how F# does its type inference.
I'm still wrapping my head around macros, but I have
been able to come up with a couple use cases that I quickly realized were already covered by existing macros, the most recent one being a less flexible -> macro.
Anyways, I kept reading places that lisp macros and c macros were completely distinct, which seems untrue after a couple years of trying clojure.
> I kept reading places that lisp macros and c macros were completely distinct, which seems untrue after a couple years of trying clojure.
They're similar in that they're both compile-time functions that generate code, but they're very different in practice, because C macros are written in a text substitution language that knows virtually nothing about C, which naturally makes writing even simple macros very error-prone. Lisp macros, on the other hand, are written in plain old Lisp and receive regular Lisp data structures that you can use the whole language to operate on.
A lot of people learn from C that macros are very difficult to get right, so it's important when they move to Lisp that they give them a second look, because Lisp is a much more capable language for code transformation than cpp.
>Anyways, I kept reading places that lisp macros and c macros were completely distinct, which seems untrue after a couple years of trying clojure.
I haven't used Clojure macros but as a programmer that uses both C and Common Lisp, I can say with good authority that C macros and CL macros are very different.
I read another comment on hacker news today that referred to a type of regulation that is actually accountability.
Perhaps if we were able to classify regulation further it would be easier to analyze the tradeoffs of certain regulations rather than saying all regulation is bad or all regulation is good.
But if we do that we have to accept that there are tradeoffs in the first place. We have to recognize that reasonable people might disagree about which tradeoff to make. We have to accept that even good decisions are likely to leave someone somewhere worse off. We might even have to gasp understand the historical and cultural context in which the current system arose.
It is a good point I hadn't considered that public cryptocurrencies are not fully fungible. I.e. It may be socially unacceptable to accept money from certain known people.
> Rust’s design has taken inspiration from a lot of existing languages and techniques, and one significant influence is functional programming. Programming in a functional style often includes using functions as values, by passing them in arguments, returning them from other functions, assigning them to variables for later execution, and so forth. We won’t debate here the issue of what, exactly, functional programming is or is not, but will instead show off some features of Rust that are similar to features in many languages often referred to as functional.
It is weird that they were redirecting their customers to Koodo when they stopped offering a certain favorable plan.