the ten thousand things became so catastrophically powerful.

It is important to learn as much and at the sametime as little as possible.J

neoclassical Economist about you know growth can be totally decoupled from 00:45:45 Material use

I don't really understand what they think uh what it is um if it's not you know 00:45:20 how resources are allocated and um the the transformation of commod you know raw material into finished goods and stuff all that takes energy it all takes material

We must not use the word system, then, to refer to an object. A system is an abstraction. It is not a special kind of thing, but a special way of looking at a thing.

In order to speak of something as a system, we must be able to state clearly: (1) the holistic behaviour which we are focusing on; (2) the parts within the thing, and the interactions among these parts, which cause the holistic behaviour we have defined; (3) the way in which this interaction, among these parts, causes the holistic behaviour defined. If we can do these three, it means we have an abstract working model of the holistic behaviour in the thing. In this case, we may properly call the thing a system, If we cannot do these three, we have no model, and it is meaningless to call the thing a system.

Certainly you could adapt the code to round rather than truncate should you need to; often I find truncation feels more natural as that is effectively how clocks behave.

Web sites often design their APIs to optimize performance forcommon cases. Their main object-reading methods may return onlycertain “basic” properties of objects, with other methods availablefor fetching other properties. ShapirJS hides this performanceoptimization complexity from the user.

The value of <Y>, the position of which varies in the sequences, may be the precursor of place value, in which, for example, 5, 50 and 500 represent different values according to their position, thought to have been a Sumerian invention (d'Errico et al. Reference d'Errico, Doyon and Colage2017).

We believe that we have demonstrated the use of abstract marks to convey meaning about the behaviour of the animals with which they are associated, on European Upper Palaeolithic material culture spanning the period from ~37,000 to ~13,000 bp. In our reading, the animals integral to our analytical modules do not depict a specific individual animal, but all animals of that species, at least as experienced by the images’ creators. This synthesis of image, mathematical syntax (the ordinal/linear sequences) and signs functioning as words formed an efficient means of recording and communicating information that has at its heart the core intellectual achievement of abstraction.

subject { described_class.do_something }

Testing frameworks often introduce their own abstractions for e.g. evaluation order, data validation, reporting, scope, code reuse, state, and lifecycle. In my experience, these abstractions are always needlessly different from (and inferior to) related abstractions provided by the language itself.

before that the support for parsing JSON in C was essential for using LSP servers

here are several ways I havefound useful to invite the sociological imagination:

Prefer alias when aliasing methods in lexical class scope as the resolution of self in this context is also lexical, and it communicates clearly to the user that the indirection of your alias will not be altered at runtime or by any subclass unless made explicit.

Whitehead once described the mentality of modern science as having beenforged through “the union of passionate interest in the detailed facts with equaldevotion to abstract generalization.”

And just a fewyears later, it was jubilantly discovered that machine translation and automaticabstracting were also just around the corner.

The idea here is to emulate the hardware platform WordPerfect ran on

I avoided using languages that I don't know how to bootstrap like node.js

Typography in HTML is awful

Even physicists,when they leave equations behind and try to describetheir discoveries to the rest of us in plain English, findthemselves employing analogies, metaphors, and theother language tools we all use

it might be worth-while to point out that the purpose of abstracting is not to be vague, but to create a new semantic level in which one can be absolutely precise

This is possible because the internet isn’t designed around telephone networking hardware. It isn’t designed around any hardware at all. Instead, the internet runs on ideas, a set of shared protocols. You can implement these protocols over a telephone, over a fiberoptic cable, or over two tin cans connected with string.

And the best ideas are usually the ones we haven’t anticipatedanyway.

