Invitation: https://apass.be/databases
Download texts: https://cloud.constantvzw.org/s/eGmApCmrlAWSA2l
https://pad.constantvzw.org/p/apass.databases

http://possiblebodies.constantvzw.org/mondayreading/ apass mirror

http://possiblebodies.constantvzw.org/phpmyadmin/

https://www.phpmyadmin.net/


site: http://possiblebodies.constantvzw.org/mondayreading/
database: http://possiblebodies.constantvzw.org/phpmyadmin  
decoder: https://www.web2generators.com/html-based-tools/online-html-entities-encoder-and-decoder


Introduction Sina

my old background (in computer sciences) (how Sina learned/learns):
- www.joelonsoftware.com (Joel Spolsky runs a company which sells bug databases, "FogBugz") - found Stackoverflow: rigid answers to all questions
- http://wiki.c2.com/ Peculiar writing and thinking about programming. Interesting metaphors and humor. > http://wiki.c2.com/?WikiSquatting
- "Structure and Interpretation of Computer Programs" http://libgen.io/book/index.php?md5=F8008C48DE93647FCB8A4B3F9C6BAB7C
Alchemy meets programming. Abstraction and modularity.

Computer science studies: Learning to draw boundaries between active and passive data.
Variables and operations in Javascript: What is considered a process and what is a variable.
Some languages do not make that distinction (something operates on something else).
Learning to make the distinctions on the problems you want to solve.

Q: is this how we understand mathematics?
A: In some parts, but not always. 

"real world problems" (are there unreal problems? real solutions? unreal solutions?)

Q: Why is process different from a variable? Something is doing something to something else. 

The assumption is that the distinctions are made according to certain problems, where modularity + efficiency are desirable.
Modularity and efficiency = separation of work/divisions of tasks

usually the object is separate in the database -- object oriented view

decomposing the world into computational objects.
"technique of isolation"

Data and control are not ontology separate

Q: Where does the need come to use numbers
A: Efficiency, history of computing, hardware 

What does a text do?
To make text operate in computers, you need to translate into binary.

2 dimensional matrix, many formats to export in

There is a relation to archive -- a grammar of memory/knowledge

The table as a structure -- it links to the structure of computers/hardware.

RAM -- random access -- you can access from any point/at any moment


From census to big data
"there were no young people before the 2nd world war"
appearance of lifestyle

census producing a body - has a limited reach. Big data cqrrelation has another depth/precision/diffraction. Who is producing this population? Not just government, mainly markets. Consumer = user = citizen melt

slip of analogies: what is intelligence? is it like having multiple at hand?
Predicting human behaviour - von Neumann

from the beginning: link between the predictable human and the predictable computer

different intelligences -- artificial intelligence "it can make decisions"
how to distinguish living intelligence from machine intelligence?
What is intelligence :-P

What is the moment we can give a gun to a robot?
Giving agency to things

is this the same as the difference between process and data?
a lot of issues are embedded in the mentality of engineering and how the discipline defines a program.

"it is exactly like human brain dead"

computational process

abstract beings (processes*) manipulate other abstract things (data*)
--> a pattern of rules (program*)

programming: *metalinguistic abstraction* [--> engineering design] : building a mini-language to express a problem, using a fixed computer programming language (on a given hardware) to construct a new language that enables describing (and hence to think) the problem --> using:
- primitives means of combination
- primitives means of abstraction
--> representation of data and control (<~~ individual bits of storage and primitive machine instructions)
+ using the given hardware to erect systems/utilities for the efficient implementation of resource-limited computations


distinction between "passive" data and "active" processes =/= Lisp
(procedures and data are just abstractions, they are not really distinct) --> programming language should have methods for combining and abstracting procedures and data

means of abstraction: by which compound elements can be named and manipulated as units


modularity --> localized part of the system
<== perception of the system
- objective: viewing a large system as a collection of distinct objects --> concerned with how a computational object can change and yet maintain its identity
- streamous: information that flow in the system --> delayed evaluation

