4,474 karma · joined September 28, 2012
I hope the spam filter will respect it!
You may twist the language to say that they are generating a list of validations and errors, but even then it's definitely a different use case than merely creating new items.
It is not. Symbolic, deductive reasoning engines have the same claim to being old-school AI as predictive statistic models.
To do serious harm or have broad social control requires concentrating that power with an infrastructure that a small group does not have, it requires coordinating the resources of a broad social base. And at that point the incentives to use them are affected by the needs of many people.
This will make feasible to train models at least as good as the current batch (though probably the big players will use those same optimizations to create much better large models).
(*) (Not just the processes in the program, but also processes in the company needed to find out what to do and how to do it).
This leads to organic growth, which can overcome problems caused by an upfront design that goes bad, because it couldn't have planned in advance every problem it will face in the future. Systems Design is all about adapting the system to changes in its environment. Learn about the Viable Systems Model for a mental framework on what to look for.
I've only been able to connect it right after a fresh install, but after I reboot it doesn't see the phone anymore.
Is your experience better?
True, but unfortunately, rational thought is heavily influenced by emotions.
You are much more likely to accept some cognitive dissonances if the reasoning is caused by someone you trust, like, or admire.
Heavy thinkers are not immune to that, they just produce much more elaborate justifications.
You make sense of the world based on the sources you trust, and that trust is created gregariously by learning to rely on what your peers are sharing as trustworthy. The time and effort needed is shared with the group, and the resulting wisdom of the crowds filters out the most outrageous messages from the outside, developing a 'groupthink' that establishes a consensus of what is "common sense" for the group.
However, someone with the power to broadcast messages to the whole group can overcome that group processing, and sway the whole group to a different way of thinking.
By the speed of light at which messages are transmitted.
If you're building an operating system or a software platform, to for it; the robustness will pay for itself in time to fix hard-to-find errors.
But if you're iterating fast to find out what the program should be about to begin with, use a prototype-friendly language instead. With garbage collection.
Actually yes :-) I agree that the original vision of computing pioneers about "augmenting the human intellect" has yet to become reality, and the industry has been entrenched in a local minimum derived from the very early engineering practices. But all that is finally changing really fast.
Computation started at the Jacquard loom, so engineers have a tradition of seeing it as a machine crunching patterns.
But computers science, just like math, is a language so its deeply grounded in semantics. And semantics grow and evolve from the actions of each individual speaker, without a central processing unit controlling the process, so "organic" is a good way to describe it.
I'd say the recent data analysis tools based on notebooks and data lakes satisfy those requirements. A library like Pandas provides the cube programming model of data dimensions, a column-oriented database like Hadoop gives you efficient storage, and a Jupyter notebook is the user-friendly GUI.
It's certainly more complex than a spreadsheet, but the code parts may be encapsulated to not scare your users.
This is the construct used to program the spreadsheet's reactive behavior, after all. You could think of users creating spreadsheet formulas as declaring a pipeline at runtime between two datasets, the origin range and the target range.
What is missing is a way to create "spreadsheet functions" among different applications. Online computational notebooks a la Jupyter are almost there, but they still need to share the same runtime kernel to transfer data between different books.
A combination of notebooks and web hooks should do the trick, methinks, but it needs someone to assemble this brittle system into a robust product.
SQL lives on because it makes database storage extremely efficient, not because developers enjoy switching context to an entirely different programming language and runtime environment. That they have to use it doesn't mean they have to like using it.
However, it lacks the flexibility of a true dataflow model. They incorporated the full model into the Power Pivot plugin, and later migrated it to a standalone app as Power BI. It's a reasonably complete paradigm, but much less well-known than the spreadsheet.
I'm working on that exactly - I have several conceptual designs for presentation and interaction, that's where my wit concept comes from as an abstraction to represent cells in the reactive graph, which can be seen either as an array or as a single cell with a label and a prototypic value. Once you liberate the concept from the 2D grid, dependencies between variables create lots of interesting navigation and presentation problems and expanded possibilities.
Unfortunately I don't have much time for side projects and my programming skills are a bit rusty, so I haven't advanced much in terms of actual implementation. Moreover, my 'universal' requirement of having it available as a system-wide background service would take a lot of work :-(
You nailed it, it's a spreadsheet - but one that doesn't constraint all data to live on the same application window, but could access and transform it throughout the whole system - just like copy/paste can transfer data from one program to another, where it can be transformed with a different toolset.
Copy/paste is the most fundamental tool in the toolbox of the end user, since it's the only universal* way to transfer data between apps without accessing an API programmatically, so I think it's undeservedly neglected as a tool to build real life practical workflows.
Incidentally, spreadsheets are one of the most versatile and successful End-User Development tools, allowing users to build information systems tailored to their business purposes. A system combining those design capabilities with the flexibility of building system-wide workflows could transcend the current model of siloed apps.
* Intents on mobile devices are similar, but they are not universal - many times the app to which you want to transfer data is not recognized as a valid target for the shared data.
The true minimum meaningful computation is probably the lambda function, anyway.
That's what PL/SQL and T-SQL basically are. They work, but they have a somewhat weird programming model, halfway between programming and declarative sql but being neither, with table cursors and stateful SQL queries.
And of course, their scope is limited to interacting with the database itself, not the outer world.
However, the software part of the machines is made of the same material as the data, so they are much closer to what current programming languages seem to imply.
It is natural that they tend to converge, especially in Lisp-like languages, into a type of program where the structure has code and data intermingled, which organically co-evolve in the directions in which problem solving takes it.
Instead of a machine with a processing pipeline, a closer metaphor might be the phloem of plants, the living cells that transport food, and which form part of the plant's structure and grow along with it.
(BTW I've coined a name for that kind of self-rendered cells, processed in place as collections of data sharing the same structure; I call them 'wits' - as in, the minimum unit of meaning; in parallel to bits as the minimum unit of information. And if you look closely, you'll begin to see that a lot of modern programming systems have them everywhere. So you may want to use this term 'a wit' to describe the concept explained in the article.)
> A database introduces a different data model - I have to translate between database data-types and my programming languages native data-types.
The key concept is explained in this sentence in the article. It doesn't matter how difficult or simple it is; the problem is that it's a different model, so it creates translation inefficiencies and makes it more difficult to reason about.
The object-relational impedance mismatch is a known problem; having data in one place and format, accessed through a single programming model will typically be easier than a separate service with a different language and model, no matter how efficient.