Consider, as well, the extent to which the tools of abstraction are themselves tied up in the history of the trans-Atlantic slave trade. As the historian Jennifer L. Morgan notes in “Reckoning With Slavery: Gender, Kinship, and Capitalism in the Early Black Atlantic,” the fathers of modern demography, the 17th-century English writers and mathematicians William Petty and John Graunt, were “thinking through problems of population and mobility at precisely the moment when England had solidified its commitment to the slave trade.”Their questions were ones of statecraft: How could England increase its wealth? How could it handle its surplus population? And what would it do with “excessive populations that did not consume” in the formal market? Petty was concerned with Ireland — Britain’s first colony, of sorts — and the Irish. He thought that if they could be forcibly transferred to England, then they could, in Morgan’s words, become “something valuable because of their ability to augment the population and labor power of the English.”This conceptual breakthrough, Morgan told me in an interview, cannot be disentangled from the slave trade. The English, she said, “are learning to think about people as ‘abstractable.’

If you're looking for a slightly higher level API built on the same technology, you may want to check out watir or capybara.

This is what I call a leaky abstraction. TCP attempts to provide a complete abstraction of an underlying unreliable network, but sometimes, the network leaks through the abstraction and you feel the things that the abstraction can’t quite protect you from. This is but one example of what I’ve dubbed the Law of Leaky Abstractions:

Webpacker has become a slimmer wrapper around Webpack

The WebSocket Protocol is designed on the principle that there should be minimal framing (the only framing that exists is to make the protocol frame-based instead of stream-based and to support a distinction between Unicode text and binary frames). It is expected that metadata would be layered on top of WebSocket by the application Fette & Melnikov Standards Track [Page 9] RFC 6455 The WebSocket Protocol December 2011 layer, in the same way that metadata is layered on top of TCP by the application layer (e.g., HTTP). Conceptually, WebSocket is really just a layer on top of TCP that does the following: o adds a web origin-based security model for browsers o adds an addressing and protocol naming mechanism to support multiple services on one port and multiple host names on one IP address o layers a framing mechanism on top of TCP to get back to the IP packet mechanism that TCP is built on, but without length limits o includes an additional closing handshake in-band that is designed to work in the presence of proxies and other intermediaries Other than that, WebSocket adds nothing. Basically it is intended to be as close to just exposing raw TCP to script as possible given the constraints of the Web. It's also designed in such a way that its servers can share a port with HTTP servers, by having its handshake be a valid HTTP Upgrade request. One could conceptually use other protocols to establish client-server messaging, but the intent of WebSockets is to provide a relatively simple protocol that can coexist with HTTP and deployed HTTP infrastructure (such as proxies) and that is as close to TCP as is safe for use with such infrastructure given security considerations, with targeted additions to simplify usage and keep simple things simple (such as the addition of message semantics).

When we use a GraphQL API there are two kinds of errors we may encounter: Network Errors and GraphQL Errors from the API. Since it's common to encounter either of them, there's a CombinedError class that can hold and abstract either.

A class adds a layer of abstraction, which makes the component API and its inner workings less clear.

The Internet, an immeasurably powerful computing system, is subsuming most of our other intellectual technologies. It’s becoming our map and our clock, our printing press and our typewriter, our calculator and our telephone, and our radio and TV.

Components are the core of MJML. A component is an abstraction of a more complex email-responsive HTML layout. It exposes attributes, enabling you to interact with the final component visual aspect.

MJML has been designed with responsiveness in mind. The abstraction it offers guarantee you to always be up-to-date with the industry practices and responsive. Email clients update their specs and requirements regularly, but we geek about that stuff - we’ll stay on top of it so you can spend less time reading up on latest email client updates and more time designing beautiful email.

I’m proposing that writing those tests from the perspective of specifying the behaviors that we want to create is a highly valuable way of writing tests because it drives us to think at the right level of abstraction for creating behavioral tests and that allow us the freedom to refactor our code without breaking it

I am a big advocate of having a complete test base and even erring on the side of caution when it comes to quality engineering and software validation but that is not what we’re talking about here. What we’re talking about here are the tests that we write when we’re doing test-first development and I’m proposing that writing those tests from the perspective of specifying the behaviors that we want to create is a highly valuable way of writing tests because it drives us to think at the right level of abstraction for creating behavioral tests and that allow us the freedom to refactor our code without breaking it.