(for example:) a bank account: has state in that the answer to the question "Can I withdraw $100?" depends upon the history of deposit and withdrawal transactions

object decomposed into computational objects (each with their own time-varying local state variables) --> model

object programming: model real-world objects with local state by computational objects with local variables --> identify time variation in the real world with time variation in the computer --> implement the time variation of the states of the model objects in the computer with assignments to the local variables of the model objects
--X--> (how?) model a time function

stream: delayed (infinite) list

stream programming:
- different abstractions such as: map, filter, accumulate,
- transformations of lists
- sequence manipulations without incurring the costs of manipulating sequences as lists
- tadriji incremental computation


random: statistical properties of uniform distribution


object-orientation: polymorphic abstract data types =/= relational data model



Building Abstractions with Data

how to use: 
- primitive data (numbers)
- primitive operations (arithmetic operations)

building abstractions by combining data objects to form compound data <==> *to increase the modularity* of (our) designs ==> to increase/enhance the expressive power of our language

data abstraction:
*technique of isolating* (the parts of a program that deal with) how data objects are 'represented' from (the parts of a program that deal with) how data objects are 'used'

versioning
garbage collection









SELECT column_name(s)
FROM table_name
WHERE column_1 = value_1
AND column_2 = value_2;


CREATE TABLE table_name (column_1 datatype, column_2 datatype, column_3 datatype);

DELETE FROM table_name WHERE some_column = some_value;

INSERT INTO table_name (column_1, column_2, column_3) VALUES (value_1, 'value_2', value_3);





WITH RECURSIVE t(n) AS (
  VALUES (1)
UNION ALL
  SELECT n+1 FROM t WHERE n < 100
)
SELECT sum(n) FROM t;




WITH RECURSIVE included(component, part, quant) AS (
  SELECT component, part, quant FROM parts WHERE part = partID
UNION ALL
  SELECT p.component, p.part, p.quant
  FROM included pr, parts p
  WHERE p.part = pr.component
)
SELECT component, SUM(quant) as total_quantity
FROM included
GROUP BY component




















===========


Look at the dump from apass.be -- phpmyadmin?

What kind of interface is phpmyadmin
how are they built, functioning?

"programmers do not mess around with databases"







Scott Calvert -- even though object of study missing it is interesting



my old background (in computer sciences):
-www.joelonsoftware.com(Joel Spolsky runs a company which sells bug databases, "FogBugz")
- wiki.c2.com
- "Structure and Interpretation of Computer Programs" 


computational process

abstract beings (processes*) manipulate other abstract things (data*)
--> a pattern of rules (program*)

programming: *metalinguistic abstraction* [--> engineering design] : building a mini-language to express a problem, using a fixed computer programming language (on a given hardware) to construct a new language that enables describing (and hence to think) the problem --> using:
- primitives means of combination
- primitives means of abstraction
--> representation of data and control (<~~ individual bits of storage and primitive machine instructions)
+ using the given hardware to erect systems/utilities for the efficient implementation of resource-limited computations


distinction between "passive" data and "active" processes =/= Lisp
(procedures and data are just abstractions, they are not really distinct) --> programming language should have methods for combining and abstracting procedures and data

means of abstraction: by which compound elements can be named and manipulated as units


modularity --> localized part of the system
<== perception of the system
- objective: viewing a large system as a collection of distinct objects --> concerned with how a computational object can change and yet maintain its identity
- streamous: information that flow in the system --> delayed evaluation

(for example a bank account: has state in that the answer to the question "Can I withdraw $100?" depends upon the history of deposit and withdrawal transactions

object decomposed into computational objects (each with their own time-varying local state variables) --> model

object programming: model real-world objects with local state by computational objects with local variables --> identify time variation in the real world with time variation in the computer --> implement the time variation of the states of the model objects in the computer with assignments to the local variables of the model objects
--X--> (how?) model a time function

stream: delayed (infinite) list

stream programming:
- different abstractions such as: map, filter, accumulate,
- transformations of lists
- sequence manipulations without incurring the costs of manipulating sequences as lists
- tadriji incremental computation


random: statistical properties of uniform distribution