Having an understanding of higher level abstractions, such as tasks, activities and the historical code path taken, its debugging trace is much closer to how you, as an engineer, think about your code.

Please note that this is a higher-level debugging tool that does not confront you with a 200-lines stack trace the way Ruby does it, but pinpoints the exceptional code and locates the problem on a task level. This is possible due to you structuring code into higher abstractions, tasks and activities.

While you could nest an activity into another manually, the Subprocess macro will come in handy.

The Track() function will snap the output to the next task that is “magnetic to” the track’s semantic.

The entire framework is based on small, clean Ruby structures that can be executed programmatically.

While you could program this little piece of logic and flow yourself using a bunch of Ruby methods along with a considerable amount of ifs and elses, and maybe elsif, if you’re feeling fancy, a Trailblazer activity provides you a simple API for creating such flow without having to write and maintain any control code. It is an abstraction.

However, some people think these solutions are hacks and the problem reveals a missing abstraction.

Each of the programming language generations aims to provide a higher level of abstraction of the internal computer hardware details, making the language more programmer-friendly, powerful, and versatile.

The adapter is where authentication, policy checks, and eventually your domain logic happen. All termini of the protocol’s activity are standardized end events - that’s how protocol and adapter communicate.

An endpoint links your routing with your business code. The idea is that your controllers are pure HTTP routers, calling the respective endpoint for each action. From there, the endpoint takes over, handles authentication, policies, executing the domain code, interpreting the result, and providing hooks to render a response.

Trailblazer extends the conventional MVC stack in Rails. Keep in mind that adding layers doesn't necessarily mean adding more code and complexity. The opposite is the case: Controller, view and model become lean endpoints for HTTP, rendering and persistence. Redundant code gets eliminated by putting very little application code into the right layer.

Trailblazer is no "complex web of objects and indirection". It solves many problems that have been around for years with a cleanly layered architecture.

Svelte components are a thin layer over the DOM and naturally expose the web platform. Coding in Svelte feels like I’m moving with the grain of the web.

Stores are such an amazing abstraction.

Declarative programming is an enabler of abstraction. Imperative programming is an inhibitor of abstraction. Declarative programming allows you to say “I want this and I don’t care how I get it” while imperative programming requires you to define each and every step.

but the design pattern is so simple that it takes hardly any effort to implement it on any existing reducer, so I rejected abstraction for abstraction's sake.

virtual-dom exposes a set of objects designed for representing DOM nodes. A "Document Object Model Model" might seem like a strange term, but it is exactly that. It's a native JavaScript tree structure that represents a native DOM node tree.

Generating engine-specific code from a DSL (HTML in this case) seems like the right abstraction.

Alfred Korzybski remarked that "the map is not the territory" and that "the word is not the thing", encapsulating his view that an abstraction derived from something, or a reaction to it, is not the thing itself.

The map–territory relation describes the relationship between an object and a representation of that object, as in the relation between a geographical territory and a map of it.

"All non-trivial abstractions, to some degree, are leaky" —Joel Spolsky

I used them a bit and realized almost immediately they felt like a leaky abstraction.

Transparent debugging: a <div> is just a div.

There is no reason material-ui can't create a better abstraction on top of the one provided by React itself though.

It is an append-only, totally-ordered sequence of records ordered by time.

As Sebastian Markbage pointed out, no abstraction is superior to wrong abstractions. We are providing low-level components to maximize composition capabilities.

It's much easier to recover from no abstraction than the wrong abstraction.

investigates

It is far better to grasp the universe as it really is than to persist in delusion, however satisfying and reassuring.

Civilization advances by extending the number of important operations we can perform without thinking about them.

Week 3 (Jan 27) - Tasks - Ch 3 Discuss the strengths and limitations of vis tools that are for a specific purpose and those that are general. Distinguish among the three levels of actions in the task abstraction framework. Given a visualization, identify the actions the vis allows and the targets of those actions. Transform domain-specific tasks into the task abstraction framework.

The hard part is teaching the consequences of each choice.

As a "rational" being, he now places his behavior under the control of abstractions.