04 décembre 2020: initial morning program based on https://github.com/TomHumphries/InfiniteCanvasWhiteboard 0 create zoom loops * 0 there is so much space, that one can hide messages in the vast infinity 05 décembre 2020: 0 échelle 0 double flèche 0 parcours 0 arbre 0 notation 0-20 : nb_questions = n(n-1)/2 = 190 06 décembre 2020: 0 Arrow: 0 "horizontal arrow" : 10 fois plus loin 0 "vertical arrow" : 10 fois plus grand 0 "oblique arrow" : itinéraire (ou mesure) 0 itinéraire: 0 select pointA, pointB 0 draw arrow 0 orientation automatique de la flèche représentant l'ordre de grandeur courant en fonction de la flèche "itinéraire" 0 find order of magnitude and "get there" (show the arrow with the "right size" wrt screen) 0 from question A to question B: 0 create line from A to B and follow it in the direction of the arrow till you meet the next exercise 0 warp 0 from question A,B and C to question D: 0 triangulate 0 PAUL's vision: deux calculs L'abscisse est la réponse à la question 1 L'ordonnée est la réponse à la question 2 Abscisse et ordonnée par rapport au _repère courant_ avec un repérage "A1": on peut utiliser les préfixes comme indicateur de colonne tableau d'un peintre: fractale 11 décembre 2020: **0 import pdf 0 import embedded text as text, embedded image as image, ... OR 0 import pdf as png file with big width and height 0 workflow : 0 import mind map pdf 0 enrich the map by adding 0 neurohandle images : a goat, a lion, 0 associate biome to zoomLevel 0 content inside those neurohandles : exercices, problems, figures... * 0 hardcore : zoom trap : when zooming out, user does not get to previous scene, but sees zoomed out current scene 14 Décembre 2020: **Z-PUZZLE: bring object back to its corresponding slot (object can be extended, shrinked) 0 click and scroll to change size 0 long click| long press to lock obj selection 15 Décembre 2020: **Z-Puzzle avec des carrés : inscrire un nombre dans le carré, avec une double flèche pour indiquer la longueur du côté, _à l'intérieur_ 0 Z-Puzzle Logo : write Z-Puzzle with squares of different sizes 0 WOW effects : 0 puzzle pieces are on a blue background : blue background is only a small (blue) part of a big piece of the puzzle 0 puzzle pieces are on a table : the table is a part of a big piece of the puzzle 16 Décembre 2020: 0 puzzle creation : 0 image split 0 create puzzle piece using cutting path 0 commencer par un petit Z-puzzle à 4 pièces : initialisation : toutes les pièces sont carrés, de la même taille, de couleur différentes avec un numéro différent (1,2,3 ou 4) le slot pour le numéro 1 est très grand, on voit dans la vue initiale un petit morceau de bordure de 1 le slot pour le numéro 2 est de taille initiale le slot pour le numéro 3 est petit mais on peut y arriver avec un resize classique le slot pour le numéro quatre est très petit 17 décembre 2020: idées: 0 movable/unmovable objects : bg objects vs interaction objects 0 z-index should (/may) decrease when object gets bigger (imagine an image of the universe which was contained in a house window) 0 group/ungroup when z-scrolling inner element 0 inno_further: 0 double object: {front layer, back layer} front layer displayed when scale <= x back layer displayed when scale > x example: closed window / open window => 0 calendrier de l'avent 0 living object: front layer may change if something has been done "inside" object (i.e. when scale > x) 0 edu: 0 numbers fractal : [ 9 ] [0][1][2][3][4][5][6][7][8][9] etc. il y a le zero-level : avec [0,][1,][2,][3,][4,][5,][6,][7,][8,][9,] 0 10^n rectangles _____________________________________________________________________________________________________ [ 10^n ] ----------------------------------------------------------------------------------------------------- __________ [10^(n-1)] ---------- 0 double layer numbers : front [ ] [ 9 ] [ ] back [ 1 2 3 ] [ 4 5 6 ] [ 7 8 9 ] 19 décembre 2020: * 0 remanent points : center point for rotation is displayed then fades when rotation is done * 0 complex animations : 0 X-wing : zoom-in + centered rotate 0 spiral staircase : zoom-in + non-centered rotate ** 0 animated objects : endless spinning wheel, endless translation * 0 user could force software to adopt moving object's referential ** 0 temporal active objects : 0 calendrier de l'avent : mettre un timer dans le programme pour que les fenêtres (==double object) ne soit "ouvrables"(==pénétrables) que lorsque le jour est passé 0 devoir maison : le sujet n'est plus accessible après 0 interro : time frames 0 edu: three sectors : course material plane is divided: green sector : easy : for everyone orange sector : moderate : for almost everyone black sector : serious : for strong pupils students can rotate the wheel to access to stronger content 0 un z-puzzle simple: des carrés de couleur 0 z-puzzle with reflection : negative scale 0 snapping: 0 move 0 resize 0 rotate 0 what is the right snapping percentage ? 20 décembre 2020: edu: bien affcher la taille et la position du rectangle d'observation zpuzzle: 0 droite graduée et profil affine (carré de différentes tailles) un humain près du 1 (1 mètre) 0 z-puzzle : telephone 7 8 9 4 [] 6 1 2 3 0 colored squares with dimensions 0 format : factor x power of ten [---------] [<------->] [ 3,8 ] [ x ] [ 10^(-2) ] [_________] 0 need _reference_ arrow 0 more complex: no reference is shown : pupil has to use relative sizes to solve puzzle ** z-scroll, r-scroll, etc. is only about placing the selected object in _a different ("hovering") layer_, and then dropping it in the original layer maybe code would be cleaner if it was done this way * => hovering layer is the player's backpack (multiple objects could travel along) * ((double puzzle: recto / verso * basic exercice course: exercise n: - image (funny) - statement (less funny ^^) - answer text field: on right answer : open exercise n+1 door etc. ** OUR WEBSITE : students' have a website consisting of an infinishute every student can have its own miniverse in the infinite vastness * animation: pov path : from pov1 to pov2 to pov3 to pov4 etc. edu: séquence de mémorisation *[ Keyboard shortcuts: F: Rect F for fabric Shift F: Toggle object.reactor on/off T: Text Shift T: Tag X: Point "cross" (if nothing is selected) OR: sameHomeScaleClone (if something is selected) Shift X: geminiShade D: Droite (if nothing is selected) Decoration Begin/End (if something is selected) Q: Circle Q looks like O W/N: Polyline W/N is a polyline M: Measurement arrow (depends on context orientation) ? + M: greatest length ? + M: smallest length G: Group while supervessel cargoing: KeyG: operateOnActiveObject__gemini (clone + geminiLink) KeyG + Alt: operateOnActiveObject__echo (clone + echoLink) B: Ungroup "Break group" (special: toggle .isMobile of selected composite part) Shift G: Compose Shift Alt G: Compose (special) (je ne sais plus à quoi je pensais quand j'ai écrit ça...) Shift ² G: Compose: create equation Shift B: Decompose Alt G: Link Alt B: Unlink Shift + move: (special: force move of selected composite part (== make as if it were .isMobile == true)) "!": Show object types (KeyDown (toggle)) (on peut voir (via une bordure spéciale par exemple) les composites, les groupes, les objets normaux, etc.) ",": Split active object (==object in supervessel, be it currently held (mousedown) or simply selected) ";": Join active objects (==objects in supervessel) "_": Toggle icObj.isTouchable A: zoom out (KeyDown (timeout)) "Away" Z: zoom in (KeyDown (timeout)) Shift A: zoom out (/10) Shift Z: zoom in (x10) R: Rotate (KeyDown (toggle)) C: Color (KeyDown (toggle)) ² + C : pick color at cursor (canvas "global") Shift + ² + C : pick color at cursor (canvas fObj in front) ?unknown shortcut?: pick color at cursor (document global) V: Opacity (KeyDown (toggle)) W: StrokeWidth (KeyDown (toggle)) "²": FreeDrawing (KeyDown (toggle)) Shift "²": FreeDrawing group (group parts) : Evanescent FreeDrawing : Sticky FreeDrawing Alt "²": cosmetic FreeDrawing (== (.isCosmetic == true)) maybe "isCosmetic" should have a reserved keyDownToggle, in order to spawn objects _of any type_ with .isCosmetic true or false <: Category (KeyDown (toggle)) (this will allow: selectNextObject(activeCategory), selectAllObjects(activeCategory)...) &/1: Cursor (KeyDown (toggle)) (this will allow: click on obj VS select obj and then move it) X: Context orientation (KeyDown (toggle)) (horizontal, vertical, ltrb diagonal, rtlb diagonal) "^": Landing stage (KeyDown toggle): new objects spawn in landing stage (object or infiniteCanvas, or infiniteCanvas.layerX)) H: Homescale for new objects (KeyUp (toggle)) Shift H: save homeScale to preset.homeScale CTRL + 0: move to origin pov digit move to pov Y: Z-Puzzle slot P: Create Platform Shift P: Create ProtoSlot E : Activate (maybe mouse click is more intuitive) E(long press): toggle reactive version S: Save all (when nothing held) Toggle Sticky Release (when something held) Shift S: save selection L: Load Esc: cancel current behavior (for example Sticky Release) ← ↑ → ↓: move active selection +/-: "Time" control: accelerate, slow down (KeyDown (toggle) == as in game consoles emulators) debug: Toggle Supervessel (KeyUp (toggle)) Keyboard+Mouse: rightMouseDown + zoomIn/Out keeps screenRect centered on object while zoomingIn/Out Shift + scale via side controls: unitCloneScale ET LES GAUCHERS ALORS ?... *] 1 keyZ: zoom-in to cursor / zoom-out "KeyW" : get aWay "KeyE" : "Enter"/"Explore" : zoom-in 1 keyDownTimeout 0 keyDownTimeout VS keyDown: complex mgmt to only zoom once when key is "simply" down-up'd (== ? pressed ?) ** => problem "vanishes" when timeout delay is 17 ms (== "small enough") ** sometimes it all adds up nicely (==resulting feature): rightMouseDown + zoomIn/Out keeps screenRect centered on object (this is a nice feature which should be preserved) * antialias "pixel fight" when zoomingIn is like Heisenberg's principle, it's more and more shaking ** edu: le petit poucet de Gulliver : semer des petits cailloux à chaque niveau de zoom pour ne pas se perdre => les amener à comprendre la notation décimale ** on "remonte" un nombre comme par exemple 14758,1654873 (on part du niveau de zoom) ** avoir un affichage spécifique pour les "zéros facultatifs" (que ce soient ceux qui sont à gauche ou à droite de la virgule) 0 affichage additif (on affiche le nombre sous la forme sigma(ai x 10^i)) 0 representations: 0 square representation : I don't like this one because it may override what we try to teach regarding areas 1 rectangle representation : better ** 1 "representation 74" (xylophone representation) (width does not matter, only height matters) * 0 704 : write "0" when no column is filled 0 fill remaining space in black and write "0" when no column is filled * 0 add double arrow (as separator) : double arrow size depends on select number, to show that only height matters 0 show |10^ sector| on top of each xyloblock * 0 show addition of two number with this representation 0 two "lines" (is this possible ? (yes, if all towers have same height)) 0 abaccus way * 0 allow user to type number and draw corresponding representation => 0 exercise : type the number corresponding to the displayed representation 0 easy: 183,01 0 standard: 140 015,3 0 hard: 1 000 000,000 028 * 0 allow user to select rectangles and show corresponding number => 0 exercise : select rectangles to represent the number 157,005408 0 show "current number: ...." "target : ...." 0 negative numbers : upside down 0 show addition of positive and negative number 0 show sqrt(2) 0 square product of two xylos 0 show sqrt(2) * sqrt(2) 0 xylophone number char representation: small 1, bigger 2, even bigger 3 etc. * 0 representation "empire state building" : pile up all rectangles 0 with rectangles 0 with real-life objects rectangles 0 add corresponding power of ten square [10^] next to the xyloblock * 0 representation fallen skyscraper : empire state building goes horizontal 0 with rectangles 0 with real-life objects rectangles 0 animation: 0 from xylophone to empire state building 0 from empire state building to fallen skyscraper ** 0 Wow effect: la virgule tournée dont on ne comprend pas au départ la signification, revient dans le bon sens pour former l'écriture décimale du nombre (écriture décimale "pondérée") (0 representation "closest square puzzle" 0 sum of scientific notations (sigma(ai x 10^i)) 0 exponential-carried representation (logarithmic scaleX) 0 fractal path representation ("5,1 c'est un bonhomme et un petit poisson"): each square has BL = (0 ; 0) and BR = (10^ ; 0) 0 create "trailing part" only when "tower" becomes active (or else number of objects will grow exponentially) 0 représentation en aire: essayer de montrer un remplissage des xylorects de telle manière que le nombre représenté corresponde à la somme des aires 0 "vous avez débloqué un nouveau secteur : partie décimale" 0 colored numbers: * 0 zero could have transparent color ("container") * 0 non used level number could have very low opacity (but we could still seem them) * 0 write "0" when no column is filled 0 power of ten : patterns each power of ten has a characteristic filling pattern (example: hearts, diamonds, ... , cars, cells, ... ) pour la multiplication de deux nombres : représentation en surface d'un nombre : on prend arbitrairement un des deux comme 'multiplicateur' et l'autre comme la surface à multiplier attention : multiplier une surface par 2 : simplement prendre deux instances de la surface initiale et les accoler 0 mécanique de précision : trouver la pièce complémentaire *** zoom-bound freeDrawing text reading animation (== write smaller and smaller text using deep freeDrawing and then animate the diving/reading) 21 décembre 2020: une séance préparée pour 1 heure pour 24 élèves VS un programme pour x heures pour 10^n élèves * un nombre (fini), c'est un parcours (fini) sur une fractale. 0 show sqrt(2) * sqrt(2) 0 make it sexy 0 round corners 0 "this thing is living" animations * 0 raster and vector DUO: one window infiniteCanvas, the other paint.net : copy/paste images to and fro 0 applications: 0 une année de 4ème: 0 tangram cat : 0 translation only : * 0 unrotatable fObj 0 unscalable fObj 0 fixed scaleX|Y 0 fixed homeScale 0 une carte de mes voyages 0 C-puzzle ("create objects" puzzle) : "recrée avec des formes l'image suivante" ** icObj.type = "url" : open new tab on click 0 move to next exercise * icObj.type = "video" * icObj.type = "webcam" 0 ne pas vouloir trop en faire pour le moment, rester sur quelque chose de simple 22 décembre 2020: Internet exists : * 0 Z-puzzle : have players go find the puzzle pieces (==images to paste on canvas) on the Internet ** 0 CTRL-F on a webCanvasPage * object wells: click and drag on object well to get an instance 0 static 0 animated object wells : le triangle rectangle qui tire des carrés qui disparaissent dans un portail cicatrice, on peut attraper le carré au vol LES FAIRE FAIRE => il faut qu'ils utilisent l'éditeur à un moment donné * représenter l'espace mental alloué dans l'infiniteCanvas : FORTNITE en gros et Mathématiques en tout tout petit * le code informatique est lui aussi quelque chose de "moderne", dans le sens où il est porté par une fractale (à la différence du "plain text" (si on ne prend pas en compte les références littéraires ou culturelles)) * Le cours de la 4ème: at start of class, file is opened during class, content is edited at end of class, file is saved 23 décembre 2020: * La même chose avec les fractions : utiliser l'infinite canvas pour montrer les fractions 0 enchaînements alternés de découpages verticaux puis horizontaux etc. * "Nombres en boutons"(== xylophone, fractal rep, etc.)::Somme positive side is immutable : get to target number using only negative side buttons (target = negative + positive) * Probabilités avec les nombres en boutons de fabriquer le nombre N ? ** infiniteCanvas editor is a place for students to run algorithms by hand (? ideal sandbox ?) example: create Koch snowflake example: create Sierpinski's triangle exemple: trier un jeu de cartes... * skewing exists in fabric => easy parallelograms from square * Skewing allow easy creation of "big-to-small arrows" from standard arrows * le project, c'est peut-être augmenter la boîte à outils numériques des élèves : - Scratch - Geogebra - Tableur - Infinite Canvas Whiteboard * visualisation/manipulation des homothéties avec un object well et le zScroll Z-Puzzles sur les homothéties * icObj types: [ //primitive rect text circle //composite group (== anonymous composite) groupWithBgRect (bg rect will allow stroke and fill (== border and backgroundColor)) card doubleObject ] * z-puzzle : user must create group with objects ( zSlot only accepts group with particular properties) * workingHomeScale : this would allow easy drawing of architectural planes ** mScroll (est-ce que ça a la moindre utilité ?) ** light-sending (== eye-catching) objects : no matter what current infiniteCanvas.scale is, a star grows from object so that it is visible at current infiniteCanvas.scale ** marker objects (on revient au côté whiteboard): those objects are like the other canvas objects, but they are not designed to stay, they are here to ease explanations 0 toggle show marker objects 0 clear marker objects * animation: décollage de fusée * l'infiniteCanvas permet de matérialiser des expressions du genre "étudier en profondeur" ou "un savoir superficiel" * presentation : standard "infinite fall" story carrier: each story item is displayed on a square at zoom level n * dynamic fabric object which parts pop and destruct along with the current pov (follow the yellow road) (this way an infinite object (like an axis) still can be represented) 24 décembre 2020: * Lien entre le xylophone et les z-puzzles : La balance: target weight / current weight (peser une planète sur une balance, c'est irréaliste, mais bon...) ** paradrop: "updward" z-scroll(the only available) momentaneously changes object homeScale but object falls down to its natural homescale when released sparkle indicates where small object is (if user wants to remove it from the scale(==balance)) *edu: angle pas droit: glisser un éléphant dans l'espace intersticiel et ajouter un commentaire à côté "regarde, l'angle est tellement pas droit, qu'on a pu y ajouter un éléphant" ** student may ask for hint: sparkle (light-sender) Arrow indicator in HUD ("in this direction, there may be something useful") hide arrow indicator when user is "in the object surroundings" additionnal upward/downward arrow to avoid using too many sparkles ** Le multiplicateur : un objet est sélectionné l'utilisateur choisit le type de multiplication : longueurs ou aire un nouvel objet est créé selon la multiplication ** Le guide âne pour montrer les découpes de fractions * xylophone : 10^ zone : "nombre sélectionné dans cette zone" : donner plusieurs écritures exemples: 5 x 10^4 : 50 000 2 x 10^(-3) = 0,002 ** /!\ aux erreurs d'arrondi quand on demande à l'ordi de sommer tous les termes updateActiveNumber 0.7000000000000001 (when only "sharp 0.7" is active...) => use string type OR => use Math library ** Comment faire pour débugger quand il n'y aura plus de logs pour avoir la meilleure performance possible ? * zéro est un nombre comme les autres : créer une autre version du xylophone avec le zéro selectionnable et pas de toggle isActive sur les xylophone towers (le xylophone vanilla à un zéro "absence") ** xylo abaccus: manage temporary multiple active towers in xyloZone : show timer 3,2,1 and then resolve chaos and bring back order. This can involve cascade updates. ** il y a des problèmes que la civilisation se pose à elle-même : pourquoi avoir gardé le système de position des nombres de la droite vers la gauche alors que l'on lit de gauche à droite en occident ? parce que du coup, on se retrouve avec une droite graduée, qui va "dans le mauvais sens" **xyloSynth: user types number and xylo updates accordingly (though we can't see much with standard xylo) (exponential xylo will be more readable) * black is a strong color : black zero in xylophone catches the eye a lot, is it a good idea ? ** multiplication de deux segments colorés : utiliser des gradients pour former un damier _[___|___|___] segment3, couleur3 | | |_| à l'intérieur, chaque rectangle (ou carré en fait) est colorié avec un gradient de manière à former un damier (on voit n x m carrés, et on voit que leur couleur c'est un mélange de couleur_n et de couleur_m) | | [_| segment2, couleur2 25 décembre 2020: * xylophone: ? add sounds ? (en base 9 on peut faire do ré mi fa sol la si do) 0 ECRIRE EN GROS : ~ 5x homeScale *zPuzzle: piecewise hints: "la pièce n°2 se trouve au coordonées : x = ... y = ..." et la position courante est affichée dans le HUD ->> l'élève peut chercher à tatons ** all is there : everything on the same canvas (~The Witness) remarque: le xylophone prend déjà une bonne partie de la place ** metagame : stars: get all 20|120 stars (comme dans Mario) 3 stars for every minigame: easy, medium, hard (ces étoiles apparaissent dans un écrin de verre qu'on enlève en réussissant l'exercice) ** étoiles d'exploration : some starts are there for the taking metagame: completing exercise X gives a puzzle piece for completing exercise Y *** par exemple des xyloTowers ("touches de xylophone") pour pouvoir écrire des nombres qu'on ne pouvait pas écrire avant (ce qui fait le lien entre (z-)puzzle et xylophone (la xyloTower ne change pas de taille (pour ne pas trop perturber le joueur (au moins au début)))) ce qui ferait du xylophone un objet central, sur lequel le joueur reviendrait plusieurs fois, et qui donnerait au jeu une saveur à la The Witness (autrement dit, une saveur exceptionnelle) ou par exemple des xylozones incomplètes aussi, ou même des xylozones adjacentes collées entre-elles (tout un secteur de puissances) ou aussi des xylozones avec les xyloTowers qui sont pas mises dans le bon ordre et qu'il faut remettre dans l'ordre avant de pouvoir les utiliser (0 beautiful xyloZone : perroquet: oeil(zéro) et ailes(1-9) ** units converter : user types number and (unit_from; unit_to) and: 1. the two unit-bound xyloZones are highlighted, unit_from with red border and unit_to with green border for example 2. each xyloZonePerception has two lines : one for the number expressed in unit_from and the other in unit_to so user sees it's only a shift (when units are "scalar units") * ne pas réinventer la roue : https://mikemcl.github.io/decimal.js/ (javascript numbers have limited precision) ** separate 10+ mantissa numbers when writing string rep: separator |, or bracketing [] (instead of having to create symbols (we don't write A for 10, we write 10| or [10])) + write which base is used (cela va de soi) * remplacer le point de la notation anglo-saxone par la virgule ** toutes les zones ramenées à unitZone.homeScale: afficher des agrandissements/réductions des différentes zones (un truc avec des lignes à moitié diagonales) pour arriver à un affichage de la somme des composantes à homeScale == unitZone.homeScale * xylophone: fading optional zeros for decimal number : zero "inside" !!= zero "outside" (==optional) (concept mathémtique: chiffres significatifs) * xylophone: cadenas à code pour xyloShow: user inputs number via scrollable cylinders * 0 make xylophone dynamically infinite (destroy/create zones around current scale) *:'( 2D canvas does not allow non-parallel skewing (~"scale traversing" objects) => use a 3D library to have: -scale traversing arrows -"pov aware" objects (==orienting sprites (as in paper mario)) 26 décembre 2020: ***( un hyperlien, c'est juste un portail (dans le sens Portal) tous les portails de l'infiniteCanvas sont à sens unique (impossible de se retourner dans un espace 2D et aussi: un portail n'a pas d'épaisseur) * traverse portal while zScrolling (==while "carrying" object) * Build Empire State Building tower (ESB tower) with xyloTowers => * size-preserving z-scroll ** power fractals: squares 8 8 8 8 8 8 8 8 etc. 2 2 4 4 1 1 4 4 staircase 1 [1] [1] [2 2] [2 2] [4 4 4 4] [4 4 4 4] etc. ** 0 Flat xylophone 0 additions 0 multiplication: scale "multiplier xylophone" so that the result's area equals B times A's area flatXyloB * flatXyloA A-> [ 1 ] 2[ 1 ] 2[ 1 ] ^ | B *" en fait, y'a que des fractales partout, des conteneurs dans des conteneurs dans des conteneurs, etc. etc. etc. *" je suis pas idéaliste ; mes idées, je sais qu'elles sont réalisables. (et je le sais parce que "ça" a infusé en moi) *" l'infiniteCanvas, c'est juste un espace dimensionné pour notre discipline (autrement dit un espace infini) ** toutes ces fractales prennent beaucoup de place, si je pouvais mettre des canvas dans des doubleObjects, ce serait moins encombré, on serait plus à l'aise. Et ce serait davantage rangé. ça ferait comme les niveaux dans Mario64. *** OPEN YOUR MIND (== "the world from a slit" / "THIS IS UNKNOWN TERRITORY"): initially, the player can only only see a small (_yet infinite_) part of the canvas, because there is a slit and the rest is black and filled with "unknown territory" labels open your mind animation: move to slit pov and show user that the slit is growing to a new size (/mutating to a new shape ?) -idée de scène initiale: la caverne de Platon, et ensuite la personne se retourne (grosse animation, stupeur, mydriase etc.) * a universe in ceiling cat's left eye ** "eye in eye" sequence: reversed image in retina: someone looks to someone which looks to someone, etc. ** entire book in canvas ** entire books : the Library ** time picture frame tunnel: __________ |1940 | ______ | |1941 | | ... * 0 trouver un moyen de symboliser "cette pièce est/n'est pas z-scrollable (i.e. "cette pièce à une taille fixe")" ** z-puzzle: arbre de calcul interactif: targetNumber,currentNumber easy: pieces == numbers normal: pieces == operators hard : pieces == numbers & operators => need graph library ? https://github.com/anvaka/ngraph.fabric ** z-puzzle: remettre les noms d'objets au bon endroit étant données telles et telles propriétes exemple: ** pour le calcul mental: parcours avec un timer: il faut aller récupérer le trésor caché profond en entrant succesivement dans des portes. Si le joueur met trop de temps il est ejecté (zoom-out animation) jusqu'à la porte de départ. la zoom-out animation doit être un peu costaude à coder non ? en cas de succès : collecter automatiquement l'étoile pour ne pas frustrer le joueur qui avait réussi à la débloquer ? *[ mini game ideas so far: xylo_write xylo_read z-puzzle: classic (z-)puzzle: arbre de calcul (z-)puzzle: range les nombres dans l'ordre croissant (on peut donner une sorte d'indice en mettant un mini xylo la tête en bas pour les nombres négatifs) (z-)puzzle: geometry: object names z-puzzle: citizenship/society: remettre les choses à la bonne taille par exemple: on écrit en grand "MOI" et en petit "les autres", pour représenter l'individualisme on écrit en grand "DROITS" et en petit "devoirs", pour représenter l'oubli fréquent du lien entre les deux aspects de la loi le joueur doit rétablir l'équilibre, c'est-à-dire la même taille pour les deux objets timeout travel: standard (pour exercer la mémoire, genre "active l'interrupteur à côté de la mouche", "maintenant, active l'interrupteur à côté de Y") on timeout write "time expired" and "you hear a door closing" to warn player that they'll have to start again back from the start timeout travel: deeper and deeper: calcul mental c-puzzle: évaluer des expressions - priorités opératoires - nombres relatifs - expressions littérales s-puzzle: ??? P-puzzle: géométrie greenMouse Indiana's path bulletMouse bulletGolf wow-effects: a small part of a big piece is visible on the side of the screen piece already in slot but very very small slot hidden in piece big-picture: build numbers with only 1 to start with xylo recomposition (== (re)compose challenge input) zPuzzle zTraveler recomposition: to complete z-Puzzle, you have to 'activate'/'enable' all z-Travelers like the laser beams opening mountain top in The Witness there will be a "moutain top" sensation when all z-travelers recompose the mountain top challenge "complete by repairing": "pebbles in the shoe": conductive operator seems broken (reason is: super small operand is inside conductive area so that apparent binary operation is actually involving three operands) completing another challenge may give the location of this "~hidden" (pebble) operand player "repairs" the operator by moving the pebble out of conductive area This pebble could be of use somewhere else... familiarisation progressive avec les "objets concepts" (comme les symboles dans The Witness) unlocked challenges : diy: when puzzle is completed, it can set up a challenge dust off: when covering challenge is completed, it reveals the covered challenge multikey: when challenge is completed, the multikey that was used is unlocked and can be used elsewhere unlocked recomposition component: unlocked challenge piece: movable: standard piece unmovable: zTraveler (unmovable yet moving) R-Puzzle target may be a patchwork which turns into an operator when completed unlocked "skills": object wells: numbers operators (for example: a well that generates operator "+" puzzle pieces) geometric figures transformations: rotate machines: x10 /10 clone keyboard shortcuts: player gradually learns "new keyboard keys" unlocking always happens via the same artifact (see: xylo-unlock) unlocked areas: Alice system "horizontal" areas (à la The Witness) unlocked:indirect key: xylo-unlock: player successfully completes a greenMouse challenge, then a number is given to them and they have to type it via the xylophone to unlock next thing unlocked places: "open your mind" system canvas-container double object (an entire fresh canvas in your fridge or bedroom window) and portals to get back to "home canvas" " required" door locks once Z|S|C-puzzle is complete, it transforms into a doubleObject or a portal (castle door for example) password (or hint or directions) hidden behind puzzle (player has to dismantle it in order to see the message behind (==l'étoile des douze coups de midi)) geometrical puzzles inside number shapes ((construit un nombre 1 qui ait pour aire 1 ((construit un nombre 2 qui ait pour aire 2 co-challenges: challenges can only be solved by progressing alternatively in one and the other example: solving greenMouse challenge make sparkle appear(which indicates z-puzzle piece location) and putting piece in slot makes sparkle appear which indicates greenMouse challenge is renewed digitWell: a many-digit number can be transformed into nb_digits wells, each yielding the corresponding digit (exemple: de 7891, on pourra extraire [7] [8] [9] et [1]) on peut créer des co-challenges qui font évoluer le "nombre puits" au fur et à mesure (c'est prometteur mais il va falloir se prendre la tête pour faire un "level design" qui soit goûtu) tool ideas so far: xylo_show ESB scroller with 'scroll increment = f(scale)' pythagore_show (avec des carrés) photograph: take picture of current rect and create puzzle piece or icImage from it clone tool repaint tool: input slot, color parameter --> output slot common multiples grid le répartiteur: user creates a partition of a 100% box and can then drag any collection or number that will be divided into different output boxes with the right proportions area of numbers (2 has area 2, 123 has area 123 (1 has area 100, 2 has area 20 and 3 has area 3)) protractor redMouse calculator (a redMouse doesn't die when released anywhere) solution writer assistant: as in Scratch: writing a solution would involve selecting blocks and putting them together clock_simplifier: perform simplification of mathematical expression at each clock tick The Mirror: what happens on bottom screen happens in mirror on top screen, _in a different _representation system_ _ example: bottom screen: expressions // top screen: bag of numbers bottom screen: fractions // top screen: colored rectangles ('fractions for kids') Frac_add edu: slow building of year's z-puzzle by getting puzzle piece for each part of year's course when done (slow compositing) difficulty gradient: Say we want children to try a particular challenge type 20 times, first instance will be easy, then there will be a gradient of easy/medium/hard till the last instance which will be hard prevent bruteforcing by increasing nb_challenges_todo when bruteforcing is detected ]* * xylophone for hours/minutes/seconds: * pythagore_show: show squares (use same "reference square" in all three squares) * essayer un xylophone compact avec les chiffres en mode photo de classe (est-ce que ça va pas faire un peu abrupte ?) * once again: make it sexy 0 papier peint "pattern" sur les xylophoneTowers ** showing before dying : avoir un z-puzzle basique à montrer à Paul ** Hue(==anti-sparkle): object opacity getting stronger as we get closer trois parfums: glassPlaque: only scale matters, (x,y) doesn't matter Clameur: obj is "localized" around a particular(x,y,scale) ("nearer, we hear better") spook: it disappears when getting too close ** S-Puzzle: slot-only puzzle : user has to enter slot and complete task for slot to fill with completed state (typically, the slot becomes colorful, hence the name) ** C-puzzle: colorize puzzle: user has color palette and must color areas corresponding to number 27 décembre 2020: ** user created sparkles : SparkleMarker: - pour se repérer: "true"SparkleMarker - pour effectuer des mesures : l'outil mesure peut prendre en entrée des SparkleMarkers, ou créer des sparkleMarker ** edu: choix pédagogique pour les représentations: moi j'aime mon xylophone, mais d'autres préfèreront une autre représentation, libre à eux d'utiliser la représentation qui leur convient, étant donné qu'enseigner, c'est enseigner ce que l'on est. * save game state: some objects don't need to be saved (since they are generated automatically when page loads) *PAUL: un repère orthonormé pour chaque xyloZone, pourquoi pas, un seul axe en fait, l'axe important, l'axe des ordonnées avec 1 2 3 4 5 6 7 8 9 z-puzzle: slot avec 1.47 x 10^-3 qui fait écho au papier peint des xyloTowers * machine à x10, machine à /10 : un slot d'entrée et un slot de sortie ** écrire "taille normale: ..." et surtout _"agrandissement: ..."_ sur une zPièce pour bien montrer que ce n'est pas la taille normale de la pièce * tous les élèves évoluant sur le même canvas: quel intérêt ? (à part du showoff client-serveur) compétition: -dynamic leaderboard (ce serait une sorte de course, on pourrait repasser 1er, ou être maintenant 3ème etc.) coopération: se partager les tâches: ~escape game (il faudrait que les élèves commencent à des endroits différents) * photograph: take picture of current rect and create puzzle piece or icImage from it: this way user can create keyFrames to create a comic book page * geometric puzzle: overlapping slots: pieceX has pointA, pointB, pointC labels, pieceY has pointB and pointC and pointD labels, so we know where to put it wrt pieceX ** P-puzzle (==slotless puzzle, ==le bon vieux puzzle des familles): puzzle can only be completed by assembling adjacent pieces *res: _DK Wonders of Nature_, incredible source of beautiful natural objects 28 décembre 2020: NUIT HORRIBLE MAIS PROLIFIQUE * create portal KeyP: select from, select to * create canvas: a portal to another canvas * canvas link : move from any canvas to any canvas, example: triangle A <-> B <-> C et C <-> A "KeyBack": return to previous (/parent) canvas * ? web page as fabric object ? (this way I could include a Scratch page for example), ou bien la page de l'ENT * point and click a la Myst, from room to room: fake immersion with portal buttons (and back button) (actually, all frames are next to each other, but pov creates the immersion effect) ** Bubble sparkle (comme dans les bandes dessinées): "Hey!" ** PNJ: quêtes annexes: - remettre les poules dans l'enclos - Link(Zelda): je voudrais une épée plus grande ! "Merci, maintenant c'est moi qui ai la plus grosse." ** enemies: some enemies are wandering around and when they lock on player, scroll & move are locked until enemy is destroyed *( Level and Xp ? * Z-Memory: like a classic memory game but slots are big and small * mirrored xylophone (left) + ESB tower (center) + tower fall on graduations(right) * piano with sound for each piano key (base 8, do ré mi fa sol la si) * challenge is there but unreadable: stains (need to unlock wiper) blur (need to unlock glasses) ** PreviewSparkle: quand on veut embrasser d'un coup d'oeil des objets de taille très différentes * 728,4�32�001: show empty space or unknown character for missing xylozone digit * xkcd: put some mini characters here and there a la xkcd * Z-Puzzle::Tangram * NightVision/ThermalVision * Docteur Maboule * Z-Labyrinth => object is locked inside walls but can shrink/grow with Z-scroll to get to destination or to get out (the existence of a getout narrow passage is only blatant when zoomed): fabriquer un système de collision (fabriquer un système d'interrupteur et de portes qui s'ouvrent et se ferment (casse-tête) * canvas world::scale world: a world with gravity which weighs a collection of objects target weight: ... * Z-spook::telephone numpad (layerN is only visible for f(n)-)puzzle: color on color: hide piece on top of similar object texture (like the chameleon) ("la pièce marron est cachée dans le pelage du chien") * (color composer: compose color using R,G,B values ( (or using hexcode...)) * Angle-puzzle:telescope: user can set a precise angle (using arbitrary precision graduations) for the telescope and when the angle is the good one, a star can be fetched inside telescope's objective * L-puzzle: link puzzle: relier les points * Puzzles géométriques faisables/impossibles: faisables: avec un angle droit: Pythagore Triangle inscrit dans un cercle impossibles: avec un angle presque presque droit (il faut zoomer fort pour trouver pourquoi ça ne snappe pas) Pythagore Triangle inscrit dans un cercle ... **Z-scroll: trace fading animation (so that user sees than the piece is growing or shrinking (or keeping its size (for non z-scrollable objects))) * puzzle autour des fractions: Tablette de chocolat: 6 rangés de 4 carreaux (Mathieu) * Localization challenge: select point with coordinates (x,y) or (r, theta) many points are put near the target point to show user that they sometimes need precision and zoom in to discriminate * Le coin informatique: Algo-puzzle: user has to select to right operators to get to result operators: assignation == mutator == set evaluation == accessor = get * Make it visible: Addition: fusion de parcs à moutons Multiplication: des moutons avec des moutons à l'intérieur ou alors on peut dire que chaque mouton du parc A rêve du parc à moutons B, ce qui fait n x m moutons de rêvés en tout. * Calculator: missing keys: reassemble it before being able to use it 29 décembre 2020: 29, c'est déjà un peu plus beau de 28 * code chiffre/son: challenge: "712", il faut placer dans slot(=="sertir") un katana * comptage analogique: challenge: "150317": il faut sertir une pièce qui possède 150317 particules dessus challenge "3 jaune/4 rouge": il faut sertir une pièce avec 3 points jaunes et 4 carrés rouges challenge: "17": il y a écrit 17 en pointillisme mais il manque deux particules pour faire 17 (le slot est visible, mais subtilement) challenge "incomplete rippa: 4/?": double challenge: il y a un outerslot et un inner slot ** Revenir sur les puzzles: - soit parce qu'il y a encore des étoiles à récupérer Mécanique: correct is good, fast is better exemple: le joueur gagne une deuxième étoile en refaisant le z-puzzle en moins de 40 secondes cela permet de créer des joueurs qui maîtrisent bien le z-scroll, qui l'ont intégré - soit parce qu'on a trouvé la pièce pour l'indice correspondant (MonoZSlotChallenge) (au moment où on a trouvé la pièce, on sait exactement(et c'est vrai) où elle va) - soit parce que ça y est on a compris ce qu'il fallait faire (jusque là une(/les) pièce(s) qu'on pensait correspondre à l'indice ne donne(nt) rien: on s'est pris des râteaux) exemple typique: le comptage analogique: indice: "150317", pièce à trouver: une pièce qui contient 150317 particules le joueur a testé de mettre des objets qu'il pense faire 150317 mètres, de mettre une expression littérale dont le résultat donne peut-être 150317, mais sans succès on peut donner un indice au joueur en écrivant 150317 en pointillisme mais le mieux serait de faire ça plus tard remarque: les différentes écritures des nombres sont une mine d'or pour créer des challenges *[ Mécaniques de déroulement: { mécaniques: couple slot/pièce (SPCouple): une fois que la bonne pièce est snappé dans le slot, le slot s'entoure de vert pour indiquer que c'est bon duo indice et SPCouple (MonoZSlotChallenge) -l'indice est à côté du SPCouple: classic (outer hint) -le SPCouple est dans l'indice: (container hint) -l'indice est écrit dans le slot: (contained hint) -l'indice est écrit dans réparti dans le slot et dans la pièce: (complex contained hint) collection de MonoZSlotChallenges avec une logique propre: ZPuzzle containerSlot: un slot pour plusieurs pièces ("enclos à poules") "greenMouse" piece / vials: "trempez-la dans l'huile, trempez-la dans l'eau, ça fera un escargot tout chaud" (hold click and move around while held: piece mutates while held) this will allow user to keep focus, focus being almost captured by the holding down mouse button user won't have the possibility to insert a "how about sending a text message to Y ?"-step during the transformation sequence, because _mouse button is held down_. fragilePiece(=="fragile greenMouse piece"): => F-Puzzle 1.user clicks on piece well 2._while held_, piece can be mutated via mutationAreas (+1, /10, change color, etc.) (pièces forgées au fil des "trempages") 3.when piece is dropped: if piece is above a slot and corresponds to the slot criteria: piece is kept alive in the slot (slot is filled) in any other conditions: piece dies fragilePieceTemporarySlot: un avre de paix pour la fragile piece (qui doit peut-être être encore retravaillée), en attendant de rejoindre son slot de destination challenge resets when player has made too many attempts (prevent bruteforcing) FiniteWell: well will only yield n clones (no more) déroulement: it would be nice if every new mathematical topic could be introduced by a new puzzle type (this way the user is 'delighted', and could memorize the mathematical topic by remembering the puzzle type) en suivant cette logique: faire un challenge mélangeant topicA et topicB serait créer un challenge avec un puzzle mélange de topicA.puzzle et topicB.puzzle mutations: challenge complété devient: slot pièce challenge mutation complexe: "step challenge": collection de SPCouples complétés devient une pièce et le challenge "mère" mute également wandering around: montrer où sont les challenges: NAVI(Zelda) (c'est un objet complexe fabriqué à partir de Sparkle) déblocage: request: from player: player presses "give hint" button from game: le jeu demande qu'on donne un indice au joueur -à partir d'un certain temps -quand le jeu détecte que le joueur commence à être à la traîne par rapport au "peloton" les indices en eux-même: transformer un indice pour le rendre plus explicite (exemple: pointillisme pour le comptage analogique) montrer c'est où: sparkle HUD arrows les cailloux du petit poucet montrer un exemple de comment faut faire: solution "sèche" animation revisite: Z-puzzle disséminé do it faster now / do it real fast now color the world: colorier tous les 123 du jeu en rouge,vert,bleu débloque des étoiles (ou une seule étoile si on veut faire un challenge "road to 100% completion") the top-down edu principle: 1. nommer l'objet 2. rentrer dedans pour étudier ses propriétés challenges: autour du chiffrement: codage décodage induction: objets répétés et emplacement vide: il faut mettre un exemplaire de l'objet répété dans l'emplacement vide suites logiques: remplir l'emplacement du terme remplir l'emplacement du terme général suites logiques avec figures géométriques fonctions: expression graphique décoration: écrire des noms de mathématiciens autour des challenges (+ mettre la photo ?) exemples: Sloane pour les suites numériques Pascal pour le triangle de Pascal } *] ((je le mets histoire de dire, mais je mets pas d'étoile, et j'espère qu'on le mettra pas en place: put the right price on object (on dirait que la raison de pourquoi on l'a pas mis, c'est parce que ce n'est pas stable dans le temps, et on passerait vite à autre chose :)) **philosophie de la montagne(mathématique (ou tout autre discipline)): 1.reconnaître qu'elle est là, c'est-à-dire la rendre réelle : arrêter de passer au travers comme si elle n'était pas là. D'une certaine manière, la respecter. 2.Plus on la gravit, plus on peut redescendre en glissant (et prendre de plaisir ce faisant), on peut aussi maintenant faire des figures au dessus des endroits où l'on avait précédemment peiné avec les cordes et piolet et crampons. Une fois qu'on a déjà été une fois à l'altitude h, on peut prendre l'hélicoptère pour y revenir. 3.une fois qu'on est à l'aise avec un secteur, on peut aider les petits à monter, mais bien sûr, on ne peut pas leur faire prendre l'hélicoptère, sinon pour leur montrer ce qui les attend. (est-ce que ce serait pas quand même du gros spoil bien sale ?) 4.on peut toujours trouver du nouveau, même dans les secteurs les plus arpentés. ou une couche de neige réconfortante. ** pour les fractions: on pourra diviser par 1000: un rectangle devient 1000 petits rectangles combien de 'particules' le système peut-il supporter avant de crasher ? ** edu::pour les 'petits': unités, dixaines, centaines: demander à l'élève de construire 2,3,4,5,6,7,8,9,10 demander à l'élève de construire 20,30,40,50,60,70,80,90,100 demander à l'élève de construire 200,300,400,500,600,700,800,900,1000 ** bien afficher le fait que 200 contient des conteneurs qui contiennent des unités ** c'est rébarbatif mais une fois qu'ille l'a fait, normalement, ille commence à avoir une idée du principe des décimaux, et ensuite ille peut passer au xylophone (et placer les nombres qu'ille a construit dans le xylophone) * snapping: ? écouter la vitesse de la pièce ? representation system is nice: this way the slot could mutate a piece in a blink of a eye: 0 repaint a piece 0 change its background texture pattern 0 change its size 0 rotate the piece 90° clockwise 0 its nature 0 its behavior (activate or deactivate eventListener code) 0 more complex: change underlying fObj while held: fImage becomes fGroup for example ** relative number piece creation: F-puzzle on a un (ou plusieurs) nombre(s) de départ on a quelques opérateurs, _mais pas tous_ et on doit remplir les slots avec des nombres forgés au fil des "trempages" exemple: si on a 4 au départ, et que l'on veut fabriquer -10, on trempe la pièce dans "+1" puis dans "x(-2)" ** trempage::équation: même chose mais on part d'une équation ** trempage::inégalité: même chose mais on part d'une inégalité ** trempage::encadrement: même chose mais on part d'un encadrement **When you feel the concrete at the tip of your fingers, when you smell it, when you press your face over rough surface, you might have nice, _sharp_, "concrete-ideas". Otherwise, you might have "far perception-ideas" (which can be nice though, but are too often blurry on closer examination). on pourrait même se demander: qu'est-ce qu'on apprécie dans une incarnation ? l'idée qu'elle porte, avant tout ? ou plus simplement, son existence et par conséquent, son interaction avec nous ? (ENCORE UNE FOIS TU VAS TROP LOIN, CHERCHE PAS TROP A FAIRE LE MALIN, RESTE DANS LE BETON MON VIEUX. RAMENE TA FRAISE, JE VAIS TE FAIRE INTERAGIR AVEC UN SAC DE CIMENT. TU VERRAS SI LE POIDS DU SAC EST AVANT TOUT UNE IDEE.) Les concrete-ideas, elle se construisent progressivement, avec du concrete. Parfois ça se casse la gueule alors faut reprendre. Dans tous les cas, il faut avoir les mains dedans. * Ce qui fait peur, c'est quand on montre des bricolages à des gens qui sont pas du métier. (Toutes ces images complètement trafiquées...) La réalité, c'est un nez qui coule, c'est un gamin qui pleure. encore et encore et encore et encore des idées: prout est-ce qu'a un moment donné faut dire "stop, tant pis, allez vous faire voir dans un autre cerveau, je vous laisse passer, je vous retiens pas, la sortie c'est par là" ? onNewIdea((idea) => { //ignore }) tout le temps parler, tout le temps parler, tout le temps parler: prout et si on dansait ? et si on écoutait l'Autre ? * snapping: show that object will be snapped on release (==on drop) (so that user, being informed, chooses to drop it) * snapping: what would be nice would be to use the norm of a transformation matrix to settle threshold * snapping: new events: onSnapped, onUnsnapped * snapping: asymmetrical allowed input size range: 80% - 110% (pour privilégier la fabrication de pièces qui "rentrent") * on pourrait aussi habituer les élèves, qui savent déjà faire la conversion secondes/minutes/heures/jours/années/siècles/..., à faire la conversion mot/ligne/page/chapitre/livre/armoire/bibliothèque/... Comme mes élèves, "ils" n'ont rien demandé. Ils se fichent complètement de savoir si la grossesse a été difficile ou pas, de pourquoi j'ai pas avorté. Le rejeton est plutôt agréable ? Tant mieux. Mais personne ne lui a demandé de venir au monde. C'est très étrange, surtout quand on pense à l'attachement que l'on peut avoir pour sa voiture, ou sa planche de skate. C'est moins fun un magasin vide. * Plus on connaît de représentations, plus on se rapproche du backingObj. * pov: show active object * pov: show last action location (object may be deselected but get me to where I was when I last moved it) ** easyFill: _while held_, near enough to slot, object triggers onSnap(or 'onNearSlot', 'onNearEnough'), which leaves piece on slot, mutates held object (for example it can be a bottle of liquid, whose liquid has partially been transfered to the piece occupying slot), so we can continue filling, all in the same drag sequence. easyFill could be a simple "leave clone of held object in slot" ('hit and run') ** easyPaint: simple easyFill with color pieces ** bouton réinitialiser semble indispensable pour les challenges avec des effets irréversibles j'essaye de séparer ce qui relève du jeu et ce qui relève de l'éditeur: **icObj.snapped et icObj.type = "snapSlot" et icObj.type = "snapGrid" (si l'utilisateur veut une configuration de snap qui lui plaît mieux, il la fabrique lui même avec des snapSlot) **layoutBag: icObj.flowLayoutBag: icObjects dropped inside automatically arrange in a "top-left if able" manner et tous les autres layoutBags auquel on peut naturellement penser **snapSlot et layoutBag permettent à l'utilisateur de fabriquer des templates de présentation (==des dispositions dont on peut changer les images, les textes, etc., et montrer à l'utilisateur des variations sur un même leitmotiv visuel) **et du coup, on pourrait relier toutes les instances de dispositions entre elles de manière à pouvoir appliquer des modifs au template qui se répercuteraient sur toutes les instances. **presentation options: show/hide slots, show/hide layoutBags (c'est moins cracra de faire une présentation quand ils sont cachés) * res: _Help your kids with Math_ (goldmine) ** montrer un histogramme avec les nombres entiers pour pouvoir ensuite afficher les multiples et les multiples communs cela va demander une construction dynamique de l'histogramme *[ icObj.type = "dynamicObject" icObj.objectsInRect = (rect) => { return objects; } *] ** multiplication posée: highlight factors when hovering partial product ** addition de fractions: trouver un dénominateur commun avec une molette en dessous de chaque rectangle (mais attention, il faut pas que les challenge ressemblent trop à un cours de maths) ** machine à compter les petits carrés: la machine grogne quand il y a des carrés qui ne font pas la même taille dans son "enclos" d'input ** machine à mélanger, machine à démélanger (dilutions) ***SELF-CONTAINED EDITOR: when sending the file to personX, I send the object I want to send, and its editor so personX see the object and then edit it and send me back the new file, so I can see the updated object and edit it etc. this would require saving the file in .html, with an object part (json) and an editor part (html/js) https://stackoverflow.com/questions/30563157/edit-save-self-modifying-html-document-format-generated-html-javascript https://www.reddit.com/r/learnprogramming/comments/4hjz1z/how_can_javascript_in_html_self_modify_and/ https://github.com/gildas-lormeau/SingleFileZ https://github.com/gildas-lormeau/SingleFile *[ the dream: page.html (zip format) //facade pour Monsieur Toutlemonde lib/ //intérieur propre pour l'initié machin.js truc.js index.html data.json *] 30 décembre 2020: still ideas: à chaque fois je perds du temps à tout recopier, ma pauvre chérie. comment perdre une heure tous les matins. ** flow-machine: la machine déclenche automatiquement la fabrication quand elle a les ingrédients suffisants **flow-machine::object _fountain_: fountain = well + surrounding pool: when an object leaves the pool, machine automatically creates a new instance so that pool always keeps the same number of elements * machine:random number machine: cette machine renvoie un nombre au hasard * machine:random sample machine: cette machine renvoie un clone d'un élément au hazard du pool en input * machine:random order machine: cette machine renvoie une liste ordonnée aléatoirement à partir d'un pool en input * edu: il faut que les machines soit faciles à utiliser, et que les {drags and drop, snap, légère animation de fonctionnement} rendent la chose ludique (__"c'est simple en fait, regarde !"__) * challenge::chronology (dynamicConstruct timeScale needed) example of objects to place: cadillacs and dinosaurs * challenge::apple tree: the apple to get to is located on a certain branch of the tree. A code is written like 4568541. The idea is to remember the code and press start. Then the player controls an ant, at the foot of the tree, and at each 'crossroads', move to the right branch (first one is 4 for example, next 5 etc.). * challenge::homothety: select center and ratio (c'est une machine au fonctionnement un peu différent des autres machines ("à slots")) * challenge::factory: une succession de "flow-machines", bien connectées entre-elles, permet la fabrication d'un objet complexe exemple: l'usine à flocons: on part d'une forme simple et on arrive à des flocons (et même une succession random>homothety pour fabriquer des flocons de tailles différentes) ** challenge: find the operator (travailler l'induction): il y a une zone d'input, une zone "opérator" (slot dans lequel il faut mettre la bonne pièce), et une zone d'output user can try putting in _any input value_, and result automatically displays in output slot it's by compiling those (input,ouput) couples that user finally finds the (most probable) matching operator greenMouse and vials could be put close, so that input attempts can be done in one held mouse click * challenge: add parentheses (en fait ça va être assez hardcore à mettre en place je pense) * challenge: pixel draw puzzle piece (les amener à compter les carreaux) easy: grid has only "unit scale" precision graduations medium: grid has "unit to milli" precision graduations hard: grid has arbitrary precision graduations * challenge: line draw puzzle piece (les amener à comprendre que 1.97 en abscisses, c'est pas 2) line end points always snap to grid easy: grid has only "unit scale" precision graduations medium: grid has "unit to milli" precision graduations hard: grid has arbitrary precision graduations * bizarrerie : all same-mantissa xyloTowers leading to same world (portal (montre-t-on à l'utilisateur qu'il passe un portail ou laissons ça 'seamless' ?)) * "self-contained": append datetime to filename so that savedgames look like videogames saved games (you know, when you choose 'load game') * "self-contained":editable ==> password? empêcher les modifications par les petits malins: checksum is checksum written in self possible ? checksum in editor.js checksums everywhere :) *"self-contained":editable: tool to show edited parts pour que je puisse voir si un élève s'amuse à mettre des images de X dans le monde original (bah ouais, vu qu'elle peut être arbitrairement petite faut faire gaffe) * 9-puzzle with labyrinths: there is a frame for the 9 puzzle precising where start and end are * edu: amener les élèves à jouer au jeu tous les jours exemple de système: day streak star: pour récupérer l'étoile, il faut la recomposer. Chaque jour, la challenge completion donne une fraction d'étoile (un cinquième par exemple). Il faut donc réussir le challenge cinq jours de suite. * edu: nb max allowed errors: pour éviter que les élèves brute-forcent les exercices. (peut-être qu'il faut les laisser brute-forcer certains exos, que cette répétition peut être utile pédagogiquement, mais certainement pas tous.) ou alors on peut dire: easy: infinite nb of attempts medium: 3 errors allowed hard: no error allowed * edu: montre moi que tu as compris: 5 tentatives minium et un taux de réussite supérieur à 3/5, 4/5 ? de cette manière: on voit que l'élève a essayé et on voit qu'il a compris ou pas compris 0 statistiques sur chaque challenge ? * edu: challenge habillé VS challenge "nu" (==sans aucun texte) (si y'a trop de texte, on va se croire dans un bouquin de maths) * edu: outil pour analyser la progression de chaque élève * edu: timestamps for challenge completion to track cheaters and headless-followers * edu: tolérance: geometry: snap when close enough to answer * edu: mécanisme pour augmenter la difficulté: montrer moins de choses, laisser un peu de calcul mental se faire par exemple avec la machine à homothétie: ne pas montrer la figure image intermédiaire quand on bouge le centre de l'homothétie. Indiquer seulement quand c'est bon. (pareil il faudra un peu de snapping dans ce cas, de _tolérance_). * fractal labyrinth: some sectors are smaller than others, etc. * sectors : on peut organiser des secteurs autour d'une même thématique ** map: quick access to sectors * z-puzzle: que l'on soit bien clair: slots could be "z-different" too (et c'est un peu le sel du truc (parce que sinon, une fois que les pièces sont ramenés au même z, ça devient un puzzle classique)) * essayer des xylophones avec rectangles superposés pour avoir une aire valide: xylozone: [1] [ 2 ] [ 3 ] ... - le 1 est par dessus le 2, qui est par dessus le 3 etc., - quand on sélectionne une xylotower, elle passe devant et on voit alors que le rectangle fait telle taille - la hauteur de tous les rectangles est la même: si la zone est 10^3 alors tous feront 10^3 de hauteur 0 essayer avec un léger décalage entre les xyloTowers pour qu'on voit dès le départ qu'il y a des rectangles courts et des rectangles longs * flemme : regarder notes>"notes_a_taper__30_12_2020" * edu: fil rouge: walking cat: complète le challenge pour que le mur soit détruit et que le chat puisse continuer d'avancer, etc. ** représentation visuelle de la racine carrée: fractale de racines carrées en utilisant un triangle rectangle de cathètes 1 et a: l'aire du grand carré sera 1+a². même chose avec 2 et a (? et en utilisant 10^n et a ? 10^(n/2) et a ? ** transformer un rectangle en carré: encore une "fractale" à la shu algorithme: 0: prendre le plus carré possible dans le rectangle 1+:avec ce qui reste, prendre le plus grand carré possible et 2 rectangles qui vont bien (( donner comme note à un élève 10^(-2), 10^(-5),... bravo, bel esprit ** greenMouse::GLU: a particular kind of mutation the number 7 could be represented by 7 squares glued together soaking this representation inside a +2 vial would result in 9 squares glued together * relative number: [[sign] [absolute value]] 31 décembre 2020: * multipiece/multislot: le pendant Z game des "unrasterized" groups quand on place une multipiece sur un multislot, des slot peuvent être correctement remplis et d'autres non, en gros, c'est pas encore tout à fait correct. ça va demander une sorte de tether, de cordée, entre les "atomes" * => edu: construire petit à petit une réponse: l'élève construit sa réponse avec des "atomes" _dépendants_ **_dependance_ : disons que la multipiece contient une pièce "a", et une pièce "2a", alors modifier la valeur de l'un impacte la valeur de l'autre (et réciproquement (si la relation de dépendance est bidirectionnelle)) ** dependance::unidirectionnelle, bidirectionnelle * SlideAndSnapXyloTower: on peut slider verticalement vers la valeur que l'on souhaite et la xyloTower garde la même largueur, elle snappe vers la valeur la plus proche cela apprend aussi à l'utilisateur qu'il va pouvoir redimensionner des objets avec les contrôles sur le contour * "click & snap" xylotower: quand on clique dans la xylozone, elle traduit le click en un snap vers le "taquet" le plus proche * ClickAndSnapSliderXyloTower semble être encore plus intuitive (on peut "sortir de l'ornière zéro") * FreeSlideMonochromeXyloTower: on peut slider verticalement vers la valeur que l'on souhaite (pas de snap) ** FreeSlideColoredScalesXyloTower: la tour montre les différents "étages" nécessaires pour aller à la hauteur demandée (les tours peuvent être ou ne pas être de même largeur) L'effet de couleurs changeantes qui se produit quand on déplace le slider doit valoir le coup d'oeil On pourrait mettre un effet sonore aussi, ça serait peut être bizarre => Il faut un Z-behavior aux petits oignons pour éviter de décevoir l'utilisateur (le z-scroll ne doit pas induire un changement trop important de la "valeur" de la tour) ** greenMouse: slot has countDown (say "3,2,1,0") and then triggers - this allows "soak cancel" (actually I wouldn't want to soak it there) ** greenMouse: the longer you stay, the more you get: example: the slot is a [+1] slot, then for every second you stay on it, greenMouse gains +1 (if it was 4 it is now 5 etc.) *snapping: l'important, c'est les valeurs: il faut trouver des valeurs qui soient "juste comme il faut" *snapping:unsnapping must be "harder" (snapping and unsnapping are asymetrical) *snapping: snap(): la pièce écoute la version snapped, unsnap(): la pièce écoute la version free **~mise en abyme/psyOps: dans le canvas infini, montrer des maisons, des immeubles, et quand on zoome dans une fenêtre du bâtiment, on voit un élève en train de joueur au Z-game, et en fait, c'est nous qui jouons à sa place. L'idée c'est de faire croire aux élèves que tout le monde joue au jeu et donc que c'est pas un truc de ringard/loser/tête d'ampoule. ***could we actually combine z-scroll and 3d canvas ? (z-scroll would zoom in current z-layer, but keeping z the same) (this would open the door to total madness) *snapping: snap to any canvas 'position' (pas besoin de snapSlot, ici le "snapper" c'est le canvas lui-même) * le système de représentations pourrait être utilisé pour retrouver un coupable (ou du moins mieux visualiser les différents points de vue) 01 janvier 2021: * challenge mecanism: 5 seconds to complete: after clicking on start, user has 5 seconds to complete challenge greenMouse allows quick mutation combos : c'est rapide de glisser la souris * on pourrait aussi imaginer des mappings locaux de touches de clavier (valables uniquement quand le challenge est actif, pour déclencher des mutations (sous le slot il y aura marqué la touche de clavier pour le déclencher)) * challenge: related objects: mutate objects so that a relation is verified examples: mutate objB so that its area is twice as big as objA's mutate objB so that AC is twice as big as AB * challenge: shmup: shoot numbers: to destroy negative numbers, you have to shoot positive numbers so their sum equals number opposite 02 janvier 2021: around puzzles: * polygonal piece * rounding corners (any angle): inner/outer: courbes de Bézier (pour ne pas se prendre la tête avec les tangences) ? * any piece shape ==> masks * puzzle snap types: -shape and content-seam (le truc classique sur un puzzle) -shape-seam (la pièce snappe même quand les contenus ne font pas la jonction) -content-seam (la pièce snappe quand les contenus font la jonction, même si un des pièces déborde sur l'autre) ==> this requires complex z-index mgmt * create pieces: * - machine: piece mould: input: content container (content), operator: piece mould (shape), output: piece with shape and content ** - pokéball: (single-use portable machine) (masked snapshot), user can carry along a puzzle mould, which when placed over content (this could be many objects piled up), and activated, mutates into a puzzle piece with mould shape and captured content **machine: portable machine, machine is carried along to input location instead of input being carried to machine location **machine: single-use portable machine: machine can only be successfully actioned once * wearing objects: objects wear out after a certain time, and then disappear * edu: creation d'automatismes: [ - timeout challenges - wearing objects - focus-enlivened wearing objects: what has not been appearing in screen rect for a long time begins wearing ] *** Paul's idea: "companion app": une application couteau-suisse qui les suit tout au long de l'année et dont les programmes ont été construit par les élèves: ils se servent de ce qu'ils ont construit ** lien entre companion app et game app: - use companion in game (companion 'mascot' is visible in the game) - unlock companion skills in game (on est moins dans la construction mais plutôt dans l'acquisition) * edu: docimologie: - noter la progression dans le jeu en fin de trimestre, coeff 2 par exemple - progression 'notée' vs progression facultative - si c'est le cas, il faut empêcher les élèves de tricher * edu: un jeu qui suit le cours de l'année: à chaque chapitre, le prof donne le code pour débloquer le secteur associé au chapitre et il y a un secteur 'hors-piste' qui est toujours ouvert ** take photo and then look for piece content: photographs can now have very high resolution: piece content could be fetched from photograph * edu: 1. on marche et on prend des photos 2. on cherche des objets particuliers dans les photos en zoomant 3. on fabrique des pièces et on complète le puzzle **StickSnap: the idea is to stick two pieces together ** L-stick snap: side-length snap: the idea is to stick two pieces together, using a flat side (a "gon"): snap will trigger only if sides length are rigorously equal edu: the idea is to make students understand that sometimes, things have to be precise ** P-stick snap: "perfect"(/"profile"/"protein") stick snap: when trying to stick pieces together, pieceA profile must be the anti(==complementary)-profile of pieceB same thing: the idea is for students to observe profiles by zooming in ** edu: il y a un problème avec ce genre d'idée: _jusqu'où s'arrêter_: une fois qu'on a compris le principe, on peut se dire qu'il peut y avoir des "imperfections" cachées n'importe où ("paranoïa de la ligne jamais droite") ** pile up objects on snap slot: edu: the right order: poser 1,2,3,4,5,6,7,8,9 dans cet ordre sur le slot ** fifo/lifo: snapSlot could have fifo or lifo behavior 03 janvier 2021: **meta-challenge: challenge list: challenge.onCompleted(moveToChallenge) edu: un meta-challenge "prérequis" avant de commencer une nouvelle étape ** greenMouse: activateOnTouch: onEnterActivationZone/onLeaveActivationZone (un peu comme un snapSlot mais ici c'est pas un snap c'est une juste une activation) ** greenMouse: fastGrow/mediumGrow/slowGrow (same effect but different strength) ** challenge: manually create clone: given a model, player has to recreate a clone of it next to it * mettre des images de déchetteries: d'énormes piles de déchets edu: miner des idées dans les bouquins de maths: *edu: decimal dot-to-dot ** Dobble avec des représentations différentes d'un même représenté edu: avec les nombres: 1/2 est équivalent à 0.5 qui est équivalent à 5/10, etc. ** le livre dont vous êtes le héros: zoom-in to the branch you chose ** on peut fabriquer un poème fractal avec ce système ***infiniteCanvas exoObject: the idea is this: say we create an object in fabric(which is normally a representation space for icObjects) (typical example: a freeDrawing) and we don't want to know what it is explicitly(its properties, how it works, etc.), _as long as we can serialize it_ we can create an icExoObject which will then be reenacted when fabric.unserialize(icExoObject.payload) un peu comme une éponge sèche, que l'on mouille et que l'on fait redevenir une éponge tout à fait valable **keyDownToggleX + mouseClick: select object **keyDownToggleY + mouseClick: select object just below **keyDownToggleZ + mouseClick: select object just above **mouseDown/up: hold/release _(previously)selected_ object **challenge: différentes représentations d'un nombre, un nombre au centre et les autres représentations autour avec des flèches et des slots *puzzle pieces everywhere: puzzle pieces may have a distinctive frame, or symbol, so that we know it should go in a puzzle in sector X Les grandes étapes de développement restantes: [ Editeur: serialization freeDrawing (exoObject) Groups polyline svg Jeu: Xylophone with texts ESB tower ZPuzzle: basic zPuzzle indicator slot (slot borderColor is either green or red depending on .isValidPiece(piece)) DoubleObjects Sparkles GreenMouse: basic GreenMouse Portals ... ] 05 janvier 2021: * z-puzzle: piece original container image, exemple: (bulle de champagne(pièce) dans verre de champagne (container image)) 06 janvier 2021: * square graduation to ease "piece hunt" when trying to solve a z-puzzle * z-scroll (minification): auto-attract to puzzle area * "square caterpillar" growth animation on challenge completion ([1] piece was the "missing part") 07 janvier 2021: ** HP::HP fountain: to recover HP, player can solve repeatedly an "easy" challenge(each time with different "problem values") to get a small amount of HP back harder riddles may give a greater amount of HP back ** HP may determine how fast the player can zoomIn/zoomOut *remark: fractal drawing seems very natural (as if we were predisposed to draw some (recursion is not brain-intensive, it is quite dumb actually)) *mouseDown z-scroll: follow cursor https://cancerberosgx.github.io/demos/misc/fabricRectangleFreeDrawing.html?d=9 * shape recognition: https://stackoverflow.com/questions/10463158/fabric-js-implementing-shape-recognition-on-newly-created-paths this would require AI-trained library 1. freeDraw a path 2. shapeRecognitionLibrary.getShape(path) 3. create fabricObject for recognized shape **dehydration/rehydration of "non-passive" objects is to be done wisely (==reactive objects(like in a chemical reaction)) (for example: slots) couper les tentacules avant de congeler puis refaire des boutures de tentacules à la décongélation 0 imagine if some "slow attraction" process was going on when saving: recover attraction process when loaded **protoSlot: this objects waits for user to put piece in it a workflow: 1. create obj 2. create protoSlot 3. drag obj in protoSlot => protoSlot mutates to slot 4. select newly created slot 5. (while slot is selected) keyP (for example) => slot creates piece 6. piece can be moved around **easy object: AmorousSquare ("pixel amoureux"): un pixel facile à vivre qui se vient se L-snapper à un autre AmorousSquare => on peut fabriquer facilement des polyominos => double L-snap, triple L-snap, quadruple L-snap: when piece L-snaps for different reasons at the same time AmorousSquare::padding: don't snap too close, leave a spacing between glued objects **protoAmorousSlot: creates an AmourousSlot when an object is placed inside (amourousSlots can be useful when designing a puzzle) * slot racing pour parler de l'abscisse curviligne * find pieces to create triangle (segments [AB] [CD] [DE] etc.) 08 janvier 2021: * l'unité de longueur d'un nombre c'est un nombre (le nombre 1) * diamagnetic objects: cannot be snapped/attracted by snapslot (icObj.snappable == false) * another slot/piece creation workflow: with a CreationManager 1. create slot (it will be given id == 1 for example) (creationManager.startSlotAndPiecesCreation(); creationManager.slot = slot;) 2. create another object: if it's a piece (creationManager.slot.allowed_pieces += piece;) if it's any other object: (creationManager.endSlotAndPiecesCreation(); (if slot has no associated piece: destroy slot)) => this way we could associate "different pieces" (for example: [1],[2],[3]) to a same slot * challenge creation: computed object's backing graph user creates slots (for example: "given", operators, "answer" or target) for each "computed" object, puzzle maker indicates via a graph how to compute value puzzle maker can then hide the backing graph so that player only sees challenge "facade" (on cache les tuyaux derrière un peu de placo) * challenge creation: computed object's backing formula (way faster!) "= A1 + B2" ** match object's representations using freeDrawing: player links points using freeDrawing, then freeDrawing is replaced by "pretty line" when released there must be a freeDrawing zone (to avoid player doing crazy things) **O-puzzle: Overlapping puzzle: slots overlap: some part of the piece is not useful, it must be overlapped by another piece for the whole to display something nice => this requires complex z-index mgmt => this requires "slot community" (first filled slot is "send to back", then next filled slot is put over etc.) * slot overlap has many different flavors: TL, TR, BL, BR, center, offsetXY difficulty::hard: slot can be filled multiple times slot can be filled with pieces of different sizes example: with filling order ______________________ | 2 |1 | | 6 | 5 | | | | ---------------------- | 3 | 4 | | 9 | 7 8 | |________|___________| edu: O-Puzzle "useless zones"(==zones that will be overlapped) could be used to carry texts in order to describe object parts edu: easy mode: add piece orderIndex in the useless zone edu: O-Puzzle "useless zones" could be used to display what's behind facade example: anatomy **edu: O-Puzzle: "put it in right order" (un peu comme le jeu UNO, on empile quand on peut) examples: mathematical demonstration (in geometry for example) * we could use a slot for the main demonstration flow and satellite slots for the lemmas used in the main flow geometrical construction * edu: feedback: add tick when the right piece has been placed (like in a todo list) logical sequence: cover [A->B] with [B->C] etc. colors and numbers (un peu comme le jeu UNO mais en mode "dominos" (il faut utiliser tous les dominos)) dobble (sets are related by one common element) * on est d'accord que le mieux c'est quand l'élève part de rien et doit tout fabriquer lui-même, ici c'est un peu de la réflexion discount ** edu: add "unfitting" pieces(==dead-end pieces) (to prevent student from bruteforcing): there are many more pieces than actually needed some pieces may seem fitting at first glance but then appear to be dead-ends *O-puzzle:easy creation workflow (for a single-slot O-puzzle): 1. maker creates protoOPuzzleSlot 2. maker puts _in the correct order_ the different pieces they want to use 3. maker clicks on "Done" 4. protoOPuzzleSlot automagically paints useless zones for each piece with garbage by comparing the different pieces 5. maker can get the painted pieces from the filled protoOPuzzleSlot and put them wherever they want *challenge: trouve l'intrus *challenge: lis l'algorithme de déplacement et sélectionne le point d'arrivée, ensuite appuie sur "play" *tool: le répartiteur: user creates a partition of a 100% box and can then drag any collection or number that will be divided into different output boxes with the right proportions *-puzzle::double puzzle: pieces are linked together so when solving puzzleA, it solves puzzleB (first puzzle could be mathematical and the other puzzle could be an image) and only puzzleA pieces can be selected and moved * coins: player earns coins easy exercises give fewer coins than hard exercises player can then buy: hints keys say the game is playable from kindergarten to high-school, in kindergarten, player will earn 1 or 2 coins in comprehensive, player will earn 100-999 coins in highschool, player will earn 1000-9999 coins per challenge (player would keep the coins they have earned the previous year, keep the places they discovered, keep the challenge they completed, and also those they have not completed yet, so they can always complete them later on) * snap objects that don't have homeScale (example: lines) => "sizeless snap" => sizelessSnapSlot * createLine: rep_proto ("proto representation") ( notre point de départ ça pourrait être un solide avec un volume, parce que c'est le seul objet mathématique "qui existe vraiment" * AmorousSegment: once pointA is snapped, pointB can be moved around in the radius circle * on pourrait refaire une interface plus rapide pour les chiffres dans "les chiffres et les lettres" basée sur green mouse (dans le fond, l'esprit de l'idée de départ de green mouse c'était très proche de ça) * greenMouse: priorités opératoires: we don't care about the result value: - answer slot is filled with full expression - green mouse shows growing full expression we do care about the result value: alternate display: number result / full expression easy: - only result value - only full expression medium: alternate display: number result / full expression hard: answer and greenMouse have different representations (one is result value and one is full expression) harder: answer is full expression but player cannot mimic full expression with the available vial operators: player has to match two different, _yet equivalent_, full expressions * greenMouse: function related vials: derivative primitive composition with another function 09 janvier 2021: ** challenge: "show me X", "show me the thing with property Y" *edu: Langues: repère les fautes dans ce texte *edu: Géographie: repère les pays/capitales sur cette carte *edu: Maths: montre moi un exemplaire ayant tel type (montre moi un triangle, montre moi une équation, montre moi une inégalité, montre moi un théorème, etc.) *edu: construction de preuve pas à pas : - l'élève clique sur ce qu'il estime être l'endroit concerné par la prochaine étape de la démonstration - l'élève a accès à une liste de théorèmes sur lesquels il peut cliquer exemple: 1. l'élève sélectionne un triangle rectangle 2. l'élève sélection le théorème de Pythagore 3. l'identité de Pythagore associé au triangle selectionné apparaît (_en tant que nouvel objet_ dans le canvas) ** challenge: "show me X in field (normal/mini/micro field)" un peu comme pour les souris vertes, on demande à l'élève de répondre rapidement ici il faut cliquer sur l'objet associé à la question posée il peut y avoir plusieurs réponses valides possibles Le petit twist: - les objets "petits" (voire minuscules) vont être assez longs à atteindre. Les objets petits sont les réponses "évidentes". - les objets de taille normale vont être accessibles pratiquement instantanément. Les objets normaux sont les réponses "pas évidentes". Donc: easy: player has enough time to pick a small object (the small, "obvious", object) normal: player may have enough time to pick a small object but it requires dexterity hard: player does not have enough time to pick a small object, player has to think and select valid normal object exemple: La consigne c'est [1] (==sélectionne le nombre 1). Dans le champ de réponses possibles, il y aura un [1] tout petit, il y aura un [2 - 1] un peu plus gros. il y aura un [(5 - 1)/4] encore un peu plus gros. etc. optionnel: Avant que l'exercice ne commence (== avant que le timer se déclenche), l'élève peut se balader dans le champ de réponses pour se familiariser. **wow-effect: present stuff and use game objects during presentations, since they are just right here *edu: j'ai envie de sortir le glisse-nombre, je le sors, même pendant ma présentation de cours (j'en ai besoin là maintenant, eh bien, je ne change même pas de fenêtre, je ne perds pas de temps à aller le chercher dans mes dossiers, je l'ai là, je l'ai toujours eu là, sous la main, prêt) => besoin de plein de raccourcis clavier *edu: j'ai envie de sortir un exercice/jeu, je le sors **générateurs d'exercices: ne pas réinventer la roue (au moins au début) 0 est-ce que pyromaths est open-source ? *challenge: place le glisse nombre au bon endroit: "le xylophone est cassé: il donne des nombres sans mettre la virgule" *challenge: place la virgule au bon endroit *challenge: réparation: aide nous à remettre au bon endroit la virgule sur le xylophone (ni tout à fait vectoriel, ni tout à fait raster, un entre-deux * slot "endoConfig" (if you get close enough, you will see the cogs and gears) ("horlogerie") * opacity setting same as color => "KeyV" * l'encre invisible ! write stuff with opacity 0.0 * opacity blend: add vs fusion * 0 acheter le nom de domaine teachingbeforedying * protoSparkle 10 janvier 2021: * serialize useof interactive module: module will be loaded on deserialization example: modules: { xylophone: { type: "xylophone", exponent_min: exponent_max: }, } *sparkle emitter: phare feu de camp candle lightbulb luciole * reversed Z-puzzle: remettre les objets à leur taille originale 11 janvier 2021: *greenMouse: path graph: étant donné un nombre de départ et des opérateurs, - il y a des nombres faciles à atteindre (==en peu d'étapes) - il y a des nombres difficiles à atteindre (==en beaucoup d'étapes) *(greenMouse: NIM game: à chaque fois que l'on utilise un opérateur, il disparaît, l'idée est de ne pas faire le dernier mouvement (idée encore un peu floue) 0 fabriquer une présentation de cours avec infiniteCanvas **machine: l'agrandisseur: (basé sur le théorème de Thalès) on a un angle donné, par exemple 35° il y a un slot dans lequel on met l'objet d'entrée on peut ensuite faire glisser l'objet pour l'agrandir/rétrécir à l'envi l'objet de départ est montré et le facteur d'agrandissement aussi *( un pulse électrique dans le bouton de souris pour faire en sorte que l'utilisateur arrête de garder le bouton appuyé quand ce n'est plus nécessaire * protoWell * greenMouseWell/protoGreenMouseWell * touchSlot: user-scripted touchSlot * protoTouchSlot: - facade - transformation script * scriptHolder (généralisation de touchSlot) et scriptHolder.triggeringEvent voire triggeringFunc (séquence complexe d'évènements) * greenMouse: pour le fun: faire un exemple avec la souris verte, l'huile, l'eau, et l'escargot tout chaud ** greenMouse: pathHintTouchSlot: full: toucher cet objet donne un chemin à suivre pour arriver au résultat cible ** greenMouse: pathHintTouchSlot: next: toucher cet objet donne le prochain noeud pour arriver au résultat cible ***dynamic object::network-fetched: "tout le web dans un seul canvas" / "infiniteBrowser" cela demande une autre façon de coder les sites web, mais si tout le monde s'y met, ça peut être sympa 0 add network-fetched image-of-the-day to infiniteCanvas ***Z-scroll railway(==z-railway): from beginning of course to end of course user can select the z-railway and then, when user would scroll, they would follow z-railway's path (le prof n'a qu'à rouler la souris pour dérouler son cours) *pathSparkle: multiple phase-shifted similar sparkles (probably better with opacity != 1) (comme si on voyait d'en haut les balles d'un jongleur) *touchSlot: explain mutation: [1][+2][=][3] while greenMouse is "in" touchSlot, objects appear on the sides of touchSlot to explain mutation ^ ^ ^ | | |______ mutated value (== a preview of the greenMouse when it will leave touchSlot) (==rep_touched) original value _________| | |_______ touchSlot this is mainly dedicated to edu purposes *edu: show steps around variable: accessor(get) == get value out of the box, compute expression == do stuff with value, mutator(set) == put new value in the box gros travail d'animation *touch-based number shoot'em'up: player starts with 1 and tries to get the biggest value possible by touching powerups (x2, x(-4) (which may be a risky strategy), +10, etc.) we could imagine 'sector gates' that only numbers above(/below) threshold could get through 12 janvier 2021: * greenMouse::competitive: beat(==finish before) computer beat other player * greenMouse: conjugaison * greenMouse: Pythagore il faut trouver un moyen _fluide_ de suivre le procédé qui amène à sqrt(a²+b²) ("Sans titre" aurait été tout à fait satisfaisant pour le PCI *( a well is like a reverse snapSlot 1. on hold, create new represented 2. on release: if out of well's recapture area, disable recapture if inside well's recapture area, recapture object: destroy represented OR a well is a self-refilling initially-filled snapSlot (but this requires redefining the behavior of a greenMouse (greenMouse can continue living if it was never held)) => composite object: snapSlot + sample#000 OR a well is an object refusing to move (because snapped), cloning itself instead of moving, and a "blackhole" snapSlot (destroying whatever it snaps) *) ** touchSlot: dual touch/multi touch: a dual transformation func is triggered only when two touchSlots are touched simultaneously **"are these operators or numbers ?": a touchSlot, if prepared with "touchable = true", can then be touched, thus mutated (this way a -1 operator can become a -2 operator, when touching a x2 operator) edu: this way we can blur the boundaries between "operator -1" and "number -1" **challenge: Indiana's path: to get to target slot, greenMouse has to cross a grid of touchSlots, so player has to find the right path (we can imagine complex looping paths) * challenge(hardcore): Indiana's room: player has to fill 4 target slots. Once a target slot has been filled, player comes back from start and previously used touchSlots are neutralized (là on est dans le casse-tête) *challenge:goulet: there are two "operation wards" and between the two, the only passage is a [x(-1)] operator: user has to anticipate before changing room targetSlot is only reachable from operationWard2 *edu: greenMouse operator spam: - spammer le +1 ne donne pas grand chose d'intéressant - spammer le x2 donne quelquechose d'intéressant (pour le cours sur les puissances) *activationPool: touchSlot.canActivate is conditionned by activationPool.nbRemainingActivations (collective behavior) *edu: easyStar/mediumStar/hardStar: check if student only has easyStars: it would be nice if student could, at least in one domain, get a hardStar (que l'élève ait une compétence avancée dans au moins un domaine) (pour qu'on puisse ensuite s'en servir comme d'un marche pied pour avancer dans les autres domaines) *maker:easy: referringTo: comme pour la couleur, ou l'opacité, on aurait une zone un peu comme un select, qui indiquerait ce à quoi on se réfère en ce moment exemple: je veux créer un snapSlot qui snappe uniquement les icTexts, eh bien, si j'ai comme reférence "icText", alors quand je créerais mon snapSlot, il sera automatiquement configuré pour ne s'intéresser qu'aux icTexts *greenMouse::litteral operators: [+x], [-y], [*z], [^k] easy: autoReduce full expression medium: autoReduce current expression layer hard: don't autoReduce *greenMouse::fractions: easy: autoSimplify full medium: autoSimplify current layer hard: don't autoSimplify *greenMouse: time extended/small heal: when greenMouse is soaked, it adds a bit of time/HP to the greenMouse we can represented the countDown by slowly removing HP from the greenMouse *challenge: GTA: objectHolder is a car and player can accelerate/brake/turnleft/turnright c'est toujours la même soupe mais là on controle une petite voiture *greenMouse: is a transient variable: say only greenMouse.value is transferred to target slot, then greenMouse is a transient variable (it does not outlive oneself) * variableWell (==geminiWell): mutations are shared by all representations (there is only one object) * challenge: 2 areas, 1 variable: each area is exclusive (one cannot go from one to the other), variable is present in each area and can be mutated in either **greenMouse::vectors: vector greenMouse, vector operators, vector target * edu: show vector arrow (for 2D numerical vector) *greenMouse::collection: collection greenMouse, collection operators (map, filter, reduce), collection or anyType target * challenge: composite object * a composite is not a group (a composite has only 1 level of nesting, a composite does not have intrinsic position, size or homeScale): compose() flattens all objects (though it does not break inner groups) 0 moving one part: 0 makes all parts move (== "fixing") 0 does not make all parts move (== "mobile") (example: well's sample) (0 move individual part: rearrange composite * selection transformations: - compose - wellify - greenMouseWellify *composite object: protractor (rapporteur d'angle): les aiguilles sont les parties "mobile" et le centre est "fixing" => mobile parts movement is constrained *composite object: oriented-angle protractor *composite object: editable segment: les deux points d'extremité sont les parties "mobile" et le segment est "fixing" *composite object: clock ***permanent challenge: clean the world: litter regularly spawns in the infiniteCanvas. Player would better put it it the bins, or else there will be litter everywhere. the more litter there is, the more litter there will spawn. ***permanent challenge: upkeep: everything slowly withers, if not "refreshed". **composite object: "[+1] [-1]", when a [+1] touches a [-1], they cancel each other and object vanishes *snapSlot::gravity-based: player can create satellites by giving the right release impulse *challenge: "click on point with coordinates (< >;< >)", animation: an archer shoots an arrow to the point picked by user, if user point is close enough to target, then that's fine... 13 janvier 2021: *greenMouse: parentheses plusieurs mises en oeuvre possibles: - two areas: switching area starts new parentheses expression - central parentheses operator: [()] - central parentheses related operators: [()+()][()-()][()x()][()/()][()^()] - central parentheses related operators: start new expression with initial value: [+0][-0][x1][/1][^1] - one area and parentheses operators on top, "standard" operators at bottom *redMouse calculator: un outil pour calculer des nombres rapidement (a good parentheses ux is required) *challenge: écris la rédaction correcte en assemblant les blocs (à la Scratch) some blocks would have slots to fill with redMouse calculator's output as in Scratch: slots/blocks should resize when inserting big piece (a long number piece for example) *greenMouse::logical expressions (sûrement pas mal de choses à gratter de ce côté là) *xylophone calculator(juste une autre proposition d'UI pour la calculatrice): user can pick number on xylophone *edu: ce qui est bien avec l'idée initiale de greenMouse, c'est qu'on affiche jamais une expression incomplète à l'écran *la désillusion: dans le fond, rien d'innovant: Scratch possède des snapSlots, Scratch possède des wells, Scratch montre des exemples de L-snapping, de composites, d'object bin, *greenMouse: undo operator (merci Willy) (et redo aussi pourquoi pas) *greenMouse:operator preview: show preview of operator's application *greenMouse: guess the operator 14 janvier 2021: **greenMouse: is equality **greenMouse: is inequality **greenMouse::equations: rejoue les étapes à l'envers pour éfeuiller l'expression *greenMouse:complex operator: example: [x2+1] **operator mutation: tu voulais [x20] ? eh bien, tu prends [x2] et tu lui fais toucher [x10] **greenMouse:reset button (put operators back to their initial value) *greenMouse: we may reset operators on greenMouse release (if operators mutate during the "greenMouse journey" (==greenMouse transformation process)) **opérateur de conversion: exemple: [croissant <-> argent] *edu: greenMouse on Scratch pour faire comprendre le principe un peu plus en détail **greenMouse: parentheses operator: une autre proposition: [)x(1] [)+(0] *greenMouse::complex numbers [+i] [xe^(i theta)] 0 show minimap of position in complex plane as gm evolves 15 janvier 2021: *greenMouse::eval operator: example: operator: [eval({x = 3; y = 5;})], so when [2y] will touch it will transforms into [10] this could produce partial evaluations **greenMouse::strings: string variable, string operators, string target - capitalize - remove first/last letter - insert letter at index - concatenate - randomString with format **greenMouse: number dump: the whole greenMouse area is actually a dumpingSlot, so when number is dropped, its value could be: - auto added - auto multiplied - etc. to the dumpingSlot current value **greenMouse: target is ...<[ ]<... edu: -2 * 10^-3 <[ ]< -10^-3 **greenMouse: variable has to match target's condition - inequality - complex condition: {{number must be odd} and {over 9000} and {its last digit must be 6}} etc. icObj.cType = "<>" may actually be replaced by: gmObj.icObj.type = "composite" gmObj.type = "<>" ((* ""système des boules noires et blanches choisies par le jury"": on peut faire un système de note probabiliste: chaque membre d'un jury(très nombreux) remplit un sac avec la note qu'il attribue au candidat le candidat tire une note au hasard dans le sac et c'est sa note définitive ))* *edu: greenMouse: "last operation should be a multiplication" (pour forcer l'utilisation des fractions) ***greenMouse: "value path" conditions: "last operation should be a multiplication" "third operation must be a substraction" "reach target in max 5 operations" "reach target in exactly 5 operations" "reach target without exceeding 100 at any step" "reach target without getting 42 as a step result" => targetSlot checks value but may also check "value path" (==the value "fabrication process") ((le problème avec la forme: quelqu'un respecte la forme, mais c'est une belle coquille vide. *edu: greenMouse: commencer léger child: nb_operators: 1-2 pupil: nb_operators: 3-4 student: nb_operators: any **greenMouse: écrire une phrase sans fautes operators are renewed for next word il y en a avec des fautes et d'autres sans when touching a "mistake" operator: everything resets: back to the start **greenMouse:show greenMouse path building: greenMouse: writing: montrer la phrase en train de se créer greenMouse: numbers: montrer l'expression en train de se créer (""visionnement d’une vidéo montrant un épisode du jeu"": WOW **redMouse:Mario et les champignons *edu: show/hide value tag of redMouse ((est-ce qu'il est légitime de montrer des figures avec des longueurs de côté qui ne sont pas reflétées par le dessin ? *webpage should be lightweight for "bad connection" users *webpage shouldn't involve two much CPU/RAM usage for "bad computer" users *greenMouse: build a tree: leafs and nodes 1.it starts with a leaf ([1] for example) * 2.then you select a node operator ([+] for example), you get [1]---[+]---[?] 3.you have to fill empty leaf space with a leaf, you select a leaf operator ([2] for example), you get [1]---[+]---[2] 4.then you select a node operator, etc. *greenMouse: number textual form: [un]*[+2] va donner [trois] (* == touches) *greenMouse: observe the decimal system "in deeds" using operators: [+1] [+10] [+100] [+1000] 16 janvier 2021: *greenMouse: target slot is riddled: exemple: 1234 + [ ] ________ 7894 *union libre: composite([piece,slot]) (ça donne un petit côté gemini, "si tu me tues, l'autre mourra aussi") *try composite([compositeA, compositeB]): regarder si on peut faire des trucs subtils avec isMobile (qui est en fait isMobileWrtMyComposite) *Z-railway: from slot to piece *Z-railway: dot wave: a wave from src to dst is formed by static dots getting bigger, getting smaller *machine::clone:[inputSlot][temporaryWell] *greenMouse: cloneMachinesEverywhere: well could be replaced by a cloneMachine to give the player the ability to choose the initial value edu: par exemple: l'élève peut prendre son numéro fétiche pour faire le challenge (un petit côté "choose your character") edu: par exemple: l'élève peut prendre ses opérateurs préférés pour faire le challenge (un petit côté "choose your weapons") *greenMouse: round()/trunc() operators **multimouse(many mouses in classRoom) is compatible with greenMouse **multimouse(many mouses in classRoom) is compatible with zPuzzle *madness: 4 player split-screen greenMouse ((many mouses in classRoom)) **dev:MAKE IT F-ING SEXY (sinon personne va y jouer, ou alors 5 min et c'est tout) - rounded corners - animations (regarder ce que font les jeux genre Candy Crush etc.) *challenge: contrôle qualité: le joueur doit dire si la pièce doit être mise au rebut ou pas en mesurant (on peut imaginer une machine qui produit des pièces) des longueurs des angles des couleurs etc. *greenMouse: boiling operator: il faut attendre un peu de temps sur l'opérateur avant qu'il ne s'active (on s'écarte un peu de la "philosophie greenMouse") *challenge: "dirty glasses"-puzzle: the "key" to solving puzzle is to use piece in HUD-layer, so the puzzle is completed when all others pieces have a correct relative position **(*)greenMouse: invisibleMouse: at some point, greenMouse is invisible, so player has to run the operations mentally edu: we could replace the invisibleness by a question mark symbol: [?] *challenge: Pythagore et Thalès: une petite cuisine de nombres: length tags are redMouse wells so player can use them directly to create expressions *easy clone: keyDownTrigger("") + hold object (en gros: keyDown + mouseDown + move) 17 Janvier 2021: *z-well: grow number via z-scrolling *timeWell: grow number via waiting *ui:numbers::colors: -each "broad" operation (+/-==+) is given a color: example: +: yellow x: cyan -each operation neutral number is given a color: the color for neutral example: [+0] could be yellow with a neutral color border *challenge: single-operator challenge: since there is only one operation involved, numbers and operators can be considered the same thing in this case: [+] operation: [1]*[-1] = [-1]*[1] = [0] [x] operation: [2]*[1/2]=[1/2]*[2] = [1] operation symbol (and color) could be the background pattern of the challenge area (==operator as wallpaper) *challenge mutator::now it's black and white: player is driven to reading the symbol instead of reading the color ***icObj.type = "emitter": - the information propagation could extremely slowed to be visually represented using a growing circle - the information attenuation could be visually represented with a fading effect edu: this way: player can visualize the cause of: - "negative events": - challenge reset (for example: the countDownTrigger triggers the resetEmitter, whose wave resets challenge) - "positive events": - challenge completion (for example: the completionTrigger triggers the completionEmitter, whose wave opens the star box/gives a key/etc.) **E-Puzzle: emitter-based puzzle (==information propagation puzzle) *challenge twist: touching countdown with number n adds/substracts n seconds, and number is to cross countdown (center area is narrowed not to leave any other possibility) (un peu une idée farfelue, mais les joueurs attendent des mécaniques farfelues) *dev: live-shared document would be nice for brainstorming and creating exercices *greenMouse: A*cos(w*t+phi): [0,2Pi] *drop system: because life is also luck: when completing a challege, there may be "dropped" objects. dropped objects could be: numbers letters operators images quotations etc. (*en fait, on parle jamais de contexte, d'espace de noms, quand on fait des maths avec des lettres mais on devrait peut-être. Je pense à l'élève qui a utilisé x = 7 dans l'exo1 et qui voit maintenant que x=-12 dans l'exo2, et qui comprend pas pourquoi il a changé. subtract vs substract: substract is now obsolete *tex and svg: icObj.type = "svg": double click to edit: show texCode, on stopEditing: show svg mathematical expression <--> tex --> svg (*résoudre une équation du premier degré, c'est de l'effeuillage. edu: exemple: Je note sur une feuille un mot. Je mets un scotch noir dessus. Je plie la feuille. Je la mets dans une enveloppe. effeuillage: ouvrir l'enveloppe, déplier la feuille, enlever le scotch. *infiniteCanvas: classroom representation: put photographs of students ==> easy mgmt: click on student's photo 18 janvier 2021: *greenMouse: tool: build expression from greenMousePath *greenMouse: tool: build program from greenMousePath ((tu peux recoder une sorte de Scratch si tu veux mais pas maintenant)) *greenMouse: snapSlot in TeX expression: du gros dev en perspective 19 janvier: * tex --> math 0 Uncaught TypeError: algebra.fromTex is not a function Le travail a probablement déjà était fait, il faut juste le retrouver * subtle work to adjust expression container size in order: - to fully contain expression - for expression to be readable (== 'big enough') - never to surprise user (size changes must be visually 'acceptable') OR we can animate expression's size adjustment: it slowly moves to target 'nice' size OR "touchable part" keeps the same size and "display part" continues growing OR we create composite: [E][=][(1+5+y)x2] and touchable part is [E], while growing part is right-hand side *greenMouse: polynomials: show function graph/function shape next to expression (this way we see the 'waving effect' (== more and more roots as degree increases)) * icObj.type = "computed" (== icObj.type = "view"), createIcComputed(icObj,transformationFunc) ***z-Scroll:: 'scale defying' object: zTraveler: comme un sparkle, mais il ne clignote pas zTraveler gets as close as possible to infiniteCanvas.scale zTraveler may move along a z-railway edu: at level1: we see all operators, at level2 we can focus on each when we zoom in on a particular operator, we see that it seems to shrink, moving to its homeZone the operator's homeZone hosts a more specific challenge edu: "c'est le même opérateur" *greenMouse: show all identities along greenMousePath: 1 + 2 = 3 ; 3 x 2 = 6; 6 x (-1) = -6 ; ... *greenMouse::mathematical statements: sujet verbe complément subordonnée et grand-mère sur la commode (* mathematical verbs: =, !=, <, <=>, =>, *greenMouse: evaluate expression: 1. put expression in protoWell: [2x] --> [[2x]] 2. use clones to evaluate: [2x] * [eval({x = 2}] --> [4] [2x] * [eval({x = 10}] --> [20] (3. destroy protoWell to get original expression back (* multiplier _une équation_ par 2 , c'est un peu comme mettre une phrase au pluriel. *greenMouse: priorités opératoires: effeuillage: à chaque étape, proproser comme opérateurs les opérateurs qui constituent le chemin standard exemple: on demande de récupérer _le_ 8 dans l'expression (8 + 7 x 6)/50 - 1, pour [(8 + 7 x 6)/50 - 1] proposer [+1] [x50] [-(7x6)] (pourquoi pas [/6]) ensuite pour pour [(8 + 7 x 6)/50] proposer [x50] [-(7x6)] (pourquoi pas [/50]) ((quand la souris accouche d'une montagne * edu: two almost identical wells: a well yielding "autoSimplify:on" nodes a well yielding "autoSimplify:off" nodes so when the student follows a greenMousePath, they will either see the "growing" _result_ or the "growing" _expression_ ** edu: expression simplifies: - every n steps - at random time - only after student has earned the simplify skill - when touching _a_ simplify operator * il y a des simplify spéciaux, par exemple quand on veut transformer (-1)x(-1) en (-1)^2 pour montrer l'exposant de (-1) *edu: écris deux expressions égales, différentes dans leur écriture **sparkle firework: to celebrate a challenge completion *events: - circle propagation ("radio propagation") - wire propagation (we see the event moving along a wire) *keep it local: icScope.icObjects = {}, pour: - éviter de scanner le monde entier quand on est un trigger d'un challenge - éviter de spammer le monde entier quand on est un eventEmitter d'un challenge => là, c'est la notion de $scope qui intervient (tout existe déjà) **composite mimic: from real-life object to mathematical model example: moving clock hands is "reactively" mimic'd in triangle 20 janvier 2021: *greenMouse::invisibleMouse: question mark changes color and font when touched (touch feedback) edu: when greenMouse value is something x 10^30 and touches [+10], the value doesn't seem to change and yet there must be a feedback that touch happened (j'ai jeté une goutte d'eau dans l'océan et personne n'a remarqué). **step by step simplification after node.evaluate("x = 3") => 0 "atomicSimplify" operator edu: l'idée par exemple, c'est un peu comme une montagne: on part de x, (pied de la montagne) on complexifie pas à pas l'expression (on monte) on fait l'évaluation (sommet) on simplifie pas à pas l'expression (on redescend) on a le résultat (pied de la montagne) * add a pool next to icObserver to put triggers in (or composites with triggers) * icObj="challenge" * icObj="challenge_generator" **switch expression representation: - reduced form - tree show tree depth to get an idea of the complexity of the expression - "historical", unreduced form **(*)redMouse::graph editing: 0. there exists an empty node [empty] which can be used as an initial node 1. user creates an operatorNode [empty]---[+]---[empty] by touching the [+] gmOperator 2. -THIS IS THE INTERESTING PART- user can fill the empty nodes by a. selecting the empty node with the mouse and dragging it (the whole graph moves but the rest is "numb") b. touching a gmOperator (be it a common operator or a "valueOperator" like [1] or [2] for example) this can be extended to "non-math" graphs * increase operator arity: say the operator [+] has been touched and we have [ ]---[+]---[ ] then if we touch [+] operator again _with the [+] node_, we get: |---[ ] [ ]---[+]---[ ] or even simpler: say the operator [+] has been touched and we have [ ]---[+]---[ ] then if we touch a valueOperator (for example [1]) _with the [+] node_, we get: |---[1] [ ]---[+]---[ ] * build tree: say the operator [+] has been touched and we have [ ]---[+]---[ ] then if we touch [+] operator again _with the left node_, we get: [ ]---[+]---[ ] |---[+]---[ ] ** mathNode graph: show partial result next to each operatorNode (* en fait, les opérateurs [+2] [x(-1)] etc., sont des opérateurs unaires, qui sont en fait des currying d'opérateurs binaires. Grâce à eux, on construit l'arbre de calcul de façon séquentielle, sans "revenir en arrière". *rect fusion: we a rect touches another rect, they fusion so that the new rect area is the sum of the two rects' areas *ux: easy graph creation: draw a line between two objects and it creates the graph composite with the two objects as node and a link between them - draw a line between the two to created an unoriented graph - draw an arrow between the two to created an oriented graph - draw the reverse direction arrow over an existing link to mutate the link to a bidirectional link * colored value/ colored operator: operator only operates on a node with the same color - color assignment operator (==color change operator) *greenMouse: target format is unsimplified expression: player does not have enough time, or does not have the operators allowing them to perfectly reproduce the target expression, they have to decode target expression and produce an equivalent expression 21 janvier 2021: *challenge:greenMouse with only one "valueOperator": "the 4 fours", "3 nines" (refaire les premiers nombres avec des expressions contenant toujours le même chiffre) *greenMouse: "Démonstrations folles": statementNode: "Je fais du sport" ou " fait du sport" property operator: "Si je fais du sport, je transpire." exemple: Si on trempe " fait du sport" dans "Si je fais du sport, alors je transpire", on obtient " transpire". *challenge::"edu countdown": countdown has a pause button near it, but, if pressed, challenge reward can't be earned - this way player can train - this way player understands that "the true thing" does not allow pausing ***greenMouse::living greenMouse: greenMouse' value updates even when there no user action: examples: countdown-greenMouse, radioactive-greenMouse, etc. countdown-greenMouse: -standard: every second, greenMouse value is removed 1 -exponential: every 3 seconds, greenMouse value is multiplied by 10 -random mutation: every n seconds, greenMouse value is transformed via a random operation countup-greenMouse: every second, greenMouse value is added 1. radioactive-greenMouse: after a random duration, and based on a probability density, greenMouse is mutated tree-senescence: operatorNode greenMouse has branches that separate from main tree (after some time) edu: this would provoke player into keeping the situation under control, into containing the living 'dragon blob' mouse edu: il faut vraiment trouver un moyen de rendre les mutations de vie visuellement différentes des mutations d'opération, pour pas que les élèves pensent que les nombres s'amusent à changer comme ça leur chante **challenge:greenMouse:"get more than N": greenMouse value must get over target value during given time (snapping at the end is not necessary) -variant: countup-greenMouse: greenMouse slowly counts up, but too slowly to get over target value in time, so this plusOneing value must be operated on (*icObj apoptosis: say there is a network of very small touchslots which send a 'continue living' signal, then, when an object is smaller than those touchslots, it will die from not having been maintained *greenMouse: countdown timer is number too: player can use it to complete a challenge edu: think "out the box" *digitWell: turn each digit of a number into a well (exemple: de 7891, on pourra extraire [7] [8] [9] et [1]) *operator: extract digits: edu: a way to create a collection from a single element *machine: digitsExtractor 22 janvier 2021: ((comment ils font pour congeler du vivant dans les entreprises du jeu vidéo ? Est-ce qu'il y a une good practice ? ** => copy paste "living object" between two applications ((en fait, en informatique, on a longtemps travaillé avec des morceaux de bois sans vie, et maintenant on commence à jouer avec des poulpes, à les faire travailler à notre place ((I think it's important, at the time being, (and, at last, to understand the lisp spirit) to consider that user written code is as important as user written "content". Data is code is data, period. composite only needs a handle when solely composed of mobile parts **maker/consumer: teacher creates exercise and, on the fly, students can try to complete it => this would allow a lot of reactivity and a lot of ^flicage^ (éducamération) après, tant que le flicage reste éphémère: un flicage de session, juste pour la séance... *challenge:code chiffre-son: trouve le bon mot * everything already exists: https://toytheater.com/category/teacher-tools/virtual-manipulatives/ tout le concept de greenMouse est déjà là: https://toytheater.com/fraction-strips/ (lolilol, gardons le sourire, chacun sa pierre) (ça serait bien pour l'image de la France d'avoir une plateforme française dans ce genre là (* composite(composite1, composite2): une vision du management hierarchique (pouvoir sacré) * 0 fun: allow chosen non-top-level objects to be part of composite: create "funny dependencies behavior" objects edu: par exemple: si on bouge un nombre alors tous ses multiples bougent avec lui mais ça veut dire que le handle du composite est l'objet lui-même (... vive la récursion) *edu: un scroller horizontal basique qui contrôle - la "zPosition" d'un zTraveler pour que l'élève arrive à l'idée de fonction - la taille d'un carré ou d'un rectangle ou d'un triangle => on peut fabriquer des machines configurables avec la valeur du scroller horizontal comme deuxième variable d'entrée **summonSlot: 1. user writes the name of the thing they'd like to summon, 2. then when activating slot (press E), 3. the infiniteCanvas checks if there is a summonable object with this name, and summons it if something was found example: 1. user creates summonSlot 2. user writes "challenge.greenMouse.numberOne" in summonSlot 3. user can summon challenge.greenMouse.numberOne when activating the slot the summoned object can be easily deleted via a delete button near the object 23 janvier 2021: **maker: composite(composite1, composite2) allows 'easy' animations (== easy creation of keyFrames) this would be even nicer if composites are graphs (i.e. composites with links) and if nodes and links are images **greenMouse::shortest-path: get to targetValue in less than steps (exponential may play a key role) easy: 20 steps medium: 10 steps hard: 6 steps *maker: z-Index: keyDownToggle: -show z-indexes -if something is selected: mouseScroll will control z-index -if nothing selected: mouseScroll will 'pierce' (voire 'peerce') *maker: align - horizontally / vertically / diagonally / anyAngley - top/center/bottom 24 janvier 2021: *challenge:greenMouse VS zIndex: greenMouse value is greenMouse zIndex: greenMouse must go above[50], go below[-20] (un peu un parcours du combattant) **touchSlot::magicBox: touch only triggers when target is completely hidden behind touch slot *spawn sequence(==egg-laying): - keyDown: if you stay pressed, a spawn will occur every - engine-based: when engine is started, sequence spawn will occur (no other user input is needed) keyDownCharge: you have to stay pressed the whole time 0 chargeIndicator *greenMouse:little squares: - [x2] operator adds the same arrangement next to the initial arrangement example: [][] [][][][] [] * [x2] gives: [] [] [] [] [] - squarify operator: create closest-to-square arrangement of little squares example: [][] [][] [] * [squarify] gives: [][] [] - rectangle operator: create closest-to-rectangle arrangement of little squares -divide/fraction happens in two steps: - prepare for divide: user has to use operators to arrange the little squares for the division to be obvious - divide prepared arrangement: since the arrangement has been prepared, division is obvious (== not surprising) *gmOperator mutation: Plusieurs choix se présentent: - valueOperator3(value) = valueOperator2(valueOperator1(value)) (standard composition) [x2] * [+10] = [x2+10] - valueOperator3 = (operatorOperatorify(valueOperator2))(valueOperator1) = OperatorOperator2(valueOperator1) (there is no typo here, operatorOperator means an operator which applies to operators) [x2] * [+10] = [x12] *challenge:number Mahjong: there is a big heap of tiles with expressions and player has to match equal expressions to remove the tiles and gain access to the back layer challenge variant: face-up match-2, match-3, etc. *greenMouse::variants - operator cannot be selected twice in a row (player has to 'alternate') - operators fall from the sky ('operator rain') 0? .bind(this) when rehydrating (when enliving) (*les 2 clés pour des maths massifiées: animation et interaction 25 janvier 2021: **enlivenSlot: when a dehydrated icObj touches/is snapped into/.. the enlivenSlot, the icObj becomes hydrated => challengeX reward may be a dehydrated object, and challengeY activation condition may be the enliving of the dehydrated object (for example a dehydrated well) *challenge activation: any icObj can be dehydrated, so can a challenge (c'est un peu comme une pièce avec toutes les lumières éteintes) **greenMouse operators: [²], [√] **machine: reciprocalOperatorify: reciprocalOperatorify([x3]) = [/3] edu: pour expliquer la résolution d'équations (l'effeuillage), on part du set d'opérateur qui a permis la création de l'expression donnée, puis on fabrique le set d'opérateurs réciproques pour effeuiller *challenge:machine chain: given step values (initial, final, and intermediate), player must put operators in snapSlot to create valid chain *edu: timeout and nb_max_attempts may be counter-productive because they prevent pupil from sandboxing (l'idée de départ c'était de faire en sorte que l'élève se trompe énormément, comme il n'a jamais pu le faire auparavant) *edu: track when an operator is spammed by pupil, and then prevent it from being spammed (Thrasher's 'area destroyed') *telomere: each time object is rehydrated, add one to telomere (bon ok, normalement les télomères ça raccourcit mais je fais ce que je veux) *simplify +1-1 or -1+1 when in sequence **edu: add slider below equation for student to try solving equation (on peut imaginer un code couleur bleu-->rouge pour faire comme le jeu du chaud-froid) 26 janvier 2021: *machine-cooked problem statements: first we generate a random expression or equation, then the machine builds a story around it **challenge:propriétés opératoires: présenter deux expressions, et l'élève doit dire si elles sont égales ou non. _Si, oui, elles sont bien égales, il doit montrer pourquoi_. L'élève doit retravailler les termes pour montrer que les deux expressions sont égales: - commutation (a x b x c = c x a x b) (l'élève doit remettre les termes dans l'ordre) - parenthèses ((2) + 3 = 2 + 3 ) (l'élève doit supprimer les parenthèses qui ne sont pas nécessaires) ce qui va peut-être être chaud à développer: si un nombre est à une des extrémités et qu'on le déplace (ou peut-être pas si on se déplace dans l'arbre) (*est-ce qu'il y a des chercheurs (français) qui bossent là-dessus ? (ou peut-être sont-ils passés du côté obscur de la force...) ((*à partir du 21ème siècle, il y a deux types de profs: les profs qui font cours à n ~ 100 élèves et les profs qui font cours à n ~ 100 000+ élèves. comme un MEGAPHONE silencieux. (*equation: left hand side and right hand side are gemini, what you do to one also happens to the other *ce qui est bien avec le fait de devoir coder les parenthèses, c'est qu'on est obligé de les considérer au même titre que les autres objets constituant une expression. On redevient élève. ***challenge:expression simplification by "touching" operatorNode with the correct simplified value: example: an expression is on the canvas: [2 / x + 64 - 30], user can pick [34] (from somewhere) and make it touch the '-' so that expression now becomes [2 / x + 34] ***" from somewhere" == from a smart object pool smart pool should also propose letters when working with litteral expression (symbolicOperators: [xa], [-b], [/c]) edu: easy: simplification wildcard: [?*] (==universal simplifier) sometimes the wildcard will "not work" : this is when there is another operation to consider before easy: target fully-simplified expression is displayed medium: challenge listens to expression and completes when expression is fully reduced hard: user has to click on "I think expression is fully reduced." button, and challenge completes only if expression is fully reduced (if not, expression is destroyed and user gets back to the start) easy/medium: smart object pool has equations in it which show simplifications calculations example: expression to simplify: [Y - 22 x Z x 33] then in smart object pool, you have [22 x 33 = 726] and [726] hardcore: smart pool contains deceiving objects *challenge:get x: easy: x + 9 = 12 medium: x + 50 = 2x + 12 hard: (x+3) / (x+2) = 4 easy: x has first position in the expression normal/hard: x has a random position in the expression ((*Pourquoi pas les automatismes d'abord ? Dans le fond, quand j'ai appris à parler, il a pas fallu m'expliquer pourquoi c'était important avant que je m'y mettes. D'abord on apprend à danser, et après on comprend pourquoi c'était important. **[xylozone(0-9)] * [x10] = [xylozone(0-90)], [xylozone(0-9000)] * [/10] = [xylozone(0-900)]: value changes and so does size **tool: display next priority: example: (12 + 4) / (5 - 3) will highlight "/" sign **tool: simplify what user has lasso-selected (*c'est chaud faut simplifier de façon chirurgicale 0 simplify: step by step 0 create equality chain: initial = = = ... 0 one line 0 multiple lines (*est-ce qu'il existe un symbole pour "simplifier" ? https://www.symbolab.com/solver/trigonometric-simplification-calculator/simplify%20%5Cleft(3x%20%2Bx%20%2B50%5Cright) 1 simplify logo, small s and "spiral arrow" (merci Cammy) 27 janvier 2021: *mathWorkout: train 15/30?/60? min/day il faut au moins que l'élève essaie/se trompe 20 fois par jour *simplification order is not really 'natural', it's like painting stripes on a tree [1] [2] [3] [4] [5] [6] [7] **from machine to human: "Maintenant, demande à ton voisin de faire comme l'ordinateur: simplifier l'équation étape par étape. Ensuite, compare les deux résultats." edu: bah ouais, si c'est l'ordi qui fait tout le temps le boulot, ça devient complètement aliénant, complètement "dépossessivant". *edu: é"Mais comment il a fait (pour fabriquer ça) ?" (une perspective pour les élèves: é"Plus tard ("quand je serai grand"), je comprendrai comment le prof a fait.") *icObj.type = ; exemple: icObj.type = "as_text__mathNode"; => icObj.parser (== icObj.fromXtoY()) *icObj.type = "editableAsY__X": composite facade is X, composite editing medium is Y * key/doubleClick: Edit https://textext.github.io/textext/ https://docs.mathquill.com/en/latest/ 28 janvier 2021: *modèle de financement à la JBFarkas: des collectionneurs peuvent acheter les challenges, qui restent gratuitement accessible à tous à côté du challenge, on peut appuyer sur un petit bouton d'information (i) qui nous montre qui est le propriétaire du challenge *first demos: obfuscate html source code 29 janvier 2021: 0 MathQuill + Visual Keyboard: pour rester dans le bain 0 mathField.latex() --> icObj.parse(tex) 0 don't parse "=" into ":=" * 0 _upgrade_ to gmOperator when writing "x50" / downgrade to mathNode when writing "50" 0 x VS ×: it would be nice to write what user means when they type keyX *"Nice barrier" : . . . . . . . . . . . . **edu: est-ce que j'écris [×10] ou [× 10] ? 0 peut-être une façon de répondre à la question: faire du volume et regarder ce qui fonctionne le mieux pour les élèves **challenge: probability: gotta catch'em all: fill target _slots_ with correct objects: probable outcome slots will be be filled easily. It will take time to fill improbable outcome slots. target objects may be: - a 1D object: dice roll, d6, d10, d20, etc. number in finite range - a 2D object: a colored number: number is in finite range + number color is in {blue, red, green, yellow} (with different probabilities) variant: fill outcome table with correct objects: probable outcome appears a lot of time in the outcome table, and these cells will be easily filled **challenge: probability: history collector: explicit path on outcome ("those two stamps look the same but I was given this one by my great-grand-father") [ 1 | 1 ] [_____|_____] [ 1 | 8 ] when an outcome is given, its explicit path is written on it: exemple: if we get 1, because the top-right sector was selected, then the [1] we get is [1 (top right)] edu: il vaudrait mieux faire faire d'abord "history collector" puis "gotta catch'em all" **tool: same denominator zone: arrange all fractions inside the zone so they have the same denominator **PAUL: multiplication d'équation: il faudrait deux opérateurs rassemblés, et il faut toucher les deux pour que le touch se déclenche edu: une fois que les élèves sont habitués aux deux opérateurs, on peut leur faire utiliser le duo [ [x 1] | [x (3 / 3)] ] par exemple pour simplifier le membre de droite *challenge: logique: opérateur qui transforme une égalité en vrai ou faux suivant si l'égalité est vraie ou fausse 30 janvier 2021: 0 gmOperator: force simplify (si gmOperator.forceSimplify alors la simplification se produit même si les mathNode impliquées n'ont pas autoSimplify) ***challenge goldmine: probas et expériences aléatoires -sac contenu visible / non visible animation d'une sorte de main qui prend un élément au hasard remise obligatoire / remise possible / sans remise -probabilités conditionnelles (évenements dépendants / indépendants): on pioche dans un sac un objet et le deuxième sac de pioche dépend de l'object que l'on a pioché dans sac1 (*contenu mort vs contenu deshydraté: avant ce qu'il y avait dans les livres on considérait que c'était du contenu deshydraté, qu'on devait y ajouter notre part pour le rendre à nouveau vivant. mais maintenant, je ne sais pas si c'est par ce qu'on n'a plus de vie en nous ou que les livres sont mauvais, on considère que c'est du contenu mort. Comme un bout de bois. D'ailleurs c'est sûrement pour ça qu'on s'en sert pour caler les meubles. Les contenus deshydratés de maintenant, c'est les jeux vidéos. Peut-être qu'on est toujours vivant mais différemment. Et du coup c'est pour ça qu'on a du mal à réhydrater les livres. * simplification: accolade de "soupèsement" **icInfiniteChronoBar / icInfiniteProgressBar: - chronoBar grows a square at its end every 1 second (at some point, you have to zoomOut to read elapsed time) - progressBar shows students accomplishments. Same principle: it has no end variant: textual mathematical life steps infinite progress bar. [j'ai appris à reconnaître les chiffres. j'ai appris à compter jusqu'à 3. j'ai appris à compter jusqu'à 10. ... j'ai appris à intégrer sur un contour ... j'ai découvert un nouvel objet mathématique. ** edu: infiniteChronoBar est sympa aussi pour faire comprendre la notion de valeur approchée: vue de loin, la chronoBar a l'air de ne pas grandir, c'est parce qu'on la voit de manière approchée: on utilise une certaine puissance de 10 et la mantisse nous paraît rester la même. ce qui est bien c'est qu'on a un objet apparement à la fois un peu dynamique et à la fois un peu statique * edu: exponential chronoBar: chronoBar x2 every second *une représentation de l'oubli: un demi-plan complètement noir avance tranquillement, toujours à la même vitesse, vers les x positifs **0? rep_engined: ça ferait sens. rep_free c'est la représentation contrôlée par l'utilisateur. rep_engined c'est la représentation contrôlée par le moteur. (*toujours la même rengaine: l'obstacle majeur: c'est la mise en prod. C'est le passage du prototype à "A table les enfants." *["text"] * [x (22/7)] = ["texttexttextt"]avec le dernier t un peu coupé: text_out = text_in * Math.floor(22/7) width_out = width_in * (22/7) 31 janvier 2021: ***yugioh-style number card game: (SHU: i think this idea could be really powerful) - turn: draw play cards - field: monster == number magic == operator - win when first to gather all monsters (monster zone are targetSlots) (~exodia) - can reuse built number as stem (? or as operand?) (- wildcards : [x ?*] [?* 4] ((- single-use / finite-use / infinite-use operators **edu: session-cooked keyboard shortcuts: say I want, _in a particular 1-hour class_, to show students particular challenges I would use the following shortcuts: easy level: "Key1" medium level: "Key2" hard level: "Key3" And those keys would spawn a new challenge, _each time they are pressed_, this way, if students don't seem to understand well after one instance, I can always spawn _a new instance of the same difficulty_, until they understand *edu: if != when, si != quand, condition != property (==consequence is true if condition is true) != event (==condition is true at this moment) les élèves peuvent fabriquer des propriétés à la pelle en combinant un bloc [when < >] avec une instruction [machin <-- truc] *0 "embracing tree" / onion mathNode: sqrt((x - 94)/4) onionNode / layerNode * operator chain: add parentheses when operators have same priority, or else mathNode's structure is not explicit simplify top layer ** en fait, on peut définir un layer comme un ensemble d'opérateurs de même priorité * mettre les layers en couleur un layer équivalent à [x 1] ou [+ 0] (== un layer équivalent à [id( )] peut être simplifié (== retiré de l'expression) une étape de simplification mathNode1: 0. repérer l'opération de plus haut niveau 1. créer l'opération inverse: {operator2, mathNodeTerminal2} 2. appliquer l'opération inverse: l'arbre grandit: il devient operatorNode(operator2.symbol, operator2.funcName, [mathNode1, mathNodeTerminal2]) 3. réorganiser l'arbre pour faire apparaître l'opération identité composée d'un couple {opérateur, neutre pour l'opérateur} 4. retirer la couche avec l'opération identité mais, c'est bizarre, après tout, l'opérateur est pas forcément binaire, ou peut-être que si ([A] ** [Anti(A)]) 01 février 2021: *cette chance de dévelopeur: ça fait sourire - y + 0 doit être simplifiée en utilisant [- 0] ^^ - \frac{\left(y\cdot 91\right)}{0} normal quoi, y'a rien de choquant... edu: ^^ dev: la simplification du 'zéro tout seul' va être chiante **[s x 60 s]: gmOperator + forceSimplify top layer => gmOperator has the same backgroundColor as standard simplification operators (for example: light green, ou gradient red-->green, black-->white) **gmOperator decoratorTouchSlot "gmOpDec": when a via gmOperator composition: transformationFunc3(x) = transformationFunc2(transformationFunc1(x)) decoration may be applied: - once cannot decorate with decoration1 what has just been decorated with decoration1 - multiple times with an "identity decorator": t --> id(t), then could create chains dec1(id(dec1(id(dec1(t))))) **(*)edu: "I think I got it." button: when student thinks he has understood something, when "something's just happened in their brain", they can press the button to indicate to the teacher that, well, something has happened in their brain (!) this would be a way to check if a challenge "is really worth it" (par rapport à l'"élève moyen") 02 février 2021: *greenMouse: display part: in order to keep the touching part the same size, a _central display part_(== at the center of challenge's area) could be used to display green mouse's current state **edu: the whole 'simple equation' workflow: 1. create the 'simple equation' you want to solve challenge 1: coat your left side expression challenge 2(or 'challenge transition'): create the equation (touch "=" sign and then a number) 2. get back to your initial letter on left side: challenge 3: uncoat your left side expression, and see right side getting 'inverse coated' **edu:quality control: is this expression valid ? there is an expression provider and two bins: one for the valid expressions and one for the invalid if player has made nb_mistakes < nb_max_mistakes then challenge is completed (((*attention avec les func.bind(this), les arrow functions font les rebelles: il faut utiliser les bonnes vieilles function() à la place. (*la théorie du décollage: quand le processus de développement de l'élève est entretenu par l'élève lui-même ((souvent par une passion)) (*l'avenir sombre de l'éducation: convey *un petit goût d'usine: conveyor-belt-based challenges: il faut pas traîner sinon ça fait planter la chaîne 03 février 2021: **edu: random everything + "I think this is not possible" button. le pendant du "grand" aléatoire : on ne sait pas si on peut trouver une solution *edu: 100 points par jour **challenge:from expression1 to expression2 via x: unfold in order to customFold example: sqrt((3x+1)/2) --> x --> (60 - x)/sqrt(85) + 7 (((((*maths for the perv: puzzle composed of greenMouse targetSlots which gradually untile to show beautiful lady for example *challenge: interlock: with "intersecting composites" *add a handle next to snapSlot for easy 'group move' *snapSlot may be, at start, a single-object composite. It then grows with the snapping of objects. => "snapComp" = composite(snapSlot) **experiment: not really a challenge, not really a tool. It is more like a "this"-dedicated sandbox. **edu:experiment: RVB color by hand: player creates a mosaic square (or a circle, or any shape) using small colored squares, r are red, g are green and b are blue: when zoomed out: we can see that the square color we see is near RVB(r,v,b) pour aller plus vite: on peut imaginer: * -un spray avec un compteur (on spraye(== position aléatoire) des petits carrés (ou ronds) de couleur donnée) ** -un enclos avec une fonction de mélange: on met tous les ingrédients dedans, on appuie sur mélanger et ensuite on dézoome 04 février 2021: *challenge: équations: [relier] les différentes étapes de résolution de différentes équations proposées les équations de départ eq1 eq2 eq3 eq4 les équations un peu résolues eq3' eq1' eq2' eq4' les équations un peu plus résolues eq1'' eq2'' eq3'' eq4'' les équations résolues eq4''' eq1''' eq3''' eq2''' *tool: dependency: créer un objet formule qui se met à jour automatiquement quand ses dépendances changent edu:pour ensuite les faire basculer sur le tableur **0 engined.engines = {} (((*how to serialize a closure ? (((*Le problème du retard, quand il n'y a pas d'échéance... 05 février 2021: *"exertive" operators: operator is moving and touches what to transform - eraser - randomizer - show/hider *icObj.type = "2d_plank" : [plank] * [x 2] = [plankplank] ==> icObj.type = "2d_length" *icObj.type = "2d_tile" : [t i] * [x 2] = [t i t i] ==> icObj.type = "2d_area" [l e] [l e l e] [t i t i] [l e l e] *la logique derrière, c'est la coercion de [x 2] en [".size.width x 2"] ou en [".size.width x 2: .size.height x 2"] selon l'"argument" *clickWell: onclick: create instance and "put it under the mouse cursor" c'est presque pareil du point de vue utilisateur, par contre c'est très différent niveau implémentation *touchTarget: onTouch: if toucher is valid: nowCompleted *challenge: (greenMouse) rainbow: there are multiple targetSlots and the objective is to fill all of them *challenge: randomness: on part de [""] et on a des opérateurs [append random letter] edu: juste en dessous de l'opérateur [append random letter], on montre le sac duquel la lettre est tirée * edu: il y a une zone pour mettre les rebuts et un compteur de rebuts (* 0 simultaneous n-touch, "composite touch" ==> nTouchEngine this could be a way to discriminate objects: those which trigger the n-touch and those which do not **touchSlot hardcore transformation: from icObj.typeX to icObj.typeY - transformer une forme en nombre - transformer un texte en son - transformer une équation en un composite comprenant le membre de gauche et le membre de droite le dev doit être un peu costaud **yielder::fromAudio : press 'start recording', speak, press 'stop recording' : recorded audio is then transformed into a number, or an operator, or whatever corresponds to what you said **freeDrawingAnimation recorder: the whole drawing process is recorded **AudioFreeDrawingAnimation recorder: audio is recorded as well ((*architecture::challenge: composite(well, composite(operators), target) voire composite(composite(well), composite(operators), composite(target)) 06 février 2021: ((* the canTouchFunc problem : le problème est le suivant: un objet a besoin du contexte pour estimer une condition et il ne sait pas ce qu'est le contexte. Seul le contexte peut lui fournir les informations dont il a besoin. le problème est le suivant: touchSlot.canTouchFunc(above, below) n'a pas assez de above et below pour donner réponse satisfaisante, il manque des paramètres. plusieurs solutions : (1. touchSlot.will["touch"]: mutate canTouchFunc juste before it's going to be used: le contexte écoute la fonction et la mutate just in time 2. touchSlot.canTouchFunc(above, below, context): on rajoute tout simplement un paramètre => touchSlotConfig.facade 07 février 2021: 0 Paul: 0 petit personnage qui donne les instructions 0 deux modes d'exercices différents ** 0 calcul mental un peu comme le golf: scoring comme le golf: par, 18 trous 0 bouton recommencer et pénalité de 1 point 0 ou système de seuil comme au golf 0 ou alors on ne peut que recommencer trois fois un challenge puis ça donne une pénalité 0 difficulté croissante (comme le mini golf) 0 apprentissage par le jeu, la notion de score n'a pas d'importance on va jouer avec l'âge de ma grand-mère, en fait je ne le connaît pas, c'est pas grave, on va dire que c'est x. 0 première partie chaîne de caractères 0 au départ on se trimballe la grande chaîne de caractères 0 niveau 3: ["l'âge de ma grand mère"] * [+ "l'âge de ma grand mère"] = [2 x "l'âge de ma grand mère"] 0 niveau 4: ["l'âge de ma grand mère"] * [x "l'âge de ma grand mère"] = ["l'âge de ma grand mère" ²] => utiliser une inconnue dans les coulisses 0 ensuite l'inconnue 0 deux niveaux enchaînés: 0 [y] * [x 2] = [y x 2] 0 [y] * [x 2] = [2y] 0 "ah c'est bon je me souviens, pour avoir l'âge de ma grand-mère" 0 au bout d'un moment, le personnage compagnon choisit de remplacer 0 parcours 1,5 avec la règle suivante: on n'affiche pas le résultat intermédiaire simplifié mais la version parenthésée ** 0 GlanceTouchSlot: _while_ touched : simplified expression is previewed 0 SHU: utiliser le jeu de façon répétée pour s'améliorer (un peu comme les assistants de touchTyping), un peu tous les jours ==> "I was growing up big like a Superman" 0 parcours 0: pas de score, pas de par, on peut "se tromper" autant qu'on veut 0 troisième parcours avec uniquement des équations pour cette fois ci faire de l'entraînement *** 0 BlueMouse (==GolfRedMouse): _if it has been mutated_, then when dropped: the previous well is moved to the drop position pour l'instant on ne va pas trop s'intéresser à ce concept car il cristalise les "erreurs" 0 en fait il y a deux pars: 0 dans un essai spécifique: le nombre d'opérateurs touchés 0 le nombre d'essais (== de greenMouses utilisées) *edu::challenge "injection" (inject challenge in presentation): addNewChallenge(screenRect): compute the coordinates to fit in screen rect **edu: client-server benefits: teacher can be real-time moderator of student room (la cybernétique: wire power) - big-brother: oversee what individual student is doing - shutdown: close all sessions if students are too much agitated - course MC: "sharp control" course flow - show exercise - close exercise - lock/unlock move in student room - teacher can freeDraw hints in student room *golfCourse: ui: use golfCourse standard pattern: (ball), teeing, (fairway, green,) hole, flag *golfStep: onComplete: - show arrow pointing to next course, a big fat red arrow 0 icObjType = "arrow" icObj.orientTo(point) - fill golf course with golfStep.score (when zoomed-out, we see big numbers and arrows) backgroundColor(score): bronze: above par silver: par gold : below par edu: de cette manière on peut voir comment l'élève réagit à la difficulté croissante *sexy/sexiness: - greenMouse trail - decorations: associate an image to each golf course (for example, an image from ALOI 1000) - card aura - rainbow - card back - factions : grand colors - rare card / foil - stack *greenMouse: mode: survival: (== "endless") time is extended by n seconds when completing challenge challenge is mutated with new values|operators when completed **greenMouse: forbidden values: gmValue cannot be x or else gm dies (there are forbidden nodes on the gmAllPathsGraph) **challenge sequence::segue: how to transition from challengeX to challengeY 08 février 2021: *greenMouse golf: "impossible? step": gm initial value is 0, operators are [x 6] [x 7] [/ 3] [/ 42] and targetValue is 42 - player has to think outside the box and use a [+ 1] operator, available on the _previous golfCourse_ - the 2 golfCourses are visually fusionned (to give player a hint of what to do) ***CURSES! :) *icObj.type = "gmRebirthWell": there is actually no real well, only the gm respawning -> icObj.type = "bornAgain_gm" ** bornAgain is a _curse_, same as greenMouse **fucked-up maths (== curse operators): - delayed operators: a delayed operator will apply _after_ another operation is applied. [after operations: x 2] - 'just before' operators: a 'just before' operator will apply just before operation is applied [just before x 2: + 1] - doom : gm will die after n turns - amplification/minification/replacement: operator right-side value is mutated before operation is applied: [x 2] will for example be 'felt' as [x 20] **- "karma curse": - "next life": curse which applies to the bornAgain - "eternal curse": curse which applies to all the replicas. One can't get rid of this curse. - "feed me"/apoptosis curse: If object is left without interaction for n seconds, it will die. *bizarre ideas: no-copy curse: object cannot be copied ((*une idée c'est 100 lignes de code et 10 autres idées qui se ramènent. *edu: c'est intéressant de proposer le même challenge mais avec l'ordre des opérateurs changé car l'élève un peu distrait va retenter son "parcours glissé" qui fonctionnait avant et va se rendre compte qu'il ne fonctionne plus maintenant. 09 février 2021: **challenge: consume stack of targets : well does not change but top card of targets' stack is removed on completion edu: this would be a nice mode for training: students has everything in sight and knows it's over when stack is emptied *challenge: consume stack of targets with finite initial stack edu: pour se concentrer sur la bonne gestion des ressources *score: score is decreased by 1 for every new attempt **modulo: greenMouse value is modulo n ***the mole: touchOperator does not trigger if greenMouse is below (zIndexWise) : we can imagine 0-assignment walls or even complete contours, from which player would have to consider using the 'mole move' or bird move, if we consider that touchSlot triggers when greenMouse is below (it would be more coherent with stamping and soaking) **challenge: wall of challenges / challenge pointillism: completing a challenge colors the tile. An image slowly appears with more and more completed challenges. dev: how about 500 challenges ? 1000 ? performance: ** 0 touchSlot.local_listen ** 0 canvas.local_redraw *edu: ux: parentheses: in unsimplified expression display mode, when chaining 1 * [+ 2] * [x 3], it would be nice, just before applying [x 3], to add an animation which shows the user that 1 + 2 is now (1 + 2) à la limite: carrément montrer "x has a higher priority than +", ajouter les parenthèses et appliquer l'opérateur colorier l'expression en fonction de la priorité de son opérateur racine colorier les opérateurs en fonction de leur priorité "pour appliquer une priorité supérieure, il faut emballer" *edu: les bons jeux edu et les mauvais jeux edu: la jungle 10 février 2021: ((*la couleur (==la composition de couleur que l'on voit) a une influence sur le moral. Suffit que le fond soit un peu trop aggressif et c'est mort, on n'a plus envie. **edu: computer science: scope, visually: say we have a "visual local variable" [x] (~un peu comme une greenMouse) in a visual scope [S] (~a playField), then in the same way as for a classic local variable x, we could have another [x] in another scope [S'] and the two will be completely hermetic/alien. **challenge: 'overuse golf': il faut faire un nombre de coup _supérieur ou égal_ au par pour pouvoir valider le challenge. **challenge: 'Ratatouille golf' ou "Pourquoi faire simple quand on peut faire compliqué ?": il faut utiliser au minimum n opérateurs différents pour pouvoir valider le challenge. (((**la vision: rendre visible l'invisible (pour faire un tremplin vers la compétence "voir l'invisible" que l'on souhaite acquérir) (((**le moteur: toujours avoir l'impression d'être libre **challenge (computer-science): destroy ftw: : student has to destroy the right object to be able to complete challenge example 1: every time a touchSlot touches an object, a counter increases near the touchSlot the player has to use the touchSlot 5 times but, for the challenge to be completed, player is only allowed to use it 3 times an object is responsible for the counter increase, it is a visual representation of computer logic (and the object actually _carries_ this computer logic) if player destroys this object, as the counter is no longer increased, player can complete the challenge **Attempt: Evolution vs Manoeuvre: Evolution: greenMouse-focused passive stance: what the world does to me Manoeuvre: course-focused active stance: what I do to the world 0 icHook : les deux frères Will et Did (((n'empêche, tout ce caca qu'il faut écrire... : from magma to cristal, from heart shapes to trash heaps icObj.namespace ou icObj.family, par exemple: icObj.namespace = "golfStep4", icObj.namespace = "golfCourse7" pour savoir quel objet "appartient à qui" on retrouve les bonnes vieilles marmites: "label: value" ==> icObj.type = "labelValue" (==composite(label, value)) (l'informatique des dinosaures) *edu: [score] au dessus de [par] (limite avec une barre entre les deux) pour glisser au passage un petit mot sur les fractions. On peut imaginer mettre à côté une progressBar qui est débordée si on dépasse le par. **edu: flipping operators: flip animation transforms operator into inverse operator. example: [x 2] becomes, after a flip, [/ 2]. ** edu: when the golfStep challenge is completed, we flip the operators, we flip targetSlot: it becomes the well, we flip the well: it becomes the targetSlot. Student, after some attempts, will begin to understand that they have to do the reverse path. 11 février 2021: *golf: endScreen: nom du parcours, tableau de score et médaille *golf: startScreen: nom du parcours *golf: tutorialScreen ((on s'écarte de la vision originale (== à la The Witness) mais c'est pas grave. *autoPar / golfChallenge constraints: - path must stay between 0 -100 and 100 - path must uses rich composite numbers ** "AND THEN HE YAWNED" 12 février 2021: paralysis :( *golf: hacker/cheater: get total_score below 10 by cheating **edu: allow cheating but explicitly show "cheating" when cheating and on end screen **golf cheating: 0 "that hole seemed nearer": ball_1 in hole_7 0 golfCourse tampering: same principle but operators are exchanged so that, at first glance, there is no cheat edu: general cheating schemes: ugly: - end screen tampering subtle: - varX as inputY - level tampering **challenge:factoryChain: on left-side: maps to create core process values on center-side: values core on right-side: reduces to create result value ----[+ 1]-----> [x + 1] ---| | [+] -> [4x+1]---| [x] --[* 3]-----> [3x] ---| [-]---> [(4x+1)-1/x] | | ----[inv()]---> [1/x] -------------------- Some blocks may display an _expected_ value, and the consequent value. two flavors: type: user types what he thinks is correct make the chain valid puzzle: empty slots must be filled with pieces *endless: recycle golfCourse VS create new golfCourse **icObj.type = "repeater": when actioned: contained operator is applied times [R <5> ] [ [x 2] ] [ ] ? crocodile-style ui à la Scratch ? **edu: challenge rework: on completion (or later on): challenge is proposed again, but under a new, reworked form - propose challenge.ver2 with different operators from [+ 2] [+ 2] [+ 2] [+ 2] [+ 2] spam to [R5 [+ 2]] to [+ (2 x 5)], from [x 2] [x 2] [x 2] [x 2] [x 2] spam to [R5 [x 2]] to [x (2 ^ 5)], from [/ 2] to [x (1/2)] (slight change of vision) - propose challenge.ver2 with ver2.input = 2 * input and ver2.target = 2 * target ver2.input = 10 * input and ver2.target = 10 * target, etc. - propose challenge.ver2 with all components' values scaled by 10 scaled by 0.1 scaled by 10^6 (((*l'adn, c'est le code qui a été retenu, donc normalement c'est du bonheur (par rapport à du code pourri ou du code sale) **edu: practice: corrective feedback helping: (https://en.wikipedia.org/wiki/Control_engineering), create next step wrt previous steps attempts Appuyer là où ça fait mal dev: evolutionary computation, Resilient control systems *edu: display evolution: show graph of greenMouse value evolution **edu: inverse operators on top row: each bottom row operator has an inverse counterpart on top row: when student has "made a mistake", student can always cancel their mistake by applying the inverse operator 13 février 2021: ((*j'aime bien le problème de nommage de operator, quand on ne fournit seulement qu'operatorFunc. Si on connaît le code de la fonction, alors normalement on peut nommer correctement. *edu: group-covering operator set: so that there always exists a path to the target - ℕ-covering operator set: to drive student into using [x (-1)] *pretty operators: [/ 2] -> [□ / 2] *edu: challenge.deceiving_rank: check solving paths for lasagna trees built from the super operator set: {operators} + {inverse operators} some students may try to solve "[48] --> [38]" using [+ 10] * Il y a un gros travail à faire autour de "C'est quoi un challenge difficile ? C'est quoi un challenge facile ? C'est quoi un 'bon' challenge (pédagogiquement) ? C'est quoi un 'bon' challenge (gameplay) ?" petit à petit (=="gradient fractal") faire passer de [+ 1] à [- (-1)] à l'indifférence [+ 1] ou [- (-1)] *edu: est-ce que ça apporterait quelque chose que considérer des opérateurs qui acceptent seulement un certain type de valeurs d'entrée ? (par exemple: seulement des nombres, seulement des symboles, seulement des fractions, etc.) *edu: un peu risqué: fraction as a certain number of turns (oriented unbounded angle) 0 easy composite rewrite: composite.parts["x"] = y; *challenge: greenMouse = RangeNode: toutes les opérations sur les intervalles *challenge: revolver operator (== operator cycle): once used, operator becomes operatorCycle[n+1] 14 février 2021: **edu: BiggieSmalls: bigger font for what is important: artificially create a foreground and a background in TeX expression - solving an equation: MAKE 'LAST' OPERATION BIGGER ---| /| /__\ | / | / \ --| (x + 1) = | / | | / ---| | /___ ^ | |___ this is the last operation that was applied **edu: cherry-picking: [save (previous) challenge] / [copy (previous) challenge to clipboard] quand on a trouvé quelque chose d'intéressant au challenge aléatoire que l'on vient de rencontrer ((*L'approche phénoménologique: les maths interactives, ça demande de passer par l'étape (plus ou moins chiante) de _programmation_ des activités. Les maths interactives, ça tombe pas du ciel. Après on en tire les conséquences qu'on veut. *rep_eternal VS rep_living: how it feels never to die ***0 en fait il faudrait un symbole pour chaque opération: unitful operation (=="node_b" is unitful (=="node_b" is a valuenit)): combination multiplication: · Quantities multiply and units combine. Some units are lost in the process. d = v · t partition division: / We search the valuenit of a part if we partition into n unitful parts. unitless (==scalar) operation (=="node_b" is unitless, it is a "true" number): scaling multiplication: no symbol We scale by . ("mother" unit is preserved). unscaling division: : We unscale by . ("mother" unit is preserved). quantity multiplication: × We search the quantity of taking left member instances of right member. quotition division: ÷ We search the quantity of bottom member present in top member. Le langage fait apparaître des "unités invisibles": quand je dis 3 demis, je peux me dire que mon unité est le demi, et ma quantité est 3. Quand je dis "Trois demis fois un quart", en fait, - je multiplie les quantités : je fais trois fois un, ça donne 3. - je combine les unités: la moitié d'un quart c'est un huitième. Résultat final: 3 huitièmes. Trois demis divisés par un demi == Trois demis partionnés en 'un demi': Trop facile, ça fait 3. On peut passer de 3 demis à "1,5 uns". *edu: "Bon je vais où maintenant, vous me montrez ?" infiniteCanvas program X clickless student multimouse 15 février 2021: 0 Atelier_: zone de dev pour icObj ou pour une mise en scène d'icObjs 16 février 2021: **edu: (mainly for client/server): evanescent freeDrawing: teacher can write hints or indications which gradually vanish **mathNode.toTex(): custom: to inject color for example ((*hack: use (x 1^id) to tag sub expression **edu: speed evaluation: l'élève a 3 secondes pour toucher le bon target pour par exemple: * ("faire rentrer") les additions simples et moins simples (9 + 2 = 11, 9 + 8 = 17, 7 + 4 = 11, 8 + 7 = 15, ...) ("faire rentrer") les tables de multiplications ("faire rentrer") les relatifs **0 ux: make it _readable_( {size, fontSize} ) **operands: argument operand VS parameter operand [x] * [+ 3] ^ ^ ^__ parameter operand | |_ operator |___ argument operand **edu: challenge: from x to expr: ver1: same operation set is used to create targetExpr and 'growingExpr' easy: one instance of symbol, operand order is left to right normal1: one instance of symbol, random operand order (là on est au coeur d'une difficulté des élèves: passer d'un parsing left-to-right à un parsing plus global) hard: random operand order, sometimes parameter operand is an instance of symbol ver2: different operation sets are used to create targetExpr and 'growingExpr': student has to mentally simplify to find the right operation easy: simplify one step (+ -): [+ 2] * [- 3] into [- 1] normal: simplify one step (x /): [x 2] * [/ 6] into [/ 3] hard: simplify two steps: [x (3 + 10/5)] into [x 5] ((*A challenge mechanics for every 'learning step': expliciter toutes les petites difficultés des élèves: transformer l'escalier à grosses marches en tremplin (((* maintenant j'ai comme une "tendresse" pour les opérations genre [x 2] *"operator simplification": [x [2^4]] = [x [2 x 2 x 2 x 2]] = [x 2 x 2 x 2 x 2] (on peut retirer les []) 17 février 2021: 'INDIRECT' * 0 indirect touch: contactArea is the only entryway for touch =>targetTouchSlot.facade on top, targetTouchSlot.touchSlot at the bottom, so that player can see the two expressions distinctly when try to submit answer * 0 indirect hold: if I grab greenMouse's tail, I grab the whole greenMouse. Same thing with any other body part. (0 sometimes algebrite fails to recognize that two expressions are equal 19 février 2021: **challenge: Different ways: get to target via n different ways inspiré de 2 + 2 - 2 / 2 = 5 2 x 2 - 2 / 2 = 5 **challenge: greenMouse in tuxedo: greenMouse displays numerical expression instead of value, target displays value *fill tool: 0 bounded fillable 0 find if there there is a bounded fillable around cursor 0 create object which fills 0 unbounded fillable 0 create unbounded fillable (dynamic object) *greenMouse: pure operators [+],[-],[x],[/] 0 gm_calculator edu: [(x + 3)] * [-] * [(2 - 3x)] (((("HE PUSHED A ROCK" (((("AND THEN HE YAWNED" 20 février 2021: **challenge: mutating target: each time greenMouse mutates, so does target. It's kind of a curse. example: linear evolution: target := target + 2 exponential evolution: target := target x 2 (better be quick) cyclical evolution: target := target + 2 then target := target -10 then target := target + 2 etc. 21 février 2021: **adaptive pov(==bound pov): pov follows activeSelection size: if object is shrunk by an operator, then pov follows **size-restricted operators: operators only trigger when greenMouse size is compatible edu: put [x2] or [+0,01] size(10^-2) operators around _or inside_ a size(10^1) [/1000] operator *gm: test-tube operators: there is a test-tube wrapper around operator which forces greenMouse to be touched in a particular direction ______________ |[2 x] <--<--<--<-- [3 + 4] ==> [2 x 3 + 4] |_____________ **bag: put/pick (==push/pull) push x1: touching object pushes 1 instance of it in the bag push x10: touching object pushes 10 instances of it in the bag ** random pull (==random pick): touching operator random picks an instance in the bag **challenge: fill bag then "random deliver" (target must be _attained via random picking_) **challenge: multiple chained random deliveries (one may try again, and again, and again) **0 ustensil: operator can be dragged to touch other objects and gets back to its original place when released **edu: easy arrowing: measure: create measurement arrow next to object **number fonts: even number: round odd number: spiky prime number: noble 0 tex fonts 22 février 2021: **challenge: cube target: 1. player can manipulate target to understand it better: [turn left], [turn up] operators in order to know what target is 2. player has to turn and mutate side and turn and mutate side of greenMouse cube to match target cube example: cube painting dice painting (paint dots) *Scratch-like: any colour you like https://github.com/nicolaspoulain/scratchTeX **greenMouse: boulangerie-pâtisserie: - greenMouse starts with coins - there are bakery operators: [get baguette (1,00 €)] [get croissant (1,20 €)] - each time greenMouse touches operators, greenMouse loses money but gains object - unavailable operators (not enough coins) are grayed edu: même chose: un parcours à l'endroit puis à l'envers (revente au prix coûtant) permet d'introduire les expressions littérales puis les équations avec des prix inconnus 0 regarder le travail des grands: Scratch: https://github.com/LLK/ dependencies: ** - http://paperjs.org/ - plein de trucs de Google... (???) (!!!) 23 février 2021: Quantum Protocol is very good: supergraph, mastery, research, activationCountdown, different activation types: initialize, when , execute, ... *supergraph (==story graph): we organize "keyGames" (~superKeyframes) in a graph **"research": player unlocks new objects when they have enough mastery **challenge: random in range => narrow range: every turn tick, greenMouse metamorphoses into random number in range. Yet, "source range" can be mutated using operators in order to narrow down possible outcomes. **0 icObj.parts.curse.parts.counter, icObj.parts.curse.parts.curse_row **a countDown curse can be put on _a challenge_ ((curses for everyone :) ((*coop game: one player controls greenMouse, the other can cook operators *benecurse: touching benecursed operator adds counters to targetValue's countdownCurse.countdown ***reactiveAnimated: mutating one property mutates the others, in order to stay on animationPath (==lifespanObj) example 1: { progress: 0.12, index: 1, <--- mutating index results in a progress quantization color: someColor(0.12), } example 2: { progress: 0.4, name: "ozij fozjf", wealth: 5000, nb_of_children: 1, } 24 février 2021: 0 algebraic expressions easy unequal checks: 0, 1, -1 **greenMouse: units: [12 people] * [/ 4 people] = [3] **greenMouse: dotted line: periodic mutation **greenMouse: back to binary operators: operations operands can be swapped (dnd) **redMouse: back to binary operators: three (or two) red mice as left and right operands, left operand is also "receiver" WOW: https://mathsolver.microsoft.com/fr/solve-problem/7%20%60times%20%208x%20%20%5E%20%7B%202%20%20%7D%20%20%3D3?r=bi&ref=bi **multistep operation/multistep inverse operation (why not trying harder ?) example: [x] * [(3? + 4)/5] = [(3x + 4)/5] [(3x + 4)/5] * [(?x5-4)/3] = [x] ((*il y a le test fonctionnel: regarder s'il y a des bugs, et il y a le test "goûteur", le test qui se demande si un humain va accrocher. *terminalMathNode: x vs ((((((x))))) greenMouse: expr to x: * medium: propose 'reduced' operator when two same-priority operators are chained example: [((3x + 5)/4)*12] --> [x]: propose [x 3] instead of [x 4] or [/ 12] * medium: propose equivalent operation: [- (-1)] -> [+ 1] **greenMouse: binary representation of numbers: 0110011010010 - shift: left / right - invert bits (~) - add 25 février 2021: **challenge: greenMouse: clear target stacks in turns: player has to find the path to clear target stacks in least turns - numbers - number exprs - litt exprs **challenge: greenMouse: given _hypothesis_, complete challenge example: _hypothesis_ : _x = 4_, [3x + 7] --> [74], using operators: [+ 1] [x 4] [- 6] [- 7] **challenge: greenMouse: suites: player starts with _n=_ and [value(u_n)], operators are [u_(n+1)] [u_(n+2)] [u_2n] etc. touching operator [u_(n+1)] does two things: it updates greenMouse and it updates _n=.._ display: "n=+1" **ux: tablet: _dragArea_, displayArea, contactArea ((il manque un symbole pour dire c'est une expression ou c'est une opération. e3 / 2e VS o/ 2o. **challenge: greenMouse: from expr to x: medium+: depth: 10 (ça a l'air hardcore mais en fait c'est toujours la même chose et ça permet de rendre 'acceptables' les grandes expressions) edu: on pourrait envisager différemment les niveaux de difficulté: easy: découverte prise de contact medium: pratique courante prise en main medium+: renforcement, automatisation, prise de confiance hard: désautomatisation, ouverture, prise de recul *0 save/load gameSetup (save/load anything (don't limit yourself to one serial type)) 0 simplify: same priority == same "simplification level": [frac((7x+3),7)x10] * [x 7] should yield [(7x+3)x10] (((*qu'est-ce que ça va devenir tout ça ? poussière, chose publique, big money ? Should I give a fuck ? Pourquoi fait-on des enfants ? **simplify: factorize **simplify: animate simplifcation process: like combos in Tetris (Attack) *** edu: tool: clock_simplifier: perform simplification at each clock tick Parenthesis removal step can be considered a first-class simplification step. (après on peut en débattre, mais je trouve que le mieux c'est de ne pas mettre la difficulté "parenthèses" entre parenthèses) *yellowMouse (==chickMouse): comme le tri des poussins, on la balance là ou là **challenge: yellowMouse: evaluate (numerical) expression 1. player drags expr to choiceSlot 2. the expression is drawn to the center of the challenge, in the "center stage" display zone 3. the expression is then clock_simplified until the solution is shown 4. player's choiceSlot then turns green if correct (or red if incorrect) 5. challenge terminates (with success or failure) 0 class Simplifier *icObj.type = "simplifyZone" : when icMathNode is inside, a top layer simplification is attempted every second (comme des coups de marteau, un petit côté maréchal-ferrand) **"It's not maths, it's a card game." because the mathematical object is in your hands. 26 février 2021: a day without coding, a day of blah blah **ux: coterie composite: this composite appears automatically when objects are close from one another and there is a legitimate relationship linking them the main reason of this object is to be able to move coterie objects without having to click a lot (== without having to compose or group them, then decompose or degroup) **ux: preempt user actions: create easy objects for future actions *card game: crack the code: find x, y and z - card cost depends on the "filtering power" of expr [z](5): highest filtering power [3z+y](3): medium filtering power [5x+3y+z](1): lowest filtering power - card evaluates when entering field - the game ends when one of the players has successfully found x, y and z (*greenMouse: equation systems: il faut trouver un moyen de rendre ça facilement manipulable 0 tex: one color for each number place EN has nice words place, place value, face value **number is composite / myCustomNumber / "mon nombre avec jantes 20 pouces": simple is already complex (~text_destroyer: "text's not just text") 0,271 avec - le 0 des unités: noir et bold et Arial 100%, - le 2 des dixièmes: rouge et italic et Liberation 80% - le 7 des centièmes: animated: rainbow gradient wave - le 1 des millièmes: curse: only appears when in invisible light area etc. http://adereth.github.io/blog/2013/11/29/colorful-equations/ => 0 RichMathNode 0 PositionalNumber {} **number is banana: 0 https://github.com/pkra/mathjax-img 0 Xy-pic — Typesetting Graphs and Diagrams in TeX Xy-pic is a package for typesetting graphs and diagrams using the principle of logical composition of visual components. \xymatrix{ . . . } **RichMathNode: number has a color stroke (draw in number, and this trait accompanies number (the whole thing is a composite)). If number increments, color stroke is still here. number has hat number has (**sentence tree: [turbulent] | [Il] [très] |--[était]--| 27 février 2021: **bad calculators (game on the internet): 'exact par' as "same same but different"-variant source (((Tu rentres dans l'environnement d'une librairie et au bout d'un moment, tu comprends que c'est le gros foutoir. C'est clé en main, mais le sol est couvert de clés. et au bout d'un moment, dans tout ce foutoir, tu finis éventuellement par trouver ton bonheur... ((La dimension visuelle des équations: Comment faire quelque chose d'adapté pour les non-voyants ? on parle de membre de gauche, de membre de droite (lol genre les aveugles connaissent pas la gauche et la droite...) ((le dev c'est aussi perdre une matinée pour faire fonctionner une lib... ((*et tu te dis "putain je vais y passer la matinée", et effectivement, tu y passes __exactement__ la matinée: à 11h59, le truc tombe en marche, comme déclenché par un timer... ((*et au moment où tu crois que c'est bon, ça plante à nouveau... *richMathNode: color gradient (when adding 2 colored numbers) https://tex.stackexchange.com/questions/45744/how-to-put-color-gradient-to-desired-text-only/46034 ((toujours cette idée de repousser les limites, parce que c'est nul les limites. 28 février 2021: *greenMouse: challenge multiple endings: contamination: if greenMouse is contaminated then reward is X, otherwise reward is Y. edu: une manière de diriger **reactorMouse (==reduceMouse): mouse is covered with touchSlot, mouse is assigned result lore: elle est restée trop longtemps à côté d'un touchSlot ==> il va y avoir deux opérateurs pour chaque opération non commutative: [x-y] et [y-x] [x/y] et [y/x] [x append y] [y append x] **versatileReactorMouse: l'opérateur de surface change quand on la trempe dans un opérateur l'opérateur touché est [op] si op est un opérateur qui commute: on met op comme opérateur actif dans la _roue des opérateurs_ si op est un opérateur non commutatif: on bascule vers la prochaine version de l'opérateur dans la roue des opérateurs (exemple: [x-y] devient [y-x]) **turn reactor on/off default reactor operator is [+] **needleMouse: mouse destroys what it touches ***guzzlerMouse: (versatile)reactorMouse + needleMouse (aussi appelée worldEaterMouse, gluttonMouse) **challenge: guzzlerMouse: - en haut: des opérateurs [+] [-] [x] [/] - en bas: des nombres [4] [-1] [2] [0,18] **greenMouse.characteristic / [.is operator]: like a curse, but it takes part of greenMouse definition example: [.is evenNumber] [.is hundreds digit is same as units digit] [.is positive] [.is not a multiple of 3] **greenMouse: all possibles: example: let g be a 4-digit even number starting with 1 9 9 8 8 7 7 8 6 6 6 [1 | 5 | 5 | 4 ] 4 4 2 3 3 0 2 2 1 1 0 0 **challenge: whoami guzzlerMouse: end up with only one possibility from an all-possibles mouse ***challenge: from expr to expr: [split top layer] [split all] 1. split expr into components 2. build new expr from components edu: expression rebuild: from expr to same expr ** various starting stems: reactor core is randomly assigned to a node optional: faire travailler la mémoire: on ne raffiche plus l'expression de départ 01 Mars 2021: **reactorMouse: when split: one component is _reactorCore_ ((==interaction stem)) **challenge: fruityMouse: each digit symbol is replaced by a fruit symbol so player has to: 1. play with operators to get a grasp of which fruit corresponds to which digit 2. using this new knowledge, use the operators to make target value edu: quand on applique plusieurs fois l'opération [x k], comment peut se transformer le chiffre des unités ? et avec [+ k] ? etc. medium: avec des entiers hard: avec des décimaux hardcore: avec des complexes ***splitter: output: composite (weak splitter) fireworks split [1] [2] \ | / \ | / _ [split] _ ==> _ [composite handle] _ / | \ / | \ [+] 0 animation: explosion rect splitter| shape splitter: separate square into 4 pieces separate square into 2 triangles etc. **operator: assemble: randomly assemble composite parts (arr_icMathNode) to create a single expression (icMathNode) **clone fireworks: when : separate into clones, each following a different direction operators: when touching an operator: separate into 4 clones, each following a different direction labyrinth: at a crossroads: separate into 4 clones, each following a different direction **operator: next type (==morpher): [nextType]: object cycles to the next type it extends to example: icMathNode --> icText --> ... **operator: "equals": [=] (sûrement plus qu'un simple opérateur) (((the composite hack: ONE IS ONE IS THREE (((Je ne fais que dérouler les possibilités qui se montrent, et ainsi de suite. Comme un enfant qui joue dans le bain. Si je démonte, juste après, j'ai envie de remonter. Si j'ai une collection, juste après, j'ai envie d'avoir un seul objet. ((déjà dit:*PolyHandle-Puzzle: puzzle created using composites created from subsets of same components set 02 Mars 2021: ***AriadneMouse (==PoopooMouse): when touching a touchSlot: untransformed mouse waits where it touched (==poo poo), while transformed mouse continues "under player's click" Branch-cancel PoopooMouse: moving a poop destroys all descendants from this state edu: this way, all intermediate states appear on screen (even the unfruitful) 03 Mars 2021: **reactorGreenMouse: ux: non commutative operator double touch - when reactor is in (|y-z|) position: when touching [-] again: instead of selecting (|z-y|) reactor operator, select (|+|) and change [n] to [-n] - [n](|/|) becomes [1/n](|x|) when touching [/] edu: c'est une autre manière de présenter les choses, qui permet d'afficher un réacteur simplifié (un seul -, un seul /) **greenMouse: operator is unsimplified: instead of showing [+ 40], show [+ 8x5], or [+ 8 x 5] medium: [+ 8x5] (renforcer les tables) hard: [+ 8 x 5] (renforcer les priorités opératoires) **customerMouse: [stickman] [bank(-20 € on bank account)] [buy oranges(2,10 €)] [buy tea(3,30 €)] ... edu: les équations, les relatifs (le découvert), ... ((**fabricjs: change activeObject _while dragging_ (please make it easy for future generations) 0 recréer les "conditions de départ" du drag https://github.com/fabricjs/fabric.js/issues/5820 https://github.com/fabricjs/fabric.js/issues/2753 04 Mars 2021: **supervessel: on move start, show supervessel.contactArea (==supervessel.contactArea.isVisible = true;) **edu: 32bits/64bits: faire sentir la différence avec des "petites instructions" (32bits) vs des "moyennes instructions" (64bits) **(*)challenge: split,recompose,match 1. ClassX instance is split into components (for example: a litteral expression is split into "component mathNode"s) 2. components are randomly recomposed into a _new instance_ of ClassX 3. player has to match the new instance with _something equivalent to it_ in a pool of possibilities edu: ça fait le lien entre les expressions littérales et les probabilités **challenge: recycling ground: player may split many source items and put the components in a bag, and then use the components in the bag to create target item the idea there would be to split fewer items possible 05 Mars 2021: supervessel: cargo 0 manage touch with supervessel 0 the old way: business as usual, but with supervessel inclusion 0 the new way 1: event capturing: only supervessel is touched 0 the new way 2: event bubbling: touch bubbles up to supervessel ***infiniteCanvas::operate on active object (can be done while held :) thanks to supervessel) - any operation - associated ux: une main sur la souris, une main sur le clavier **Split active object == split supervessel cargo edu(/pres): language: split a sentence edu(/game): maths: split a refined object, an object which is the result of many operations **supervessel:make active object(s) touchable on peut rendre le truc encore plus mystique en activant cette opération quand le supervessel touche un opérateur spécifique au supervessel **"greenMouse ex machina": while holding empty supervessel, inject a one-life-only greenMouse under it **IcObjectTypeOverlay: (or IcObjectTypeContainer) - object type symbol on topleft corner |--------- | S | |___| | | - icObject type <-> border color mathNode hotpink string Como image Rajah freeDrawing Dark Violet shape Gray video Cola bag Baker's Chocolate #553516 **challenge: simultaneous release: player must use supervessel to split an object into component and then release/snap them "simultaneously" because when snapping an individual component, the other slots close down ((*split void: on peut faire surgir des paires d'objets opposés du vide canvassien (((the software psychotouch: when nothing explicitly indicates a bug, but still, you feel it under your mouse click **(*)challenge: multiType challenge: some operators are type-specific, so user has to use morphers before using type-specific operators edu: renforcer l'idée de _nature_ d'un objet, et des propriétés et opérations de cette nature 06 Mars 2021: ***shard transformation: morph to typed representation == show icObj.shard cette transformation peut être déclenchée en utilisant une touche de clavier: "operate on active object" - morph to text description example: "Il y a un lac à l'arrière plan. Et au premier plan, une voiture et un chien." *** - morph to code ==>This way one can modify the behavior of icObject. (==> DSL) *** - morph to inner world On peut zoomer dans l'inner world et intéragir dans cet inner world. **greenMouse: fractions: colored 'lengths' - on touch: append to greenMouse easy: no number tag is shown: only colored rectangles medium: number tags are shown on every rectangle (1/10, 1/2, 1, 1/20, etc.) medium+: improper fractions: 8/3, 5/2, etc. hard: target is a number (there is no target rectangle) **collection-only operators (==bag operators): pour montrer la distributivité **edu: The Mirror 0 l'inverse de split: join 0 incorporate geometry: [ ["i"] ] [ ["w"]["o"]["r"]["d"] ] * [merge] = [" i\nword\n e\n a"] [ ["e"] ] [ ["a"] ] 0 animation: center attraction **math: prevent join from creating "divide by 0" expressions ** allowed mathNode / allowed subgraph *que se passe-t-il quand on join() des objets de types différents ? 0 hierarchie de types 0 appeler ça autrement: merge, marry, unite, combine 0 trouver le bon verbe pour chaque situation **maths: brainfuck: use operator symbol as terminal symbol name (3+ + 4 - 4/ x 3): i think this could get funny and mad **logical puzzle: all must be true - problèmes de tri - self referential puzzles: there are 3 objects in zone A edu: sur la nature des objets: zone A: any number inside is < -5 zone B: any number inside is even zone C: any number inside is only composed of 1 and 2 as digits zone D: any number inside is a perfect square zone E: the sum of numbers inside is 20 etc. 07 Mars 2021: *challenge: reuse: create touchOperators by splitting expr *join: triangles semblables **"dropper un reset": erase the past principe: - les élèves abordent une notion via un ensemble de challenges - il y a des stats qui sont reliées à la notion: pour faire simple succès|échecs - une fois que l'élève réussit un certain nombre de fois d'affilée sans se tromper, un bouton "reset" peut apparaître pour réinitialiser ses statistiques. "'Oh, j'ai droppé un reset', s'écria-t-il." - cela donne la possiblité à l'élève de se la jouer en exhibant ses "flawless statistics" ** edu: on peut même jouer sur les stats pour ouvrir de nouveaux challenges: min. 10 attempts and 90% success ***greenMouse: properties: [A=>B] * [B=>C] = [A=>C], target is [A=>Z] edu: on peut aussi expliciter: [A=>B] * [B=>C] = [A=>B=>C] **greenMouse: equation::equivalent equations: show <=> sign: [A=B] * [x 3] = [A=B <=> 3A=3B] or build a composite: with head part and trailing part [ [ [A=B] [<=>] ] trailing [ [3A=3B] ] head ] only head can interact with other objects/be operated on ***landing stage: where a new object will be spawn in - default: infiniteCanvas - usage: new objects spawn in landing stage (object or infiniteCanvas, or infiniteCanvas.layerX)) this is the main mechanic for object enrichment 08 Mars 2021: **challenge: fractions: la planche à découper: on laisse des morceaux sur la planche quand on prend une fraction d'un objet - [x (1/3)] means we cut in three equal parts and then we pick one part - [x (2/3)] means we cut in three equal parts and then we pick two parts and join them together **edu: redMouse/redMice: fractions: montrer la droite graduée au plein milieu de l'aire de challenge, disable z-scroll for redmouse (**the taoist way of understanding numbers: numbers and operators arise mutually. L'un ne va pas sans l'autre. *Same function, different worlds: append_left(a,b), append_right(a,b) (==append_left(b,a)) in the string world and in the math world are very different. quelque chose du genre: a x 10^(floor(log(b))) + b 09 Mars 2021: (**J'aime pas les soi-disant jeux qui à la fin te disent: Bon bah tu t'es trompé 4 fois sur les 10 épreuves. On te donne 6 étoiles. Pour moi, "l'important c'est de passer". Peu importe le nombre d'essais, l'important c'est de franchir l'obstacle. L'important c'est de ne pas être empêché, de pouvoir voir ce qu'il y a après. On est pas là pour sanctionner, on est là pour faire progresser. 10 Mars 2021: **l'"objet opérateur", du coup, il est à gauche, ou à droite ? Dans ma tête, il est parfois à gauche, parfois à droite. Ca dépend. Ca dépend des jours ? [1,5 x] 24 VS 14 [x 2] **"Et ce serait dur de mettre un système d'analyse des réponses des élèves ?"(merci David) 0 Prélever les données. Il faut mettre des capteurs de données pertinentes dans le code des challenges. 0 Traiter les données: 0 librairies de stats 0 edu-tailored libs: il existe peut-être des bibliothèques "edu" toutes faites 11 Mars 2021: **VS game (vertical split screen): green rain - on each player screen, it's raining operators - player can try to create the biggest number possible - sometimes, when a player has "made a good move": it's raining [x 0] operators on opponent's screen 12 Mars 2012: ***error management: keep the machine running: from player mistake to platform|runtime error - frame is cropped: next challenge frame corresponds to player input: No mistake, no cropping. - memory error: challenges spawn regularly, if player takes too much time to solve challenge, there will be too much objects hence a memory error. - screen flood: previous challenge is cleaned wrt player's success: No mistake, perfect clean. So that, we mistakes accumulate, the screen is flooded with previous' challenges parts. ((**l'ensemble des nombres que l'on peut produire avec un ensemble de symboles: from graph theory to number theory **octoMouse(==icExoSkeleton(mouse)): exoSkeleton provides "realization limbs" to value-only mouse: area: interaction: - grabArea player --> mouse - contactArea mouse --> other objects - displayArea mouse --> player - decorationArea mouse --> player - ... (?) - internalsArea(==valueSlot) mouse --> mouse (a priori, not visible) => supervessel{octoMouse{value or expression}} ... ça fait pas mal d'emballage supervessel, when solely cargoing an exoSkeleton, is like an "exoSpirit" possessing the exoSkeleton *operators are "naturally" reactive: makeReactive([+]) * [n] = [+ n] **glassMouse (curse): mouse breaks if something illegal is done **glassMouse (curse): equations: mouse breaks if left side is mutated without having right side mutated the same way en fait ici, on a affaire à une octoMouse avec deux "valueSlot"s et un "decorationSlot" (pour le signe =) **manage simulteanous touches: - open touch phase - collect all touches - close touch phase - resolve all touches **equations: gemini-headed octoMouse: when one operations is applied to left side, it is automatically applied to right side too 13 Mars 2012: *color gradient between exolimbs (pour montrer les relations entre exolimbs (ce truc-là, c'est le "toucheur" de cette facade, ou plutôt des internals représentés par cette facade)) example: yellow-blue gradient between display and contact ***3D-->2D: _canvas lock/unlock_ (à la The Witness): player moves freely in a 3D environment and can focus on boards (which are (in)finiteCanvases) edu: one board for each subject (at least) edu: board pov stays where the player left fun: wormholes from one board to another (==portals) 3D.location1-->board1.position1-->board2.position2-->3D.location2 => Ce serait bien de voir un jour ce point réalisé. more madness: move 2D object from canvas to 3D HUD (which is a permanent 2D space) and then back to another 2D "true" canvas even more madness: 3D HUD is z-cruisable: like the glasses overlay of the hi-tech military. Write stuff in green to match the cliché. *touchSlot (active) VS contactArea (passive, delegator) => touchSlot.touch(contactArea.delegate) **compose: create equation: create equation composite from 2 icMathNodes **poopooMouse: equations: poopoo log: when transforming an equation, the previous version is added to a log (displayZone), so we can see the equivalent equations history 14 Mars 2012: (**Il y a déjà le concept de greenMouse dans The Witness. 16 Mars 2012: SOLVE ET COAGULA (Il y a déjà le concept de greenMouse dans les motifs de déverrouillage des téléphones (((*from audience to vidience: not hearing but interacting **Z-Puzzle: find the right homeScale using "membrane markers" -hardcore: optional marker (marker may or may not be used) (~téton sorti ou téton rentré) ***Black-box onion puzzle: there is a black area on the screen which contains operators, player has to discover what are those operators. The "onion trick" is that an inner-layer operator can touch greenMouse only after the outer layers have been traversed. bbbbbbbbbbbbbbbbbbbbbbbbb b[+ 2][- 1][+ 7][/ 8]b b[+ 4][+ 1][x 9][- 8 ]b b[/ 10][^ 2][x (-1) ]b bbbbbbbbbbbbbbbbbbbbbbbbb the more layers the harder it gets ***Black-box onion greenMouse challenge: the goal is not to snap operators on placeholders. Rather, it is a classic greenMouse challenge. Player has to find a route to attain target. Of course, route could imply coming in and out of black box. there is a touch sfx to identify when a touch occurs while in the dark easy: operators are contoured (((comme quoi ça peut parfois être productif d'aller traîner son skate sous la pluie ((on a besoin de mécaniques qui se marient bien avec l'"objet d'étude" (*en fait l'idéal serait de se poser pendant un certain temps avec quelqu'un pour dépiler still_shute, pour le transformer en quelque chose de beaucoup plus lisible 17 Mars 2021: *edu: geom greenMouse: [rect shape] * [+ 10] = [rect shape "with 10 added"] , [rect shape] * [x 2] = [rect shape with doubled area] **edu: unification via variety: _après une certaine maîtrise des concept-challenges, pris isolément_, mettre des instances (aléatoirement) de différents concept-challenges les unes à la suite des autres pour unifier tous les concepts. (((**loups-garous avec des nombres: les impairs: loups, les pairs: villageois (C'est drôle j'ai toujours considéré les nombres pairs comme plus débiles que les nombres impairs.) (**une salle de classe, c'est comme dans une salle de concert, t'aurais envie de sauter partout, mais tu peux pas, _y'a pas la place_. L'espace individuel est contraint. ((((FUUUU... donc là je perds du temps à cause d'erreurs du moteur, alors que j'ai envie de programmer des exercices... 0 decomposition operators: - prime decomposition [decomp_product_prime] - digit*power sum decomposition [decomp_sum_digpow] **A fraction doesn't care about how it's been produced, it has no regard for its past. 1/27 does not care if it's 1/(3x3x3) or 1/(9x3) or (1/3)/9 etc. Whereas a litteral expression is nothing but a transformation log. A numerical expression is halfway between those 2 ends. *edu: fractions [1 / 20] * [x 2] = [2 / 20] [1 / 20] * [x 2] = [1 / 10] Il y a deux [x 2] différents ici: on pourrait s'amuser à créer des rôles pour le 2 du [x 2]: - un qui aime monter sur la fraction (== qui aime multiplier: [1 / 20] * [x 2] = [2 / 20]) - un qui aime détruire le dénominateur (== qui aime diviser: [1 / 20] * [x 2] = [1 / 10]) et ensuite dire que c'est la même chose. 18 Mars 2021: *can't escape from curse: split mouse must still be cursed, even when in split form - ? every bit is cursed ? - ? there is a curse halo ? 0 singleOperatorize (~flatten) 0 [/ 3] -> [x (1/3)] 0 [- 3] -> [+ (-3)] 0 remonter tout le priorityShell... **black box number challenge (==conditional simplification): what you see is not precisely true - [56] is displayed, but internally, number is [4 x 2 x 7] - when player does [56] * [/ 8], simplification does not occur, [56 / 8] is displayed (internally it's now [4 x 2 x 7 / 8]) - when player does [56] * [/ 4], simplification does occur, [14] is displayed (internally it's now [2 x 7]) (hardcore: only last term simplification is allowed: [4 x 2 x 7] * [/ 4] = [4 x 2 x 7 / 4] and [4 x 2 x 7] * [/ 7] = [4 x 2] ((c'est marrant, on peut faire new math.ConstantNode(-2) mais pas new math.ConstantNode(1/2) ((a x (b x c) = a x b x c does not seem to have the same flavor as f(a, f(b,c)) = f(a,b,c) but that's what we mean sometimes. It's like the multiplication is diffused, and "x" is only a separator. En fait on est devenus dans tout ce qui est binaire, parce qu'on a continué à vouloir écrire sur une seule ligne et que, dans ce cas, tout élément a une extrémité gauche et une extrémité droite et c'est tout. La même chose pourrait être conclue avec le temps qui s'écoule "dans une seule direction seulement". 19 Mars 2021: (0 class PriortyShell ((comment appeler l'inverse de l'inverse ? exverse ? deverse ? preverse ? averse ? 20 Mars 2021: (((*"universal 7" == 7, _all representations accounted_ 3+4, 2.9+4.1, -5 + 12, etc. ** 0 simplification with "keep unsimplified factors order" is not that simple to do **redMouse: fractions:: add|subtract fraction challenge: split, rework parts, gather **operator decoration: decorate operator function with simplification function ("same same, but different" :) ) **conductive area operator: (mainly for binary operations (add, append, ...)) example: [6] * [+]{[4]} = [10] and [4] is consumed **greenMouse: temporary rest zone (==SafetyZone): when released in this zone, greenMouse is not reset **green greenMouse(en français: souris verte écolo): objects which have been produced using greenMouse are destroyed when greenMouse is destroyed edu: player may produce helpful representations of greenMouse when trying to solve a puzzle (typically: fraction with prime factorized "ators") **greenMouse: intermediate target slot (==viaTargetSlot) with _the same green mouse_: 1. touch intermediate target slot(s) 2. touch final target slot => when greenMouse resets, intermediate touch slot resets too 25 Mars 2021: **expiring mutation: object resets to previous state on expiration edu: fractions: decomposed version is shown for 3 seconds 0 prevent target "exopeek" version from touching target slot 26 Mars 2021: ***BulletMouse (meta-challenge): "Deterministic road to success (==TIM/Eets style)": edu: ROAD TO PROGRAMMING - Player has no control over mouse. - Player interactions are: move operators so that bulletMouse run into them push start button Bullet will then start moving and encounter operators which will mutate bullet. Challenge completes if bullet has the right value when touching target slot. première forme: "linear" deuxième forme: plumbing style: some operators change the direction of the mouse easy: value changing operators on one side, direction changing operators on the other side hard: {value, direction} changing operators troisième forme: not your average bullet: ~"polarization" "polarization" operators: when bullet touches a polarization operator, bullet polarization (==color) is set example: [* --> blue] polarized operators: bullet is only affected by operators which polarization matches bullet polarization if the bullet is blue, then a red operator will have no effect example: [if(red){ }] hardcore: polarized polarization operator: [red --> blue] edu: this is somewhat similar to proof construction quatrième forme: multiple inputs: 2 bullets, n bullets... edu: addition de fractions * use conductive area operator _[+]_ edu: pour la soustraction, il faudra utiliser [x (-1)] sur l'un des deux opérandes cinquième forme: [bullet start] is a touchable operator sixième forme: slider-controlled time (give the user some "greenMouse feeling" back) only forward, for a first approach **bulletGolf: getting closer to "real" golf: [stop] operator -there is a long road between tee (==bulletStart) and hole (==targetSlot) (player has to dezoom to see targetSlot) -some parts of the golfCourse require the ball to have a certain value, or to have a value in a certain range -player has to use [stop] operator to end his shot at a certain position and prepare for a new shot, starting from there *greenMouse::greenMice: SafetyZone conductive operators: fractions: edu: 1. challenge with one greenMouse and target slot is right after _[+]_[1/30]_ (addition is prepared) 2. challenge with two greenMice and target slot is right after _[+]_ 3. challenge with 3+ greenMice ( reworked(reworked(A)+B)+C )... **parameters galore conductiveOperator ("conductiveFunction"): [set] color, value, shape operator has multiple parameters, _each with a different type_ so that when operator is actioned, parameters are used: [conducted] or default value for the missing *icPlatform: object released on a platform is added to the platform: when platform moves, platform and objects on it all move together, resize together, rotate together, flip together, etc. (like an adhesive board) *dropTouchSlot: touch activates when object is dropped on slot *equation platform: ---- ---- [ ]____[ ] [ __=__ ] [___] [___] 27 Mars 2021: *floodTouchSlot (le contraire d'un dropTouchSlot): when _touchSlot_ is slid and released under an icObj, then touch activates *shovelPlatform: when _platform_ is slid and released under an icObj, icObj is added to platform terrace 0 platform on a platform ((*conductive operator: there is "true input" (active input),"conducted input"(passive input == context) and output => "context operands", calculer c'est d'abord parser **snapSlot-based conductive operator: If slots are empty, displayed default values are used. If slots are filled, snapped value is used. **challenge: cooking table: conductive operators (_[+]_,_[-]_,_[x]_,_[/]_) are in the center of the challenge area. Player has to cook target number using "raw ingredient" numbers. *conductive operator: when operating settingA: consume conducted_operands (~> conducted_operands == input) settingB: retain conducted_operands (~> conducted_operands == context) (**less code could be written if "generalized proxies" i.e. inheritors, decorators, containers, composites, and any kind of "I contain that kind of thing you operate on" were all managed the same way 28 Mars 2021: **(*)draw the operator: 1. user draws an operator, 2. system recognizes what they have drawn, 3. drawing is now considered a legit operator *edu: impossible button: user has to press it 15 times for it to trigger this way, player doesn't get the habit of skipping or gets it _less likely_ **upgrade icObj to icObj2: upgrade [x 2] to [x 2 / x 2](fraction operator) upgrade [x 2] to [x 2 = x 2](equation operator) upgrade [x 2] to [area x 2](shape operator) *edu: fractionOne_operators animation: every 1.5 seconds, operator display swaps (either it shows [x 1] or it shows [x 4 / x 4]). So that subliminally, student gets that value isn't changed. *edu: gmSafetyZone could be used to "pause" (the pause being either student-initiated or teacher-initiated) 29 Mars 2021: **challenge: in order: n "sticky" greenMice: we can start with any of them and then stick the others in order so that any greenMouse in this challenge is a reactorMouse which then becomes a greenMouseComposite (releasing the composite makes the greenMouse parts go back to their place, and the linker "<" parts are destroyed) ((*C'est drôle ; un truc simple à dire n'est pas forcément simple à coder. 30 Mars 2021: **eduDemo/eduQuestion: c'est un challenge modifié pour qu'il soit présenté à la classe on pourrait dire que c'est le tutoriel 1 edu: première eduDémo devant les élèves: frac add (:)) **eduQuestion: "What is the value of the GM at the end of the path ?" ** WOW effect: GM actually follows path when [PLAY] is pressed **[PLAY] operator is just another operator: Le bouton "Run" dans Scratch est à l'extérieur de la zone de rendu. Dans l'infiniteCanvas, il est à l'intérieur. C'est un opérateur comme les autres. 31 Mars 2021: *edu: demo: distributivité: [1 + 3] * [x 2] = [2 + 6] *"atomic fraction simplification" operator (example: [/2 / /2]): does not trigger if simplification by is not possible ***interacting with student's writing: LET THERE BE LIFE 1. students draws some operators on their paperbook 2. an image capture device is used to bring the paperbook image to the infiniteCanvas a. image is captured (teacher's phone) b. image is conveyed through network to computer running infiniteCanvas c. image is imported to infiniteCanvas d. image is analyzed and parsed: drawings are now legit operators (a. and b. can be performed with ChingView) 3. let's interact ** colored feynman slash Il y a du dev à faire à ce niveau là (custom Mathjax tex package) edu: each simplifiable factor pair could be slashed with a different color **tree analysis output variety: - mark nodes in-place - spoof nodes in-place (example: ConstantNode(1) becomes MySummerNode(1)) - analysisOutput object (with its a structure of its own) ((*Any step is a discovery step. Any step is a hacking step. (bricolage / make things happen). Nothing comme zizi 02 Avril 2021: **edu: corrigé des exercices: plus facile, plus rapide 1. importer l'image de l'exercice 2. ramener les opérateurs adaptés 3. capture d'écran OR even better: 4. serialization **decomposition operators: many flavors decompose step by step: output: primeA x compositeB in prime order in "easiness" order output: compositeA x compositeB random decomposition recompose recompose step by step **fractions: rational number decimal period eduDemo gm: [x=1,517...] operators: [x 1000] [decomp:sum something + x] [- x] [/ 999] [show approximative value] then same thing with random decomposition challenge **challenge: integer / not integer *0 edu: any input: 0 STT(speech to text) 0 OCR (optical character recognition) (of selected screenArea) 0 Math OCR lib in js ? => use Emscripten to create a js lib **reification: "scale" representation (number "is a" thin and long rectangle): "reictangle" **reification: "duda" representation of a numerical/litteral expression (using colored squares) edu: this will pave the way to the first-degree equation resolution process **shape operator: [x k]: many flavors [x 2 <->] (scaleX: x 2) example: [] * [x 2 <->] = [][] [ ^] [x 2 |] (scaleY: x 2) [ v] [x 2 diag] (scaleX: x sqrt(2), scaleY: x sqrt(2)) [x2 (diagonaly copy)] example: [] [] * [x 2 diagCopy] = [] **shape operator: reshape ("gravity") [] [] * [gravity x] = [][] [] [] [] * [gravity y] = [] **shape operator: reshape using wall collision [] | []| [] >>> | --> []| wall ((*L'idée ce serait de faire passer subtilement cette idée : Si on s'intéresse à la _transformation_, alors a * [x 1] = [a], c'est très différent de [1] * [x a] = [a]. D'un côté on a une idée plutôt arithmétique (~entiers, cardinal), de l'autre côté on a plutôt une idée géométrique (échelle). La commutativité, c'est quelque chose de bizarre. **R-Puzzle: Rei-Puzzle: from black unit-length shapes to colored scaled shapes puzzle there are "rei operators" ([+ 1], [x 2], etc.) there are color operators ([blue], [red], etc.) (or even [nextColor]) the montage area is a gmSafetyZone edu: c'est un bon moyen de faire sentir le côté "travail sur l'échelle"(agrandissement, réduction) de [x 2] *fraction: [x 2 / x 2] rei-edition: this subdivides the reictangle, nothing less, nothing more *icBloom: composite({core,facets}) [bloom] operator (==start bloom with touched as core) [petal] operator (==createFacet and add to current bloom) ? bloom de bloom: à quoi ça pourrait bien servir ? 03 Avril 2021: *challenge: assign, alloc, dealloc: faire sentir ce que c'est qu'une variable *homebringer: z-scroll of one object also z-scrolls _related_ objects (*0 try to have multimouse working on infiniteCanvas 04 Avril 2021: **challenge: add digits this requires "welling", either via operator or using keyboard shortcut *slotableGreenMouseWell: well has two slots: one slot for the original (input) and one slot for the clones (output) so that player can take back the original and put something else in the input slot **(*)"wellSelection": wellSelected objects will _clone on drag_ and original will keep their place **edu: keyboard keys statistics: ***IC KEY CONCEPT: "I Am Dismantling in Order to Re-mantle" / "Sorry Engine, I've got a call-up from Master User" / resource everywhere / sheep everywhere ("T'inquiète pas, ça va repousser.") En prenant n'importe quel morceau sur n'importe quel objet, je peux créer des compositions intéressantes. L'idéal étant de débrayer, si un moteur est concerné, avant de prendre un morceau sur un objet. Mais _ce n'est pas obligé_. Embrayer/débrayer (en anglais: engage/disengage, ce qui est cool parce que ça commence comme engine) => Les objets doivent être conçus pour être démontables facilement. exemple: Je tape un texte. Quand je tape la touche "e" du clavier, un objet écouteur de 'touche e pressée' incrémente un compteur et une réification du compteur en forme de rectangle se met à grandir. Même chose avec les autres lettres. Au bout d'un moment, j'ai des rectangles de différentes longueurs correspondant aux fréquences des lettres. J'ai envie de prendre chacun de ces rectangles pour fabriquer un histogramme. Je peux le faire en les déplaçant (displace) de leur objet porteur (en l'occurence de l'écouteur de touche). Si je n'ai pas débrayé, l'histogramme va être synchrone avec les appuis de touche ultérieurs. Si j'ai débrayé (disengage) avant de déplacer, les rectangles étant maintenant déconnectés de leur objet porteur, il n'y aura plus de synchronicité. Soit les écouteurs dépouillés (shorn) vont attendre qu'on leur glisse des rectangles de réification ([furbish]) et ils seront readyiés et on pourra alors réembrayer (engage). Soit les écouteurs dépouillés (shorn) vont attendre qu'on leur glisse des rectangles de réification ([furbish]) et ils seront readyiés et l'engage se fera automatiquement (.isEngageOnReady == true). Soit les écouteurs dépouillés (shorn) vont être réparés de façon automatique (.isAutoRepair == true) ou de façon manuelle ([repair] operator or shortcut key). Soit les écouteurs dépouillés vont être laissés tels quels (parce qu'on ne les utilisera plus). Réinitialiser les écouteurs, c'est réparer si nécessaire puis remettre les compteurs à zéro. TLDR: displace != dismantle dismantle = disengage, displace repair = furbish, engage reset = repair, reinit **RCMouse: use WASD to move mouse around fun: joystick support 05 Avril 2021: **colorPicker: comment n'ai-je pas pu y penser avant ? **RCMouse _system_ (à la 'Press Ctrl'): mouse1 touches buttons which make mouse2 move, mouse2 touches buttons which make mouse1 move **conductive operator, symbol edition: [x [...] [...]]: with this operator, we can build [x [2] [y]], [x [-1] [z]] **greenMouse: smart additive decomposition * division example: [192] * [smart decomp wrt /16] = [160 + 32] [160 + 32] * [/ 16] = [10 + 2] [10 + 2] * [simplify] = [12] ***YOUR OPERATOR: ask students to imagine an operator of their own **greenMouse: equations: 1. classic gm challenges 0 challenge: get to [x = v] 0 challenge 1 : 3x + 18 = 54 0 challenge 2: 3x + 18 = 5x + 60 0 challenge 3: 5(x+1) - 12 = 13 0 develop and reduce 0 continue using the standard algorithm 2. smart pool challenges: (student has played with the mechanism, it's now time to be a little clever) 0 challenge: smart pool of operators: some operators are clever (multiply by fraction for example) 3. choose answer/follow path challenges: 0 challenge: touch the right answer: resets challenge on wrong answer 0 challenge 4 : can only get to 5x = 25 using operators 0 challenge 5 : no more operators, you have to do the maths in your head 0 you have to follow the right path 06 Avril 2021: *gm: relative numbers: challenge with [- 100] [- 10] [- 1] and their inverse operators 0 [show], [hide] show/hide composite *edu: the equation movie: in the top area of the screen, a movie is shown with someone performing physical operations. at the bottom, play can mimic what's happening using operators. example: in the video, we see someone manipulating apples, putting them in bags, moving the bags, picking some apples from a bag, etc. *edu: on peut amener de façon naturelle les opérateurs [opposé] et [inverse] ([0 -] et [1 /]) 1. on fait d'abord utiliser [+ 2] et [x 2] 2. on fait ensuite utiliser [2 +] et [2 x] ((et on voit que ça fait la même chose, à part peut-être quand on écrit sans calculer (y × 2, ça s'écrit pas pareil que 2 × y) )) 3. on fait utiliser [0 -] 4. on fait utiliser [opposé] 5. enfin, éventuellement, on pourrait envisager de ressortir des cartons le "petit moins" [-] **curse/uncurse operators: - standardCurse: curse will withdraw only when withdrawal condition is met (example: when touching [uncurse()] operator) - singleUseCurse: withdrawal condition is "curse has been consumed" == curse actionates once then withdraws - hardCurse: there is no withdrawal condition examples: [curse: autoSimplify] [curse: autoColorize] **(*)context operators:: meaning-based operator example: [(2y + 10)/2] * [10 == 5 x 2] = [(2y + 5x2)/2] \meaning-based/ so then [(2y + 5x2)/2] * ["simplify"] = [y + 5] edu/dev: this means that we have to anticipate and identify what the student would like to do. maybe via a pool, but it must not be cluttered What would be nice would be to identify common mistakes and propose the operator they would like to use _given their 'mistaking context'_, to show them that the rules of maths make it roll not as what they would expect *greenMouse: exponent operator: [ ²](unary), [^ 2](unarified binary) 07 Avril 2021: **(*)[meta] layout is meaning. When looking from afar, you know what it's about. If it is a challenge about addition, write a "+" sign with the operators/objects involved. [] [][][] [] If it is a challenge about multiplication, write a "x" sign, etc. edu: when student thinks about the challenge, subliminally, they will see the symbol perspiring from the layout. **slice cut: cut image following slice path edu: pour montrer les produits de fractions: 24 * [x 1/2] * [x 1/3] **atelier: neither a challenge nor an eduDemo, but a place where the player can tinker **atelier::create a fraction [num <- 1] [num <- 2], ... [fracWell: ?/?] [den <- 1] [den <- 2], ... edu: so that there is a sense of number line, and proportions if player touches [num <- 6] and then [den <- 3] player then feels that the numerator is 2 times the denominator edu: this seems a boring atelier at first glance but: - player can then generate its own fractions to turn sheet exercices into manipulations - player subliminally gets used to the assignment operator, and to the relative proportions - player does not touch keyboard 08 Avril 2021: **(*)more kinesthetic feeling of number: touchScreen touches shrink/grow: pinch and spread (p-IN-ch"/"p-OUT-ch) player pinches/spreads a reictangle in a number bloom : number shrinks/grow accordingly 2-finger pinch for 1D-scale 3-finger pinch and 2D-scale 12 Avril 2021: ***ic digitalBootstrap: from basic skills (move the mouse) to advanced skills (spawn, copy/paste, group/compose, protoSlots, ...) 1. use the mouse:: leftclick challenge1: player must handdraw a line from A to B this challenge is "greenMoused": if leftclick is released before reaching B, handdrawn line is erased challenge2: same thing with obstacles: if an obstacle is touched, handdrawn line is erased 2. use the mouse:: move object to touch other object 4. use the mouse:: rightclick challenge3: player must handdraw a line from A to B, but point B is not visible on the screen: player must rightclick to pan current visible area challenge4: line is a redMouse: player must draw, pan, draw, pan, etc. to reach point B 5. use the mouse:: scroll challenge3: player must handdraw a line from A to B, but point B is not visible on the screen: player must rightclick to pan current visible area 6. use the keyboard:: spawn object 7. use the keyboard:: copy/paste object 8. use the keyboard:: group/ungroup objects 9. use the keyboard:: compose/decompose objects etc. **mixed-selection copy, paste in outer software (specially Writer, Calc, Draw, etc. (==standard office software)) 13 Avril 2021: **flyTag: when an object enters flyTag's area (range or specific region) and flyTag's text matches object (object type, value, ...) then flyTag will stick to the object, as long as it remains in its covered area. edu: on peut imaginer une zone bizarre, pleine de mouchétiquettes, qui servirait à faire un rappel du type d'objet que l'on est en train de manipuler (nombre, opérateur, nom, verbe, adjectif, ...) ** single/multi management: there is a big area where player can choose how they want to play : single or multi player creates a round avatar and then manipulates it, as any other icObject, if it is dragged into a roomConnection slot: then players' active avatar spawn in a bounded-yet-infinite multiplayerArea .____ __________________ . o | ||o o || .____| ||you p2|| roomConnectionSlot ||________________|| multiplayerArea edu: some challenge may be multi only / single only **curveLength challenge: Player has to draw a curve from A to B with length in given range variant: A to B to C to D, each portion within a given range *the "* [operator]" process: for a mathNode-based operator: 1. findMathNodePathInObject(icObj) 2. if a path was found: apply transformation using path 3. return transformationOutput 14 Avril 2021: **(*) (madness) ic operating system: "everything is there" Sur le même modèle que l'OS dans lequel on se déplace en 3D et dans lequel le bureau, c'est vraiment un bureau. Mais ici, y'a pas de bureau, juste un gigantesque tapis d'enfant pour adulte, un bac à sable d'étoiles de travail. *V-scroll: change selected object opacity 15 Avril 2021: *(freeDrawn) overlay operator: connect different objects with (drawn) overlay operator, then release [ ] # [ ] [ A ######### B ] = [A + B] [ ] # [ ] *operator: pixel-of-color counter ***eduDemo::spawn wrt context: context can be: - active selection - current location: - current pov bounds - current subworld (example: the fractions world, the equations world, the adjectives world, the colors world, ...) - current activity ("active ity") - current time: - current "sequence" (example: little red riding hood) - current "frame" (example: the wolf is about to win) examples: spawn a 2x2 table with cell proportions: my active object spawn a multiplication table with starting number: my active object spawn the next sentence/the next character of the story ***eduDemo::switch to edudemo keyboard shortcuts: DSI (domain specific input), the input equivalent of DSL (domain specific language) edudemoX.automaticallySwitchToDomainSpecificInput = false; design: il va falloir définir les touches qui ne changent pas et les touches qui accueillent le DSI **(*)scripted operator: write your own code in operator's icText field, example: if() {} else {} ***scripted template operator: "don't write, just drag" snapSlots or platforms to host objects example: if(input is [<>]) {} else {} operator is functional when all its parts have been filled This is a 3-star idea because it enacts "code is data, data is code" * truth-value operators: [== 2], [> 2] slot-based truth-value operators: [== [<>]], [> [<>]] 16 Avril 2021: *undo/redo keyboard shortcuts dev: this part may not be fun **greenMouse: create sentence for the image. at each step, there is only one valid spelling, but there is no mistakeBomb ("Oh my god you made a mistake"). The sentence simply does not validate at the end. Releasing mouse resets sentence. examples: [[El] [niño] [esta] [jugando] [en] [la] [calle]]. [[Le] [chapeau] [de] [la] [dame] [s'envole]] 17 Avril 2021: **what is "to manipulate" ? use hands and handtools - slice (with or without sawcut) - tape/glue together - fold - press/pressure (varying intensity --> varying response) - make holes - rotate/scale/flip - arrange/dispose (move, align, center, ...) - superimpose - decorate/paint/draw/write - bend - pin - attract/repel - copy/cut/paste - bag/unbag - intrinsic manipulation (shake, press, etc.) - capture: photos, videos - hoard (i like it, i'll keep it) - build worlds, build stories - share - "make it roll" (domino effect) (display an intrinsic property of an "external composite" ("outrinsic" property)) ((what is in, what is out ?)) - repeat: same conditions, same results ? - "gong" (tap and listen to the sound) ((y'a pas que l'image dans la vie)) **(*)slice anything:: slice mathematical expressions a sliced mathNode would create an expression and a "cutout operator" which can be seen as an _incomplete expression_ edu: this "cutout operator" could be used to try the operator against different values . [(x + 12) . / 3 + 5] --> [x + 12] ; [... / 3 + 5] . ^_ cutout operator (== half an expression, half an operator) dev: here the medium is the image representation of the mathematical object slice(mathNode.representations.2dImage, imageSliceProps) --> slice(mathNode, mathNodeSliceProps) --> array of mathNodes OR slice(mathNode.representations.2dImage, imageSliceProps) --> array of images --> array of mathNodes but we can do the same thing with the audio representation of the mathematical object example: someone saying "three p minus four times z" the slice could be done via: pausing the player at the desired time saying "slice" at the desired time and then we may process the 2 resulting parts ((*edu: objectives: allow _patterns_ ownershipping **paint: only paint inside activeSelection 18 Avril 2021: *textured path = svg (shape) + bitmap (texture) **sliceWell: slice something from the sliceWell and it's automatically cloned example: slice a letter in an alphabet board [ABCDE] [FGHIJ] **sliceClone(): command: slice something and it's cloned **edu: project: create a comic strip pick a sprite sheet on the internet (and maybe create a sliceWell or sliceClone from it) **edu: solar system (true scale): side view top view 19 Avril 2021: dev: il reste beaucoup de travail autour des doubleObjects ***examine,edit,promote: edit code using icObjects (give a way for people "very far from code" to tinker a bit) examine: bring some part of code to the infinite canvas in an ic-displayable form edit: play with icObjects to edit logic promote: when you're done editing or creating, transfer the object as code in the page script dev: forcément, y'a des composants de coeur qu'il vaudrait mieux laisser en lecture seule ***x's island: load the icWorld of other people into yours (be it offline or online) if you like someone then you add its world to yours so you can visit it sometimes to see what has changed (some kind of fa-iC-e book) there might be a giant hub connecting all worlds (iC-nternet) when you add someone's icWorld it could be only a proxy of it, so that when you access it, the true owner, if at home, sees you in and can interact with you dev: il faudra des protocoles tout ça tout ça 20 Avril 2021: **greenMouse:: vectors vector transformations are displayed (we can see the 2D path followed by vector's end point) [(x ] * [ (0 ] = [(x ] [ ] [+ ] [ ] [ y)] [ 4)] [ y+4)] **greenMouse:: fractions and images: [img1] * [x (2/5) _vert] * [x (7/13) _horiz] = [img2] How many times img2 is img1 ? 0 setHomeScale so that, at "scale0", object appears to have this size **(*) img operator: convert to unit clones (img has been scaled and we want to know how much of the original it has become) [convert:uc _horiz]: horizontally aligned unit clones + horiz-scaled fractional part clone [convert:uc _vert]: vertically aligned unit clones + vert-scaled fractional part clone [convert:uc _prop]: diagonally aligned unit clones + prop-scaled fractional part clone [convert:uc _rect]: rect of clones displayed in horiz(scale.X (int + frac)) * vert(scale.Y (int + frac)) (four regions) [convert:uc _square]: square of clones (total: sqrt(scale.X * scale.Y)) displayed in horiz(int + frac) * vert(int + frac) (four regions) **anytime there is a math operation to do, use mathNode and operators **img operator: split into color component "rects": each "rect" size corresponds to color size in original image (rect can contain transparent pixel if necessary) **img operator: convert into colorComponent-ordered image edu: use image with few colors (3 to 5) to show that when scaling, scaling is distributed to each color 21 Avril 2021: **click&drag unitCloneScale: grab side control and drag, it instantaneously shows the unitCloneScaled object (== unitClone-converted scaled object) dev/ux: outche /!\ when doing proportional unitCloneScale: clones will 'overflow' the grabbed diagonal point => ? rep_orig / rep_ucs ? unitCloneScaled = composite({[unitClone] + fractionalPart}) ... edu: so then we can manipulate the "unit-bounded" parts **icObj.type = "xyloNumber": semi-xylophone which "depth" can be increased by click&dragging while zoomed edu: this gives another way of specifying/setting a number **greenMouse: scale challenge: target is a scaled version of the original object, operators are scale operators edu: create a challenge that seems impossible: player has to rotate the object to complete the challenge (and player has to find out this 'solution' by themself) **vert/horiz scale: - wrt object intrinsic coords - wrt coords in canvas (=> boundingBox...) - wrt operator coord system *snapRotate: allow only 0,45,90,135,180, etc. **keyDownSelect: keyDownToggle + select object (then you can keyUp it's okay): scroll now mutates object - color: select object while KeyC is down (now you can release KeyC), scroll mutates object color so zScroll is the default keyDownSelect **strokeWidthScroll ((there are ideas, then there is development which brings the ideas down in the real world so there is this discussion between vision persons and preparation persons "This may seem easy, looking at it from the clouds, but down there it's a bit more difficult." "We discovered this while coding, what do you think about it? Does it inspire you new ideas?" then there is actualUse (for example using the software for demos while teaching) which brings the features down in the real² world so there is this discussion between preparation persons and activation persons "The dancefloor is nice but maybe we could add sofas on the side, and bubblegum-scent diffusers." **machine: distribution board: output is expressed using clones of input zone "vocabulary" objects, each represented the number of times specified in factor zone | | input | output zone factor | output zone zone | zone | -------------- ---------------- | factor zone | input zone ver1: input is on left-side ver2:input is on bottom-side 21 Avril 2021: **edu: greenMouse: back to good old {[+ 1] [+ 10] [x 2] [x (-1)]} propose challenges in which, all else unchanged ("Ceteris paribus"): - target changes - initial changes this way the students will start mastering this operator set then, _when grinded enough_, we can propose another operator set **Monte-Carlo: spawn disk at random position in rect... ((There is that standing position in The Witness which is important. Students should be standing (more) in classrooms. 23 Avril 2021: *greenMouse: challenge: distances: when dragging the greenMouse, a carried variable is updated as the greenMouse moves from its starting point. Using [+] and [-] operators, the goal is to attain [target] value. when touching a [+] or [-] operator, the starting point becomes the position of the last touch. if [-] has been touched, the new distance is subtracted from the previous variable value. edu: this could be used to move from hypotenuse to vectors. 24 Avril 2021: 0 create tutorial directly using the software features **0 id collisions !!! 25 Avril 2021: **serialization: load infinishutes (==serialized states) programatically, treat them as first class objects edu: this way teachers could create specific classes quickly, by arranging existing material dev: il y aura du travail pour tout organiser, sauf si les composites deviennent robustes ((*faciliter la vie des profs (fabrication aisée de corrigés par exemple) et des élèves (possiblité d'écrire sur l'énoncé numérique (ce qui est très difficile avec un pdf) par exemple) 26 Avril 2021: ((Baba Is You is a great game: game mechanics + level design + aesthetics (no need to be too pretty, simply be consistant) **"touchable as a whole": composite.isTouchable == true and composite.parts.some(.isTouchable) == false *edudemo: from 1x1 square to 2x1 rectangle to sqrt(2)xsqrt(2) square : scale, split, join *image transformation: toColorHistogram(), param: nb_color_boxes for coarse/fine analysis **3d classroom:: 2d 'infinities' - every student has an infiniteCanvas on their table (this is their notebook) - every whiteboard in the classroom is an infiniteCanvas **3d classroom:: extension rooms: those rooms are tailored for the current course: students can leave the classroom and play around in those extension rooms ((*j'ai l'impression qu'en faisant du freedrawing à la souris, j'écris à peu près à la vitesse de mes élèves *draw over font and then define the result as custom font 28 Avril 2021: *edu: on bakery operators: It MUST be emphasized that, for human life to be worth it, human life practices are MORE than operations. You MAY MODEL them AS operations, but there will always be more in such practices. 29 Avril 2021: **scale-aware selection (cannot select something whose homeScale is too far from current scale) **probabilistic operator: [× ¿1-10?] (suite à l'envie de créer un opérateur "o:scale" avec scale proportionnel en réutilisant les opérateurs o:scale horiz et o:scale vert : **operator.type == "comp" (operation is a composite of other operation) this composition may be sequential or parallel **"compoper": compositing operator: this operator pipes the operators inside it 2 flavors: sequential and parallel - sequential may have an arrow to precise the order (default orientation: left to right) dev: this would mean projecting a key point of each operator on the arrow to determine the order edu: this operator would go along well with morphers ([math --> text] [append "!"] [text --> math]) - when in parallel mode, conductive composition operator may check if operator are compatible (== orthogonal) ***supereasy operator composition: conductive-platform compositing operator and, on top of that, supereasy facading: to hide the implementation edu: on peut ouvrir le capot et regarder comment ça marche **(*) spawn "ready to tinker" compositing operator with inner operators (== non-empty compositing operator) ***operator crafting / smart facade : supereasy compositing operator has a smart engine which allows it to facade what its inner arrangement of operators is equivalent to bad recipes (with incompatible output / input types for example) would be facaded as "bad recipe" edu: [[+ 2] then [x 3]] could be smartFacaded as [x 3 + 6] edu: [[+ ¿2-5?] then [x ¿3-6?]] could be smartFacaded as [x ¿3-6? + ¿6-30?] (though we lose information when displaying it that way) **snap-based compositing operator: un peu moins naturel que le conductive **text-based compoper: for creating compoper programmatically **'Z-fallback' operator: when operator2 is slid under operator1 (via zIndex) , if operator1 does not return "success", then operator2 activates *class Operation {} 30 Avril 2021: *ux: selectAll / removeAll selectAllInPov / removeAllInPov **modifiers: objects that change the behavior of another object dev: this may require a lot a work around platforms **modifier:: activation condition modifier **greenMouse X compositing: "2 and 2 only"-modified compositing operator: compoper is working only when this condition is fulfilled 3 and 3 only... So the game setup is like this: |---------------------------------------------------------------------------------| | [1] [---->] [---->] [---->] [42] | | initial value compositing operators target slot | | | | [+ 2] [+ 10] [- 1] [x 2] [+ 12] [/ 2] [+ 7] [+ 40] [- (-1)] [/ (-3)] | | operators to be composed | ----------------------------------------------------------------------------------- another interesting activation condition modifier: all compositing operators must be filled for target value to be 'touchable' **edu: randomness has drawbacks, BUT it has this key feature: players cannot "paste" the solution to the other players, they have to explain the mechanics,... which make them teachers :) **(*)conductive-platform activating operator: "actop": a platform whose sole purpose is to forward the touch to the operator that's inside (which could not be touched without doing this). That's what is meant with the word "activating". **modifier:: transparencer/obscurizer: an operator with these modifiers mutates what it touches into something transparent or obscure (== we can no longer see what it is) different flavors: when touched (permanent) / while touched (temporary) edu: a obscurizer actop would require the player to remember what the conducted operator is, when holding the greenmouse (look at the game setup above and replace the compopers with obscurizer actops) the player may pick the obscured operator out of the actop to give it back its natural appearance, but the player won't be able to do it when holding the greenmouse (edu: we could imagine a practice phase in which the player can fail a lot and then a course phase in which the player tries to have lowest overall golfwise score 01 Mai 2021: **(*)literal compositing operator: operator priorities are taken into account edu: to make a link between the "operator mindset" and the "literal expression mindset" edu: [[+ 2] then [x 3]] could be smartFacaded as [+ 6] or [+ 2x3] with 2x3 appearing in a different color edu: [[+ ¿2-5?] then [x ¿3-6?]] could be smartFacaded as [+ ¿{6-30}?] (though we lose information when displaying it that way) 6 8 10 12 9 12 15 18 12 16 20 24 15 20 25 30 02 Mai 2021: *presets (for users who don't like z-scroll by default) presetA: selected + scroll = z-scroll presetB: selected + scroll = scroll selected + shift-scroll = z-scroll for users who prefer selecting with right click, ... etc. *(*)from group-based multiSelection to composite-based multiSelection highlight cargo objects icObj.isCargo highlight parts when cargo object is composite **show fading border animation when trying to select an object whose homeScale is too far from current pov scale so that user understands that their selection attempt failed (composites, over and again: ***Sticky release: when sticky-releasing an object S over an object O, a composite is created whose parts are: [O, S] this way we can create complex composite very easily target recipient is highlighted ux: keyboard shortcut is: S first press activates sticky release behavior next presses cycle to next target recipient (Esc key cancels sticky release behavior dev: all this ux could be then reused when editing ngraph.tree 0 find an easy way to show/hide composite handle (because a lot of them will be created) 0 toggle composite recursive move amplification **(*)Sticky FreeDrawing: drawing over an object in "Sticky" mode creates a composite whose parts are: [object (original), freeDrawing (decoration)] edu: this way we can type text, and then decorate the symbols by freeDrawing over them, and then move the decorated text around, all in one go. edu: same principle for geometrical figures, which we would enrich via freeDrawing **Replace release: when replace-releasing an object R over an object O, R "now replaces" object O - in a composite C containing O: O is removed and R is added. R's 'space properties' are set to O's. - elsewhere: same principle (we consider canvas as root composite) **Decoration "Frame" (Begin/End): 1. user select an object O 2. user begins decorating (==decoration_begin()) 3. user creates objects 4. user ends decorating (==decoration_end()) a composite D is created, whose parts are [O, ...created objects] if O was part of a composite C, D now replaces O in C *Bloom decoration: add representation to a bloom object via decorating: i.e. decorate + bind (0 organiser un concours de création de 'peinture profonde' ***(*)inner recording: start recording, move stuff around, do operations, stop recording: a record object will be created. It is an "animation" operator (it operates on canvas objects to recreate the recorded animation) recorded animation == actionSequence multiple flavors for the recording: pov: - pov is part of the recording - pov is not part of the recording frames: - discrete interval frame recording --> tick tick tick... - meaningful keypoints recording --> bezier curve interpolation multiple flavors for the operator: - video-like - slider-based edu: this way we can roll the film back and forth to the students dev: this is gonna be tough eventSourcing compress moves: FourierTransform, Bezier curves game: we can then create challenges in which a greenMouse can press play button so that it makes other objects move and then greenMouse can interact with those moving objects and attain target we can record the activation of an animation operator, etc. omg we can split an actionSequence and join actionSequence chunks (Braid in iC, lolilol Event sourcing vs Command sourcing actionSequence may not be playable if objects are "too far" from the record initial configuration (== initial "revision") [rec reset] operator to put back objects in record initial configuration (== "update to revision"), so that actionSequence can be played Red dot on top left HUD to indicate that recording is ongoing edu: experiments with periodicity: Does this actionSequence comes back to the initial state when repeated a certain number of times ? semantic-recording: system analyzes what has been done and only stores "semantics": example: "smallest number was added to greatest number" so if you play it in another context, it will try to apply its semantic program on the working objects game: record then stay pressed on [activate] then some operators will be active when record is played **polysync recording: until the recording has ended, all object moves "start at 'time zero'" this allows keyframing multiple objects: {1,2,3} --> {1',2',3'} --> {1'',2'',3''} **"almost time zero"(== "time zero +") syncing: example: recording 1 : obj1 split into {obj2 + piece1} and move piece1 recording 2 : obj2 split into {obj3 + piece2} and move piece2 when the two recording are "time zero +" sync'ed, what we see happening is: obj1 split into {obj3 + piece1 + piece2} and move piece1 and move piece2 there are sync'ed but recording1 still starts before recording2: recording 2 is brought "as close as possible" to recording1: recording2 starts as soon as obj2 is available 04 Mai 2021: **(*)program by tagging: Baba #[is greenMouse], rock #[is operator], flag #[is target] (à la Baba is You) tags are sticky by default programming happens in 2 phases: 1. create objects (==spawn) 2. assign behavior (==tag) edu: this way, teachers and students can easily create challenges **scale tracks: an object following the track (==part of a function plot) will scale along accordingly example: linear track, exponential track many flavors: - hovered track: the track is below, but it's not physical, it's more like an idea, it can be ignored if crossed orthogonally - clinging track: the track is physical, and when getting too close, you are clung to it and must follow it till you find an "untrack opportunity" (like a Y) those tracks may convey a particular scale flavor: scaleX, scaleY, propScale, etc. edu: that would be a way to become familiar with function plots and variations dev: une sorte de snap dynamique (Maths DJ: when enough challenges, edudemos, features and worlds will be available, maths deejaying will become available (propose circuits in compositions) 05 Mai 2021: *3D virtual classroom:: group fork: 4 students fork the current classroom: same room but other students are no longer visible then at some point we could merge the different forks (for example: each group has a dedicated whiteboard to write on, a dedicated area to build things in) **sticky tentacle: click on point in object then drag, a sticky freedrawing starts with the pointed color at clicked point (=="tentacle") **top-right corner button: toggleTouchDevice (switch controls to touchDevice mode) *icObj.type = "pov"; edu: easily create transitions: move from pov1 to pov2 **icObj.type = "link"; A link is simply a line between the 2 objects **easyLink: freeDraw a line between 2 objects and then proper link is created **conductive link: when an object is operated on, all "conductive-link"ed objects are operated on too. **challenge: link, operate, link, operate... **composite-link: link is composite handle **area link: link between 3+ objects 06 Mai 2021: edu::chemistry: using conductive operators (example: [+ [CO2]]) 07 Mai 2021: user-initiated command (user --> obj) VS obj-initiated command (obj --> obj) example: user moving obj via holding VS touchSlot operating on obj when touched 0 local eventstore: "connect to oneself" ((the vision is to provide everyone easy-to-use powerful tools: provide easy animation recording to everyone would be so nice **(*)oob clone (==out-of-body clone): when grabbing object, you don't move it but instead you extract and move an out-of-body clone of it which can then interact with [move] operators, which operate on "real-body" obj =>=> statueMouse 10 Mai 2021: *burning (m/h)ouse: raisonnement par l'absurde: when the chain of equivalent transformations gets to a statement we know is false, all the poopoo statements burn backwards to end up "destroying" the hypothesis we now know was supposed wrongly. *[x2 / x2] operator applied on fraction reictangles: numerator is multiplied and denominator is multiplied so that the bloom now appears bigger, but it's the same fraction. 11 Mai 2021: (expliciter la subtilité: lever les ambiguïtés: opérateurs de séquence VS opérateurs d'expression avec les opérateurs de séquence, la priorité des opérateurs est décroissante suivant le sens de lecture 3 +S 4 xS 5 -S 1 = 34 avec les opérateurs d'expression, la priorité de chaque opérateur est fixe 3 +E 4 xE 5 -E 1= 22 "petit moins" (unaire) et "grand moins" (binaire) (ça vaudrait peut-être le coup d'essayer sur quelques élèves 12 Mai 2021: **time composition of icReplay objects: we display a spatial representation of time **ghost-based programmable [record/replay] operator: ("oob clone meets record"): user can grab a ghost from the operator and produce a path with it, then any 'free' object(==unheld, user-aloof (nothing to do with "free" representation)) touching the operator will follow the recorded path 13 Mai 2021: **poopoo path: - manual (record{ grab move poop move poop move poop move release }) where poop actions are user-initiated - auto (==throttled) - every , poop action is triggered (be it a spatial length or a time length) **poopoo vector path: poopoo_{n} orientation is determined by vector(from: poopoo_{n-1} position, to: poopoo_{n} position) **"keyframe programming": polysync-recording sequence: record_start/{next_keyframe_start}*/record_end edu: easy creation of complex animations: example: on top: [1] --> [ 1 ][ 1 ][ 1 ] at bottom: [1] --> [<---- 3 ---->] edu: pour expliquer les tris aussi, ce sera bien. On pourra enchaîner chaque étape. **(*)"define" operator via recording (=="def by i/o[]" programming) (Inductive Logic Programming) let's suppose it's a unary operator, whose behavior we want the machine to understand 1. we prepare an object in a desired state: inputX 2. we record our making the object interact with the operator, and then we edit the object so that it's in the desired outputX state 3. we end the recording and some magic configures the operator so that it now transforms inputX to outputX we may do multiple recordings to disambiguate: inputY * [op] = outputY, etc. edu: teach relative numbers: define operator via 4 * [op] = 3 and see what 0 * [op] equals to. *contextual operation (=="injustice" operators): what if 2 objects are similar, but as one is grabbed from the blue area, while the other is grabbed from the green area, they now, when operated on, yield different outputs. **le glitch du replay while recording: "object is somewhere along that path": on peut surement faire quelque chose de sympa avec cette bugfeature **activate(==enable) VS actionate(==trigger) **(*)machineGunReplay: replay 1000 times, and all that, in 5 seconds (==supereasy iteration) edu: pour montrer des tirages au sort: au début on le fait doucement, puis on enregistre une transformation et on la refait plein de fois on peut mettre un écouteur sur la valeur produite pour générer des histogrammes edu: pour montrer des évolutions de systèmes non-linéaires on peut mettre un écouteur sur la valeur produite pour générer un graphe de fonction ux: peut-être gérer le cas où ça crashe, essayer de contenir l'explosion. Cloisonner la zone pour protéger les objets autour au cas où. **edu: pretty loop: replay (n-1) times then, for last iteration, replay cropped chunk(==from start to destination keyframe (which was marked during recording)) when recording the sample, ensure that "nothing happens" when in the "moving back to the start"-phase **conditionally-activating conductive platform: operators inside it can touch incoming object if and only if the condition of the platform is met by incoming object conditionally-activated operators: **[break] operator: when in the "moving back to the start"-phase, touching this operator will end the loop prematurely the breaking of the loop is reified by the object being left next to the break operator, like a poopoo *[continue] operator: go back to loop starting position dev: find a path which is short, safe (==without any operator on the way) and pretty(== round-edged) to go back to the starting position **(*)[move] operator: many flavors: - exo-level [move] operator => miniScene transformation: in order to depict a [move] operator, we can use a miniScene in which, when touched by the [move] operator, an inner object (the "performer") will move according to the [move] operator (the miniScene has its own coordinate system) edu: when introducing this concept, it would be nice to use a small and simple miniScene in which the performer is almost alone (you may put a few rocks and trees, or the coordinate system axes, in order to notice the performer move) - same-level [move] operator: - when touching a non-part-of-a-composite object: object is moved accordingly - when touching a composite object and one part of it is the performer: performer is moved accordingly consequence: when touching the supervessel: performer cargo object is moved accordingly in supervessel. So the general impression is that the held object still moves, even if held. **[loop move] operator, [pretty loop move] operator 14 mai 2021: **[poopoo-path move] many flavors: - consuming: path is erased as perfomer moves - permanent: path stays there and many objects can follow it simultaneously **cart move/cart controller: object is in the cart (==platform). Cart follows track. A scrollbar based on a small representation of the track (for example: a straight line or a loop) allows user to control cart move along the track. **stepmania-like pace line: the "now" line progressing on a music partition edu: build choreographies with students edu: a bloom petal for the object "time". The pace line reifies the passing of time. 15 mai 2021: **[if] operator/[switch] operator in railway track (=="program") - highlight the "chosen" track and darken the others (la notion de variable ou d'objet (==espace mémoire, rétention) est plus ou moins déjà présente chez les élèves. Quand ils écrivent 4 / 2 = 2 / 2 = 1, en fait ils voudraient écrire: [[4]] / 2 --> [[2]] / 2 --> [[1]]. C'est-à-dire une séquence de mutations d'un même objet. Ils veulent décrire un morceau de vie de l'objet. Peut-être que cette notation ("avec cadre et flèche") leur permettrait de faire la différence entre : les 'performances'(auxquelles ils sont habitués): Maintenant, je fait bidule sur truc et il devient machin. ((Relié : utilisation, action, évènement, exécution, instance, apply(f, args), now, vie courante sémantique séquentielle les égalités ((Relié : propriété, règle, opérateur, programme, classe, f, anytime, loi sémantique arborescente Une autre façon de faire des maths, c'est de regarder ces allers-retours entre performances et égalités. Petit à petit dans la scolarité, on passe d'un système de notation {performance: A signe égal B (qui est bancal), propriété: Si X alors Y}, à un système de notation {performance: la double flèche d'équivalence (ce qui est toujours un peu bancal), propriété: quantificateurs et relations (dont le signe égal fait partie)} En fait, c'est pas très clair toute cette histoire. Du coup, c'est normal que ce soit pas clair pour les élèves. On devrait peut-être noter op_symbol__sequential avec une flèche dessinée en dessous ((et l'autre avec un arbre en dessous mais ce serait peut-être un peu trop)). **zeroperator (=="side-effect"-ator, ==procedure, ==non-args function, ==arg-insensitive operator): what it does is side-effect only. edu: on pourra toujours me dire qu'en fait il y a un argument: l'espace entier (voire même l'espace-temps entier (quand on joue de la musique par exemple)), puisque les effets de bord reviennent à des mutations de l'espace qui contient l'objet "touché" et le zéropérateur. il est bon de le préciser, pour planter un cadre fonctionnel serein dans la tête des élèves ("all functions are one-argument functions"). *actionator segment: this pace line actionates any actionable object it touches edu: build choreographies _for the machine to perform_ (or, more likely, for students and machine) **game: Anisotropic music partition: the partition is a 2d arrangement of music playing zeroperators. an actionator segment can traverse the partition following any slice path the user wants: each traversal will result in its own music The game is to find the right path. different flavors: straight path curvy path edu: this game is close but not exactly about dot-product this game can have a lot of variants: visual: superposing images instead of playing music, display fireworks animation, etc. audiovisual: sync image displaying with sound playing 16 mai 2021: **replays, many flavors: from now: - telekinesis: replay only moves, inner interactions can happen - mutationStory: replay only 'operator encounters' - oldtimes: replay all but ignore elements that were not there when recording was done from the past: - closureRollback: rollback to record starting event and replay all (== everything "in closure" is rolled back, (==related side-effects)) everything outside this spacetime closure is kept the same 17 mai 2021: **pov-capturing object: moving object also moves pov ((c'est un peu la mécanique inverse du z-scroll)) **populator: when actioned, populator spawns object(s) in the canvas la diversité des populateurs est a priori très grande: - certains vont être des zéropérateurs - d'autres vont prendre en paramètre l'actionnateur pour faire naître des objects donc on peut imaginer du clonage, de l'anisotropie, ... **(*)autogen system: "when actionator meets populator": while(something interesting may happen) 0. actionator moves and meets populator 1. actionator actionates populator 2. populator creates a new object, for example another populator, hopefully in front of the moving actionator edu: this system will allow emergence **"different-different but same": enforce equality of icObjects by "composite binding" them ("Tous dans le même sac.") example: Dynamic geometry Say we have: segmentAB: {pointA, rectAB, pointB} segmentCD: {pointC, rectCD, pointD} We can implement the requirement "pointA is the same as pointC": - assign the same coordinates to pointA and pointC ("align") - create a composite which contains pointA and pointC which contains another point, pointX, above pointA and pointC, with pointX.isMobile == false Now when user moves pointX, pointA and pointC move as if they were a single entity 18 mai 2021: (tree == state, sequential == event-sourcing **icObj insensible au roulis: l'objet s'oriente de manière à garder son bottom dirigé vers le bas de l'écran **[sym: ] operators: apply symmetry to obj **[timeReversal] operator: apply time reverse symmetry to obj **"dessine moi une horloge": 0. spawn a [+ 1] operator and a [[0]] mathNode 1. record mathNode move: sideA --> * [+ 1] --> sideB, and generate [forward] and [reverse] replays default [forward] may spawn at first then to get [reverse]: clone [forward] and symmetrical 2. create a sequence operator [[forward] [reverse]] 3. create a loop [loop: [sequence]] dev: sequence and loop operators may ease the animations ((dreams as another event track, the innerEvents, the "semantic" events (body evergoing reconstruction is functional, rebuild_cell(rebuild_cell(rebuild_cell(...))) => event sourcing, and yet we consider ourselves as a state (((Is it necessary to run the courses in that way, in order to grasp the full thing ? 1. be taught things the wrong way 2. realize they were wrong En particulier: la précision quand on utilise un langage: au départ, on dit les choses de façon grossière l'orienté-objet pour finalement revenir vers le fonctionnel (edu: il faudrait que [2 x] [[3]] et [[3]] [x 2] aient des significations différentes proposition: [2 x] [[3]] serait la signification "clonage": 2 pommes (application d'un adjectif numéral) [[3]] [x 2] serait la signification "échelle": 1 pomme agrandie 2 fois (application d'un adjectif qualificatif d'échelle) 19 mai 2021: **edu: le "multiplier numéral" VS le "multiplier échelle": on peut créer une représentation spéciale pour les fractions: en bas: un bloc tout seul, avec un nom : le _bloc nommé_. en haut: des blocs, sans nom, mais de la même taille que le bloc nommé. Il y en a un certain _nombre_. L'important pour cette bloom c'est la longueur des blocs. Un _bloc nommé_ [1/3] devra avoir une longueur trois fois plus petite qu'un _bloc nommé unité_ [1]. exemple: Une représentation de 4/3 : [ [ ][ ][ ][ ] ] [ [1/3] ] Avec cette représentation, on ramène deux types d'opérateurs: les opérateur numéraux: qui agissent sur le numérateur. les opérateurs "nominaux": qui agissent sur le _nominateur_. (ou on pourrait dire opérateurs "escals" (==d'échelle)) d'un point de vue mathématique, pour les fractions, on a nominateur == 1 / dénominateur (ici le préfixe "dé-" est interprété comme inversif : si on multiplie par le dénominateur, la fraction n'a plus de nom (==le nom par défaut (=="unité"))) exemple: [ [ ][ ][ ][ ] ] * [x 2: via num] = [ [ ][ ][ ][ ][ ][ ][ ][ ] ] [ [1/3] ] [ [1/3] ] [ [ ][ ][ ][ ] ] * [x 2: via nom] = [ [ ][ ][ ][ ] ] [ [1/3] ] [ [ 2/3 ] ] et les opérateurs de conversion ("to"): [ [ ][ ][ ][ ] ] [ [1/3] ] * [nom: to [2/3]] = [ [ ][ ] ] [ [ 2/3 ] ] En fait, cette bloom a un énorme inconvénient: dans cette notation, on met le nominateur en bas alors que dans la notation fraction, c'est le dénominateur qu'on met en bas. Peut-être qu'une version gauche droite serait plus adaptée: [ [1/3] [ ][ ][ ][ ] ] pour petit à petit passer vers [ [1/3] * [x 4]] et arriver à [4/3] Un autre inconvénient: on utilise une fraction pour le nominateur... On peut s'en sortir si on définit proprement [1/n] [ [ ][ ][ ][ ] ] [ [ 2/3 ] ] peut être déplié de cette façon : [ [ ][ ][ ][ ] ] [ [ ][ ] ] [ [1/3] ] Je ne sais pas pourquoi mais, toujours est-il, j'aime bien cette notation. Notation sur papier: on met un nombre entier en haut, une fraction en bas et entre les deux une barre qui aurait la forme d'un "sigma orthogonal aplati" exemple: xx x xx xx xx xx xx x xx x xxxxxxxxxxxxxxxx x x x x ┌────────────────────────────┬───────────────────────────────── │ │ │ │ │ │ └────────────────────────────┘ xx xxx xx x xx x x x x x xxxxxxxxxxxxxxx xxxxxxxx x x xxxxx xxxx x xxx xxxxxxx ((ou peut-être qu'un sigma miroir orthogonal aplati serait mieux car on lirait directement 4 "1/3" : quatre tiers. 4 _______ |_| 1/3 mais du coup ça commencerait pareil qu'une fraction visuellement... ("sémantique syntaxique": quand je veux faire comprendre quelque chose à propos de la notation elle-même **draw content VS draw meaning: one can switch between two input modes: user wants to create content (==objects) or user wants to create behavior(==moves, operations,...) example: user could tell the computer to create a [replay] in reverse from a [replay] "going forward" by drawing an arrow that shows an object movement that is the reverse of the normal "forward" object movement 20 mai 2021: (Some researcher is actually named Shute!: Valerie J. Shute, https://myweb.fsu.edu/vshute/ **ghost-path greenMouse: for deferred feedback: student draws the path and _afterwise_ the mouse follows the path **Braid-like reverse (==keyDown reverse): "hot-reverse" a grabbed greenMouse 0 à essayer pour voir ce que ça donne dev: mouse pointer may shift wrt physical mouse position ****pathmade operator: create operator from path (path == move-events-only replay) operator does this: make object follow path, making it encounter existing operators yet, we don't see the object moving when touching this operator, we see the mutations on anything but the object position for simplicity, path start is where operator will spawn after it has been created, pathmade operator's path shows on mouse hover (or on two-finger hover for touchscreens) encountered operators may be loop operators edu: this way, we can create operators in a blink, and use them to build other operators, etc. edu: we may create specific applications (== apply) using a cart loader : arguments are put in the cart and the loaded cart encounters the operator we want to apply to the args edu: this way, we can create functions of functions (operators taking operator as an arg) edu: this paves the way to creating a new programming language dev: this is gonna be tough, but this is gonna be it 2 flavors: - off-ground: path is parsed into a function when operator is created if encountered operators are moved or replaced: the operator still plays as if the original encountered operators were there - grounded == path-treading 2 flavors: - conveyor: touched object is moved along the path operator leaves performer at end of path so it's like "function + goto" 2 flavors: - original object conveyor - clone conveyor -"possessed_geminiShade"-based: a gemini shade moves along the path and its mutations (everything but position) are forwarded to the original touched object if encountered operators are moved or replaced: it will result in the pathmade operator behaving differently (here Papert's idea of "screen as a data type" is realized we could replay: - at original speed (==timing does matter): to explain, to debug, or to reify async operations - way faster (== as fast as possible, timing does not matter): to use it productively, even it makes us somehow forget how it works internally edu: we can then create trees of pathmadeOperators, and maybe treer things sync/async: sync : waits for any operator along the path to complete async: does not wait for completion, mutations may happen anytime procedure/function: procedure: object is mutated along the way "pure" function: object is replaced by function's output when function has finished edu: this way we can explain state and the different between state-based and functional programming 0 from svg path to move events sequence 0 from move events sequence to svg path edu: "ghost-path greenMouse" can now be put one step further: "tailored pathmade operator creation" ("Donne moi une fonction qui résout ce problème") ((The Witness meets Braid ^^)) edu: we can change function parameters by equipping the performer ghost_rep with a reactor edu: recursion can be enacted by making pathmade operator be encountered along its own path edu: recursion could also be done via cloning "everything needed" into a lower area, and continue execution there, etc. **conveyor seam: if two conveyors operate simultaneously on the same object, ignore the conveyor which is closest to its end *event injection: inject add1 in move move move... sequence 0 inject an event which stalls the object for 1 second 21 mai 2021: 0 dessine moi un mouton de fonctions (using visible path pathmade operators) *music: frequency gradient operator: top, red: treble bottom, brown: bass *music: notes circle: 12 operators are disposed on circle, to play a note one may: - cross the circle: - from inside to outside - from outside to inside - bounce: - stay inside - stay outside **icEngined.engine = ProjectileEngine() **icObject.type = "projectileThrower" ? when wrapped in a pathmade operator: where should we the projectile be shot from ? **icObject.type = "eraser" single-use vs everlasting projectile eraser: example: destroy possesed_ghost_rep of pathmade operator while it is running by throwing an icEraser on it **edu: 0 pathmake all operators using [clone] and [-], and [[0]] and [[1]] **my deck of operators: student chooses or creates a deck of operators and then tries to complete the challenges using them (of course pathmade operators can be 'raised' from the starting set) **icObj teleportation: while moving icObj, enter freeDrawing mode, the icObj does not move but the cursor moves, then leave freeDrawing mode: icObj teleports to cursor 22 mai 2021: **modifier: inject condition inside looping conveyor to transform it into a while loop **behavior:pickAndDrop: pick object X and drop on object Y **icObj.type = "pickAndDrop" (une version incarnée du comportement pick and drop) **(*)le ramassage des pommes: réapprovisionner le canvas avec de nouvelles pommes et relancer tant qu'il reste des pommes: le pickAndDrop performer ramasse une pomme à chaque tour de boucle (la pomme se colle à lui et il la ramène au début du parcours où il la dépose dans un panier) quand le performer a tout ramassé la boucle s'arrête On peut alors ajouter à nouveau des pommes sur le parcours et relancer une nouvelle exécution ou enlever des pommes avec la souris et regarder qu'il s'arrête bien quand il n'y a plus de pommes many flavors: - condition is local (==performer-related): performer knows that there isn't any apple left to pick (because it has not found any on the path) - condition is global: "global" knows that there are apples to pick tant qu'il y a moins de 5 pommes dans le panier edu: pour expliquer la complétude: mettre une pomme à un endroit qui est dans l'enclos mais qui n'est pas sur le trajet du performer: le trajet n'est pas couvrant **function::showstopper: any process involving object X must stop now so this may be used to terminate a looping conveyor operating **challenge: show me a path/ show me the shortest path: draw a path to transform X in Y pleins d'opérateurs éparpillés, un objet de départ et l'objet qu'il faut obtenir edu: pour aller vers les fonctions (voire les polynômes): draw a path to transform X in X', Y in Y' and Z in Z' edu: pour aller vers le calcul littéral: find 2 different yet equivalent paths **whileTouch slots: comme quand on reste appuyé sur une touche d'un sampler, le sample continue de jouer tant qu'on relâche pas la touche *[tupler] creates tuple [[{A:, B:}]] ***graph by inputting: [pathmade op] then [graphConveyor]: when [pathmade op] touches [[input]], [graphConveyor] sets its path to put [[output]] at coordinates corresponding to [[input]] dev: ça va encore être un peu sportif dans les coulisses edu: pour expliquer entre autres la linéarité, la non-linéarité, la fonction exponentielle edu: avec cette façon de faire, on reste très proche de la réalité "calculer reporter" que l'on peut faire avec une calculatrice et une feuille de papier (a more explicit yet more complicated version: [conveyor] } } then [tupler] then [graphConveyor] ["input" conveyor] } 23 mai 2021: **write the function on the object: example: perimeter conveyor ----[+ 5]---- | | [+ 5] [+ 5] | | ----[+ 5]---- *edu: EXPERIMENTS before EXERCISES: before giving them exercises to do, give them experiments to do l'apport de l'ordi est le suivant: cette activité, qui devrait normalement être une activité un peu barbante à la calculette, devient une activité facile et rapide à faire exemple: faire [[5]] * [+ 3], faire [[-5]] * [+ 3], faire [[5]] * [+ (-3)], faire [[-5]] * [+ (-3)] Si on veut faire une expérience du genre "faire [[5]] * [- 3] * [- 7] * [- 5] * [- 10]", on peut déjà avoir disposé les opérateurs de manière à ce qu'on puisse tout faire en un seul mouvement (peut-être pas forcément une ligne droite pour prendre le temps de voir ce qu'il se passe à chaque étape) **icObj.type = "pen" penUp, penDown etc. edu: pen + conveyor(s) can be nice **magnetic generation: mousedown with empty supervessel and touch generator operator: generated object is now in supervessel cargo, which will be dropped on mouseup *operator's own supervessel / disposable supervessel: maybe, at some point, we'll want differentiate supervessel and platform, by giving them slightly different meanings and behaviors supervessel is like a the magnet of a magnet crane platform is like a the flatbed of a flatbed truck (OMG: I'm such a copy! Seymour Papert last week, now Ivan Sutherland: https://www.youtube.com/watch?v=6orsmFndx_o (so funny actually, all that is so old, so bright, yet nobody seems to have cared! (except some people of that distant time) **constraints / constraintsSolver: comme dans la vidéo de Sketchpad, on met des contraintes sur une figure puis on la fait toucher un opérateur [solve constraints] qui nous donne la version résolue - deux nouveaux types opérateurs: [constraints::add] et [constraints::solve] edu: bien sûr, on peut cloner la figure avec les contraintes avant de la résoudre pour afficher les deux versions - une nouvelle représentation: rep_constraintsSolved praised be thy Doug: **easy editing of documents by diving inside, editing (for example drawing) and then moving outside there is a quantization of zoom levels **Database of links: either click links or portals **Networking: allow collaboration on the same location in the canvas 24 mai 2021: **"full spectrum" composite: all representations or all shades, r_official excluded, are parts of a full spectrum composite so when you destroy the composite, you destroy the full spectrum of objects (((is the shade of a shade still a shade of the original ? 25 mai 2021: *pov, superpov, pov conveyor: a way to create transition in presentations **"become the object": when pov moves as if it were the object *easy orientation via dragging *for quick 'handmade' anims: freeDrawing.isTouchable = true after it has been created *la supercouche interprétative: quand une computer vision interprète l'espace d'interaction exemple: des objets superposés seront peut-être interprétés comme étant le même objet **Narwhal numbers: multiplayer canvas, operators and their inverses are disseminated around, each player has a starting value and a goal, winner is the first to attain their goal variant: each player also has an operator attached to them (that's a way to somehow keep the joust mechanic) so the narwhal number player has its operator on the front and its value on the back example: -=([[3]] [x 2])>> edu: I know that's gamification... (but maybe it's gonna be ok still) **shade.im_dying_now 2 flavors: - bring original down - don't affect original 26 mai 2021: *var: [create: number], [assign: 0], ...operations..., [destroy] **turtle: operations are forwarded to a third-party object (the two first being [[obj]] and [operator]): [[obj]] * [operator] = [[turtle]] * [operator] edu: c'est vrai que Mathland sans turtle(s), ç'aurait été un peu triste. **pen(== turtle) drawing: record pen drawing: create [pathmade:penDraw] operator. Touching this operator will command pen to draw. edu: this way we can draw crenellations by looping on this operator **penDrawing: relativeOrientation => roses: record pen's ending orientation so that looping on curve drawings will result in roses **in the steps of giants: https://fr.wikipedia.org/wiki/Squeak https://en.wikipedia.org/wiki/Croquet_Project Lively kernel 29 mai 2021: *katamari operator: [stick []]: touching this operator sticks a clone of on you 2 flavors: directional: the clone sticks where touching random: the clone sticks anywhere on the border *katamari generation loop: loop [stick []] edu: emerging structures ***pathmade:triggered pathmade: user draws paths for each argument and conveyors will be triggered to start altogether. this allows support for multiple arguments [[firestarter]] obj: this is like a "gogogo" argument: this will trigger the operator Result is last drawn conveyor's output. Result is cargoed in supervessel. 2 different implementations: - vacuum conveyors: trigger is a pure trigger and, when actioned, all conveyors will try to vacuum an argument near their starting point and then start conveying *** - embark pathmade: pathmade is a platform operator and each time an argument is put on it, it is mapped to the corresponding conveyor. mapping to conveyor can be done using order, type, ... Trigger happens: - when all arguments are here - if actioned by a [[firestarter]] 2 flavors: - 2+ args: - optional arguments - required arguments - only 1 argument and the rest are parameters edu: also, we _see_ the difference between an argument an a parameter: argument is consumed parameters are not consumed triggered pathmade can be conveyor ("multiConveyor"), shadePossessor ("multiPossessor"), etc. edu/fun: with multiConveyor, we can create an [arrange as face] operator which puts #1 arg as left eye, #2 as right eye, #3 as nose, #4 as mouth and then we can wonder what is actually a face, is it the arrangement or the arranging (==the result or the process) 0 show location of #1 when drawing #2 variant: superhot mode: to move in space is to move in time user may decide whether he wants the touched object to be conveyed or shadePossessed (== choice between kind of a procedure and kind of a function) depending on the glove color of their grabbing hand user may configure whether a path is: - a dead end (==performer will not be given back to user) - an outlet (==performer will be given back to user) edu: pour que ça soit vraiment *edu* (et aussi pour que ça soit vraiment utile), - il faut qu'on puisse éditer la fonction (==le chemin) après qu'on l'a créée - il faut que ça reste rond et courbe - il faut qu'on puisse changer la vitesse d'éxécution, de façon continue de figé à rapide, jusqu'au saut quantique: "hardwired"(==compilé, ==le plus vite possible, ==on n'affiche plus l'exécution) dev: encore du sport à venir **pathmade:await: wait for operator to finish before going forward dev: this is the hard part **pathmade:custom generators: 2 different implementations: - generator path: when drawing a path, if the starting point is on a generator, this means we want to create an object and make it follow that path we can then create custom generators using generator paths pulled out from _elementary_ generators - generator as arg: when the triggered pathmade triggers: the output obj from the generator is used as working argument edu: generator path may be a little bit easier to understand than generator as arg 30 mai 2021: *easy multiargfunc: type "3x + 2y -5z" and it automatically creates an embark operator "[[1]] x 3 + [[2]] x 2 + [[3]] x (-5)" should be parsed the same way *?(the path is the operation 31 mai 2021: *embark operator:named slots (==renamable slots) slots corresponding to each arg are named "#1", "#2", etc. but then you can rename them **embark operator: add support for bag input (bag contains all the args) *a program for every theorem **0 fabriquer un additionneur de fractions avec les outils existants *global pool: this pool contains words, numbers, shapes, ... (un peu comme une chambre d'enfant) *global pool: operators: grep: this would allow easy finding of **condition-based magnet: wave the magnet over a dense area: objects satisfying the condition will stick to the magnet *bloom: morph into next representation edu: pour passer facilement de 10 à [1,1,1,1,1,1,1,1,1,1], et inversement *create Heider Simmel -like stories edu: maybe a little happier 01 juin 2021: * "a + b x c" 0 have it working 0 parse tree-formatted expression into tree-arranged paths implementation *trueGolf: randomStroke/manualStroke there are multiple stages for each hole: {stage 0} --> {stage 1} --> {stage 2} --> {stage 3} each stage partitions the hole course into areas in a specific way: {stage n} --> {stage n+1} with probability P(s_n+1), {HoleCourse \ stage n+1} with probability (1 - P(s_n+1)) randomStroke moves the ball to each zone with probability P(zone) *shadeConveyors <~> multiOutput **(*)temporal builder(==temporal form): build anything by specifying one property at a time 1. I declare that I start creating an obj 2. while i'm not done, I specify another property of the obj I'm building 3. I declare that I'm done: the obj is built These buildings can be nested. It would be nice to show the hierarchy of the object we're building and the properties we have specified so far. edu: this is a simple -yet powerful- way to build complex objects example: temporal composite builder: (generalization of multipathmade) 1. I declare that I start creating a composite 2. I create the parts of the obj, one part at a time 3. I declare that I'm done creating the parts: the composite is built 02 juin 2021: *stages inside a function: mapping twingling outputting (codage géométrique: contraintes en puissance VS contraintes en acte *"Copies, clones & replicants": many flavors of "they are the same": - gemini (still "in touch") (something I am) (limb) - copy (objects are apart) (something I was) (poopoo) - shallow - deep - impersonator (something trying to be me) - stateImpersonator - behaviorImpersonator **composite: rearrange parts using conveyors: [up 50], [down 50], [left 50], [right 50] edu: un mélange de tortue et de translation edu: on peut fabriquer des obliques en mettant le début d'un opérateur à la fin d'un autre **ecological poopoo: poopoo stays in the composite edu: this way, composite's inner turtle can penDown, without polluting global context (algèbre des chemins (en informatique, y'a ce double décalage (temporel et "productionnel") entre la vision qu'on a et sa réalisation. Parfois c'est près, parfois c'est loin. **composite: [objectAtIndex:] operator [[{1 2 3}]] * [objectAtIndex: 0] = [[1]] **WASD-controlled obj, open world: numbers adventure game (/!\attention à ne pas faire une gamification merdique/!\) edu: créer un petit monde avec des portes et des clés et des portails laser avec des conditions logiques ("all must be > 12", "any equals 5") edu: quand on a pas beaucoup de mana (==motivation), on peut toujours jouer à la manette. La souris demande un peu plus de motivation. 03 juin 2021: *edu: small stroke for mathNode pour différencier "ajouter" et "mettre dans le même sac" *edu: créer des exercices avec des cailloux de couleur pour commencer à maîtriser les fonctions **[objectAtIndex:]: multiple flavors - destroy container and keep part at index (==pure-function way) edu: this behavior has a nice advantage: working space stays clean - don't mutate container: simply gain control of part at index - mutate container: remove part at index from container some of those behaviors may only be possible when using supervessel **[pickme ] operator: when an object becomes an operator to ease function drawing, we can store an object in an operator, waiting to be used later object touching operator: - if it's a container, obj will be added to it - if it's an obj, a container will be created containing the two objects - if it's an emptyObj, obj will replace emptyObj **edu: tranquillement aller vers l'abstraction (et "l'équivoque"): du spécifique au générique commencer par les opérateurs spécifiques [c:objectAtIndex:] [str:charAtIndex:] etc. pour aller vers les opérateurs génériques [g:elementAtIndex:] 04 juin 2021: **pathmade: vesseler: convey objects using a disposable vessel either we make the vessel touchable and mutate it directly or we make the vessel untouchable and we get it back from the touched object (-"Are you being vesseled ?" -"Yes, I do" -"Kay, thanks") shu: I prefer the second way **transformationFunc("new"): coords__icObj_new = coords__vessel *?transformationFunc("append"): keep old and add new ***pathmade:part#nPath the idea: easily draw paths to _dispatch_ composite parts (==vesseled objects) draw part#1Path by pressing "1" and drawing draw part#2Path by pressing "2" and drawing you can choose to draw only part#2Path if you don't want to do anything with part#1 you can draw part#2Path before part#1Path, drawing order does not matter when used, if performer has only one part, part#2 path will simply be unused shu: l'idée vient de la confrontation avec cette envie de dessiner des fonctions (facilement) dev: encore du sport **[<- [1,2,3]]: touching this operator adds 3 objects to current vessel **[store: linear]: any object touched by this operator will be added to a collection just under the operator the collection is either: - a composite - an arrangement (objects parent is canvas) and the collection is an inner variable of the operator **[vessel] and [unvessel] in order to try operators manually 05 juin 2021: **curse::unique: ==not clonable as it is a restriction, there are as many flavors as there are clone flavors **walls: isFloating while conveyed: use paths to get over walls (inspiration: BABA IS YOU) edu: this compels students to use paths ***pathmade: seaming: when perfomer is touched by another pathmadeOp: 1. prematurely terminate current pathmadeOp 2. perform for new pathmadeOp loop: newest has priority over its old self edu: la règle est assez simple en fait, c'est comme quand on a une copine example: while loop = draw [loop] pathmadeOp, draw [if] pathmadeOp which exits loop path **pathmade::loop: system automatically sets facade name as "loop" when end of path intersects operator's touchSlot (*Not simply draw, but draw in time, draw in space & time **write condition script in [if ] pathmadeOp *[join("+")] **store commands: "clone and store", "create store", "set active store" **path merge: [if] pathmadeOp goes back to original path ====[if]========>================= \--------->----------/ *edudemo: build operator: [^ ] there will be many ways to build it: - loop + exits - whileLoop - repeatLoop **edudemo: les deux formes de la multiplication - repeat(+) - scale(bloom) edu: ces deux formes sont équivalentes (c'est un peu comme le principe d'équivalence d'Einstein) edu: on peut peut-être fabriquer une edudemo intermédiaire qui ferait le lien entre les deux 07 juin 2021: **another operator behavior: imprintable: on first touch(es), operator's behavior gets fully specified example: imprintable counter: count all like this one (one touch to fully specify behavior) imprintable combo counter: count all combos like this combo (multiple touches to fully specify behavior) like an EEPROM, but it's an operator **challenge::dictation: touch mistakes in the text with the correct [mistake] obj *value-wise store/counter: only store or count when touching an object with an expected value **histogram store: must touch with the expected value **histogram counter: store + counter reictangle **histogram loop: since we use value-wise counters, performer can try all counters for a valid touch example workflow: random sample: build single histogram : loop { get_random_value, try all counters for a valid touch} example workflow: random sample: build multiple histograms : loop { get_random_value, try all counters for a valid touch in random events partition #1, try all counters for a valid touch in random events partition #2, etc.} 08 juin 2021: **edu: constructionism: any object that the student has managed to create is then available in a dedicated well - as a snapshot version: this version contains all the pain and trouble that the student has overcome - as an "instant" version: this version is the most efficient version **Theorem as a function: meta-theorem as a function generator ("functions all the way down") edu: [bag with conditions] * [theorem] = [bag with conclusions] 11 juin 2021: **icObj.type = "magnifier" edu: pour mettre en avant une zone spéficique dans une présentation dynamique edu: pour regarder ce qui se passe dans un processus "profond" et pour pouvoir débugger par exemple store: layout: gridLayout layoutEngine **icObj.type = "layout" this object is like a composite but parts are arranged using specific rules (==provide position, size, scale and zIndex) (fun: include handle in the objects we layout ("icLayout layouting itself") dev: first, static layout dev: then, dynamic layout (allow dnd reordering etc.) 0 icLayout = icComposite([...arr_obj, ...arr_layout_obj]) + LayoutEngine 0 icGridLayout: icLayout with arr_layout_obj == [baseRect] and LayoutEngine == GridLayoutEngine **"Time" control: accelerate, slow down edu: when repeating random experiments, after having shown a few outcomes, accelerate to build histograms **value-wise counter: 2DGrid: we specify two sets A and B, and we then count objects in AxB **(*)store: many flavors: copyStore: [[obj]] * [store] = [[obj]] + side effect: copy of [[obj]] is put in depot shallowCopy dev: dans ce cas on crée rep_stored et on met rep_stored au dépot ? deepCopy hardStore: [[obj]] * [store] = [[*]] + side effect: [[obj]] is put in depot [[*]] means an activator (empty) object edu: la shallow copy peut être très utile pour représenter des partitions: si tu es petit, je te peins en bleu, si tu es grand, je te peins en rouge **edu: use a loop to create counters: [iterator: possible_outcomes]/[iterator generator: create possible_outcomes iterator] icObj generator / generator generator dev: pour cela, on a besoin de connaître l'ensemble des issues possibles **edu: show stack: encountering a shadePossessor along the path must be treated as: push next path on the stack **icObj.type = "futuring" icObj.futuring mutate current futuring, as if it were any other property, like position or fill color icObj.futuring = ttFunc(icObj.futuring) [speed:fast], [speed:slow], [speed:normal] [speed:faster], [speed:slower] we may also track down the transformation process of the transformation process, etc. (== the futuring of the futuring) **edu: show stackless execution: encountering a conveyor along the path is treated as: abort previous pathOperator and follow the new one **edu: show tree evaluation: starting at the bottom, make shadePossessor halfloops to compute which reduced object the tree is equivalent to **edu: Z-tree: each depth level has its own homeScale so that you have to zoom in to see what is inside the node, etc. **icObj.isTouchable -> icObj.isTouchableDict this will allow complex routing: two objects may follow the same path, and yet, interact with different operators along the way **(*)AI objects create their own pathmade operators: this may be funny to see, all the more if they achieve something non trivial 12 juin 2021: **the admin way of drawing: multidimensional color == {color + recipients} this way, the admin may specify things to specific players admin is able to see what all players see: either all merged or specific projections typical use case: adminDraw a codenames game: draw blue and red borders only for tellers **theorem operators: [[hypothesis]] * [theorem:] = [[conclusions]] example: {[[a "supereasy" font creation) 13 juin 2021: (intention vs implementation **supereasy::number creation: type a numpad number (a timeout resets after each key press) and an icMathNode is created with your number as constantNode's value edu: because it's primarily created for kids to manipulate numbers edu: maybe we should also add this shortcut: KeyX: create an icMathNode with "x" as symbolNode's symbol 0 number builder 0 manage builder timeout 0 manage -12 0 infinite wait for - 0 manage 3/4 0 infinite wait for / 14 juin 2021: (x |--> "x" |--> lf("x") |--> f(x) VS x |--> f(x) to_litt litteral_f from_litt f on pourrait faire un carré mais l'idée est la suivante: est-ce qu'on ne mélange pas trop souvent les deux ? et on pourrait ajouter une phase de simplification, si on considère que l'objet non simplifié et l'objet simplifié sont tout de même différents l'un de l'autre lf("x") |--> nsf(x) |--> sf(x) not simplified simplify simplified 15 juin 2021: ***le transformé comme sujet VS le transformeur comme sujet: ajouter le comportement "dual": j'attrape un opérateur et je touche(/me fais toucher par ?) ce que je veux transformer edu: peut-être que les deux comportements sont complémentaires pour faire comprendre telle ou telle opération l'avantage du transformé comme sujet, c'est qu'il permet les enchaînements de transformations edu: et puis ça ouvre la voie vers les opérateurs d'operateurs etc. (("Le graphe pour le graphe" (Ducrot dans la tête): notre réseau de neurones dans la tête serait là pour calquer les graphes qui existent dans la nature de manière à avoir une sorte de "toy copy" dans la tête Un des graphes les plus utiles à "toy copier" est le graphe du langage (en fait il y en a plusieurs, le graphe langagier et le(s) graphe(s) linguistique(s)). Si on considère que le sens d'un mot n'est que le graphe des connexions qui shadowent un mot, et que, c'est uniquement cette structure abstraite qui donne le goût du mot, alors on a juste besoin d'une machine à fabriquer des graphes pour, partant de rien, petit à petit comprendre des trucs. Le graphe de notre réseau de neurones serait donc un super graphe ("toy copy") et une fonction de génération de graphe. La fonction de génération de graphe doit sûrement dépendre, au bout d'un moment, du super graphe lui-même (mais là ça devient hardcore). Le super graphe, bien qu'il soit tentant de le considérer comme une construction physique statique, comme un tas d'argile modelée, est en fait un graphe performé (et donc surtout _performable_): quand le sens d'un mot est vécu, les relations entre éléments du graphe sont effectivement réalisées, à chaque fois, par des circulations, comme une relecture (très rapide) de tout ce qui fait ce sens, ou du moins tant que le super graphe n'a pas lui-même bâtit un mini graphe "compilé" qui réalise tout cela de manière encore plus accélérée. Un dictionnaire, c'est une version "rétention tertiaire"(livre) du graphe du langage. (*l'algèbre des carreaux: [2x (horiz)] et [2x (vert)] [[5 horiz]] / [[10 horiz]] = [[3 vert]] / [[6 vert]] [[1 horiz]] == [[1 vert]] == [[1 square]] == [[1]] [[6 vert]] == [[1]] * [x6 (vert)] ***iCClassroom (==iC + colyseus): on imagine qu'on reconstitue une classe en partant d'un grand rectangle qu'on divise en sous-rectangles chaque élève a son sous-rectangle dans lequel il peut travailler, ce qui est cool, c'est que cet espace, quoique borné, est infini. Le prof a un sous-rectangle de présentation, et plus important, il voit chaque sous-rectangle de sa classe. est-ce qu'il peut voir tous les objets ? même ceux que l'élève cache profondément, genre des petits dessins, des trucs comme ça ? (avec un focus_to_next_object() en appuyant sur TAB) Les élèves peuvent voir ou ne pas voir ce que font les autres élèves en fonction de l'activité. En phase de travail: mode fermé: l'élève ne voit que son espace edu: pour faire en sorte que l'élève puisse se concentrer mode ouvert: les élèves peuvent voir les espaces des autres edu: pour confronter différentes idées, différents résultats En phase de cours magistral: les élèves peuvent écrire dans leur espace mais de façon exceptionnelle: quand le tableau blanc n'est plus dans leur point de vue, un compte à rebours s'active qui les ramènent au tableau blanc. edu/dev: wow, y'a plein de choses à faire, y'a du potentiel 16 juin 2021: **24-sourced controller: from 24 inputs to 1 input: every frame, input is avg input => The Wisdom of crowds **pathmade operator: throwing exceptions: _any_ operator may throw an exception, which results in stopping the current pathmade examples: when encountering an empty vessel when trying to divide by zero **[filter:]: filter removes cargo from vessel when condition is not satisfied **conductive operator: allow [generator] to be used in place of [[instantiated collection]] ([randInBag {} with .isConsume = false] is a generator (?) 18 juin 2021: **symbol: "on top of", "put over": /_ **stacks: [[0]] /_ [[+ 2]] /_ [+ 3] /_ [/ 5] {[[0]], [[2]]} /_ [+] /_ [+ 3] **[eval:inner] operator: [[*]] * [eval:inner {[[3]], [+ 2]}] = [[5]] edu: pour pouvoir montrer la différence entre une expression non-évaluée et une expression évaluée this operator creates an inner no-interaction zone, so that we can set up a stack inside it [eval:inner ] **exothermic reactions: [[A]] * [B] = [[C]] + {[[exoParticleD]], [[exoParticleE]], ...} edu: this would be used to show chain reactions edu: I don't know what endothermic reactions would be like ? **[occurences]: [[collection]] * [occurences] = [dict__occurences] *edu: loto: faire plusieurs tirages de loto (boucle de boucle5 et store de store5) et ensuite analyser les différents tirages de 5 numéros prendre le store et lui faire toucher des opérateurs, [occurences], [unique], etc. **edu: randInBag: bag.parts = {bag_drawing, ...bag_contents} bag_drawing.isCosmetic = true; (*revolving randomness: are we still in the "random experiment" theoretical boundaries? example: rand( revolving(1,2,3,4,5,6), revolving(7,8,9) ) which would yield, at first, 1 or 7, then 2 or 8, then 3 or 9, then 4 or 7, etc. (**"TRY HARDER" VER: on reprend tout, en gardant ce qui est bon, en corrigeant ce qui doit être corrigé, et tout ça, sur des fondations différentes, _a priori_ meilleures 19 juin 2021: **named object(=> references): if [[2]].name is "x", then [["x"]] * [get named] = [[2]] **evocator (== [get [[*x]] ]): get existing _long-living_ object this brings state in this otherwise functional landscape **operator evocation: when almost every [[+ 2]] mean: "get the one and only [[+ 2]] thing, and do it" there is a pathmade way to do operator evocation: when pathmade is simply a "passthrough operator", with the path only passing through one operator (the one we want to evoke) **t[icWorld]t (==file object (or folder)): when you doubleclick on this object, its contents are loaded so that its biggest scale is the scale in which you enter it (==it is framed) a world can contain itself, either as a dive (==go deeper) or as a reboot (==go back to entrance) **edu: iC to specify a language: some typical human situations, and their contexts, are set up and the user can write the words of his language, or record the sounds of his language which are related to the situation, when it is relevant. 20 juin 2021: **transformationOutput.cfg.isKeepPosition 21 juin 2021: **dot operator: get property named: [. [[propName]] ] example: [. [["color"]] ] **randomMultipathmade: parts-to-paths mapping is random like a 2-D shuffler **quantum-like: "all possibles"-multipath travels collection object covers all possible paths by cloning ***edu::teamChallenge: "right in front of you": hide a key near a geometrical point (we can do it since the canvas is infinite) + transmission of information 1. a student, the "witness", is shown a geometrical construction sequence at the very end of the sequence, a geometrical point is highlighted, this is where lies the challenge completion key 2. the witness has to write down, in his own words, how to reproduce the sequence 3. then these instructions are handed to the rest of the team 4. the team has to reproduce the original construction which will make the key spawn 5. the team has to find the key which lies near the end point **randInBag: manage the case where the picked object is put back in the bag **edu: functionamer operator: [["x"]] * [functionamer [["f"]] ] = [["f(x)"]] [wrap ["f("] [")"]] et là on se dit qu'il nous faudrait quelque chose qui ressemble à du texte, mais dans le lequel on pourrait mettre n'importe quel objet : une sorte de texte++. **edu: proportionality lab: different ways of responding to [x 2] [[2,7]] * [x 2] = [[5,4]] [[baguette]] * [x 2] = {[[baguette]], [[baguette]]} [[<-rect->]] * [x 2] = [[<-----rect----->]] [[square(2)]] * [x 2] = [[square(4)]] [["hello"]] * [x 2] = "hellohello" 22 juin 2021: **edu(/tech): ensure that students all experience the same (when possible) - scroll-speed automatic calibration "etc." **draw movement/draw on wrt something moving: lock pov on moving object, then draw in that local coordinate system example: draw earth movement around the sun then draw moon movement around the earth edu: if student can draw a solar system in, say, 5 minutes, then they may understand it better 23 juin 2021: **edu: late evaluation curse: [[5]] * [+ 1] = [[5 + 1]] cursed, after 1 second transforms into [[6]] multiple flavors: - a separate curse for every interaction example: [[5]] * [+ 1] = [[5 + 1]] + curse1 [[5 + 1]] * [+ 1] = [[5 + 1 + 1]] + curse2 [[5 + 1 + 1]] --curse1--> [[6 + 1]] [[6 + 1]] --curse2--> [[7]] - reset timeout if an interaction has occured before the curse trigger example: [[5]] * [+ 1] = [[5 + 1]] + curse [[5 + 1]] * [+ 1] = [[5 + 1 + 1]] + reset timeout for curse [[5 + 1 + 1]] --curse--> [[7]] the idea is to create a connection between: 1. the interaction between the number and the operator 2. the unevaluated expression 3. the evaluated expression **game::treasure hunt:: "recalled" curse: when clicking on the found object, it is recalled back to its destination slot in the "collected objects" area 2 flavors: isPovLock (true or false) 26 juin 2021: **kids have smartphones, kids don't have desktop PCs => ergonomy: add major scale buttons in the back of the phone, to enable zooming while keeping thumbs available for pushing stuff on the screen 27 juin 2021: **bande dessinée animée: mi-bande dessinée mi-dessin animé et re mi-ours derrière **icObj.type = "disk_portion" user can change angle by dragging edu: [[+30°]] * [+ [[-20°]] ] = [[+10°]] **edu: ghostSnap (from raw input to "exact" input) example: "build a circle" eduDemo: when creating a point, it is snapped to an invisible circle so that, when putting multiple points here and there, a circle made of dots appears when zooming out **edu: walking friend example: "build a circle" eduDemo: a character starts from the center and walks a given distance in a straight line **explain homothety with Mario mushrooms 30 juin 2021: into a practictal use of the infiniteCanvas: **practical::temporary portal(s): when Picasso works on a painting, Picasso has to move away from the painting to see it as a whole, and then move in, etc. **practical::isMovable spawn modifier workflow: (when creating treasure hunts for example) first draw an unmovable object, then draw a movable object and place it over it **practical::doubleObject spawn modifier: workflow: first draw the back object, then draw the front object (at its toggle scale) **edu: globetrotter: loop{ask a question to the students about current location, let answerer choose next location} 3D-infiniteCanvas (à la GoogleEarth): move from country to country 2D-infiniteCanvas => flat map (edu:liquid Sissa: square glasses on the chessboard *symbolism::reference length: say we have a triangle with lengths 3 cm , 4 cm, 5 cm, if we choose the 5 cm length to be the reference, then the other length could be written 3/5 and 4/5. on the geometrical figure, we would indicate that 5cm is the reference length by writing it with a double bar (like a segment but doubled) (or any other clear and distinct way of specializing the side we choose as a reference) 01 juillet 2021: **Line, Point and other geometrical entities have this interesting property: they are Z-scroll proof: Z-scroll leave them unchanged edu: this is a nice property to play with: "is this a point, or is this a disk?" 05 juillet 2021: **challenge: blackbox reconstruct: next to the "subject" blackbox, there is a an empty blackbox for the user to specify what is inside edu: be progressive: first, only on the surface 3 operators then 4 operators etc. then with something in the core 4 operators then 5 operators etc. **operator interaction type: sunburn (=="projective interaction"): operator can only burn (==operate) _once_ each object edu: so that the user, starting with a typical input set, can create the/a corresponding output set, in order to get a grasp on the way the operator transforms objects **operator: decimal splitter many flavors: with "decimal places units" [[1234]] * [split::decimal] = {[[1 millier]], [[2 centaines]], [[3 dizaines]], [[4 unités]]} with zeroed numbers: [[1234]] * [split::decimal] = {[[1000]], [[200]], [[30]], [[4]]} with powers of ten: [[1234]] * [split::decimal] = {[[1 x 10^3]], [[2 x 10^2]], [[3 x 10^1]], [[4 x 10^0]]} 08 juillet 2021: **edu: many ways to solve a challenge: design challenges so that there are many ways to solve them the schooly way [[7]] * [- 5] * [x 5] * [+ 2] = [[12]] the hacky way the solution seems there for the taking, yet there is an obstacle to work around [[12 (locked)]] when the target is [[12]] : you have to unlock [[12 (blue)]] when the target is [[12 (red)]] : you have to change the color so that it is no longer an arithmetic problem but an object transformation problem the unthought way: there may be some times when students will discover solutions of their own It would be nice to design the hacky way to make student think almost as much as for the schooly way ***operator: 'same as previous': this is a weird operator since it depends on context. Still it may be a funny operator. [[7]] * [+ 2] * [same as previous] = [[11]] ... (*game with students: last man standing in [[0;100]]: Roll a dice, choose an op in {+,-,x,/} and move to [[current]] * [[op roll]]. Player who cannot move loses. ... **challenge: get somewhere: specify target position using word cloud or word graph some words, images, etc. are in the canvas. You have to come up with a "semantic" position. At each pov change, update word enlightening to drive user to target. example: Say the hint is [HOT, wet] then I'd better search on the segment which joins the image of the sun and the word "lake", closer to the sun because the word HOT is bigger (***cn: iC interface: menuing: select by moving in, go back by moving out (***cn: hidden letters: the goal is not to have the guesser select the correct tiles, but to drive the guesser to collect the letters hidden in the tiles teller has the letters highlighted guesser must zoom-in, at the locations carefully hinted by their teller, to discover the hidden letters maybe, then, there is an anagram solving step in order to win the match (***(*)cn: hidden tiles: we keep the "guesser must click on stuff" rule, but the clickable objects are "Z-crimped" in a scene so everything is like a standard codenames game but there are more tiles and they are Z-crimped 09 juillet 2021: **supereasy::measuringScoop: collect a definite number of elements in a pool edu: divide 239 marbles in 11-marble groups: how many groups will we have? Will there be leftovers ? ((edu: introduire les nombres négatifs en faisant un jeu avec des opérateurs [+ 4], [- 5] [+ 3], etc. , et "on joue sur [[0,20]]" 1. atteindre 9 en utilisant des op 2. atteindre 19 en passant par 21 (il faut sortir des limites) 3. atteindre 1 en passant par -1 (il faut sortir des limites par l'autre côté) 10 juillet 2021: **relationship: materialize the relationship between two objects. Enter relationMode, select obj1, select obj2, leave relationMode. examples: 2 similar triangles: ABC --similar_triangle--> DEF scale_factor: rotation: is_flipped: (translation:) between 2 bloom petals: 123 --as_text--> "123", 123 --digits--> [1,2,3] 18 juillet 2021: **iC mutation journey: history by manipulating famous historical personalities animations may be: - user-manipulated object being mutated (getting older, getting murdered, killing someone, becoming king, etc.) - "world" objects moving or being mutated (borders moving, troups moving, king and queens laughing or fleeing, etc.) episodes: one journey for each historical moment Napoleon went there, Napoleon did that, etc. ***boxed notation: """la notation encadrée""" -shu instead of using parentheses, we really do box items ***iC over Maps: put a transparent-bg infiniteCanvas in front of a Maps element and synchronize z scrolls, so that you can now draw over the map Any Maps provider would do there could be a calibration step in which user would contour a map object at different z levels for example a country or a city dev: this would mean transfering top layer move to bottom layer (right mouse pan vs left mouse pan) ***iC over video: same thing with maps but there should be a time synchronization component 20 juillet 2021: ***Z-meaning: zoom inside a word to get synonyms (wordy "Z cloud") and Z-scroll the synonym you want to replace the original word with workflow: enter meaning mode, zoom-in, Z-scroll synonym, leave meaning mode example: My [cat] is on the car. -> My [pet] is on the car. My pet is on the [car]. -> My pet is on the [hotrod]. This can be used with images too. 21 juillet 2021: **object name/content flip/flap say we have an object with name "a" and with content 3x5+12, it is either displayed [[a]] or [[3x5+12]] [[a]] * [flip::to_content] = [[3x5+12]] [[3x5+12]] * [flip::to_name] = [[a]] [[a]] * [projection::value] = [[27]] [[a]] * [+ 1] = [[a + 1]] hahaha, this is were fun begins 24 juillet 2021: **post-naming: 1. draw a pathmade operator 2. spawn a [[x]] object 3. apply pathmade to it: you now have something like [[(50x + 18)/2]] 4. [[(50x + 18)/2]] * [to_string] = [["(50x + 18)/2"]] 5. use that string to name your operator: drag [["(50x + 18)/2"]] into the pathmade slot **(*)challenge: blackbox destruction: [[0]] is a 1-second timebomb, explode in core 1. there is an area to prepare objects: user may create [[0]], [[1]], [[2]], [[-5/12]], etc. 2. [[0]] is automagically cursed: it explodes after 1 second 3. the idea is to use the blackbox operators to end up having [[0]] at the very core of the blackbox, so that the blackbox (or only the blackbox veil) is destroyed edu: the delay is to prevent students from scribbling (this is a very important thing to keep in mind) **scribbling::hard limiter: when scribbling is detected by the system, the GUI is blocked for 5 seconds 29 juillet 2021: **(*)result is collection: [[9]] * [+ 9] = {[[8]], [[1(carry)]]} edu: to programmadraw an addition algorithm each output element may have its own type (to ease further use) **neutron bomb (== size-based chain reaction): each particle grows wrt its value [[<-1->]] * [reaction] = [[<--2-->]] a particle is consumed by the reaction, but, overall, more particles are produced [[12]] * [reaction] = {[[11(input is a bit consumed)]], [[2(output is generated)]]} 31 juillet 2021: **1D photograph of a sector angle pov or maybe a slightly more complex photograph (foreground, background etc.) 1D cam (dynamic photograph) edu: pour expliquer le passage des jours, une fois dessinés le Soleil, la Terre et la Lune, et une fois choisi un point de vue 03 août 2021: **(*)edulab: decimal numeration: putting dots in boxes, putting boxes in boxes there is a dot well there is a box well 1. student can put dots in a box which is a bloom (there is an associated number displayed below the box) 2. when the box is full, student can put it in another box there is a shrink animation when, say, a full 10-capacity box enters a 100-capacity box, so that it looks the same as a dot in a 10-capacity box edu: we can then ask: what if dots were actually boxes ? edu: we may create an algorithm using automatic overflow throwing boxes 1. "self-correcting" (== auto-simplifying) box-based number 2. addition algorithm: fusion of 2 box-based numbers ***programmadrawn cellular automaton: a localized i/o machine example: 10-capacity box: if box is full, it emits a shrunk full 10-capacity box via its output tentacle, which would be received by its connected 100-capacity box neighbor such an automaton could be copied and pasted and then eventually modified edu: on arrive au concept de classe / d'instance et à tous les problèmes de "est-ce que cette màj concerne toutes les instances ou seulement celle-ci ?"... 04 août 2021: **protective shell/[protect] operator: a protected obj will consume its shell instead of being operated on [[2]] * [protect] = [p[[2]]p] [p[[2]]p] * [x 3] = [[2]] (1984!: https://robotodyssey.online/# Warren Robinett! 05 août 2021: **Toolbox: operator wells in a box zoom in to get operator wells auto dezoom when dragging operator out of toolbox invoke/revoke toolbox edu: this would promote user autonomy (== sandbox, editor,...) **(*)programmadraw: press space for "sticky moment": any object touching the vessel when it is having that moment will be captured by the vessel this makes dummy growbounce a bit (animation) **capteurs et activation: à la Rocky's boots Execution is triggered by a sensor edu: this could lead to: function creation challenge: trigger function only when both inputs have been provided **2-input assignement operator: [ [ ] <- [ ] ] edu: user takes a variable and puts it on the left spot, then user takes another variable and puts it in the right spot, which triggers the assignment ***The Hidden Layer: in order for students to create interactive situations without showing the plumbing (==neat interactive), the underlying code is written in the Hidden Layer (~the flip side of the coin) user can enter/leave the hidden layer using a keyboard shortcut some elements have a isShown property so that we know that they will be displayed in the neat layer 08 août 2021: **Math Adventure: an Adventure-like game with math riddles equation lock system: 1. player enters a room in which there is an incomplete equation with an empty slot to be filled example: [[3]] + ... = [[7]] 2. player finds the [[4]] object and places it in the empty slot: the door opens 3. at some point, beside this door, the player needs the [[4]] object to continue the player has to pick up the [[3]] and/or [[7]] and create another equation with the numbers they have in the inventory: the door is open again edu: cette mise en scène met bien en valeur le concept d'équation The world has to contain areas which are completed by small increments, so the player comes back, again and again and again and gradually grasps the whole world 09 août 2021: ((madness: resident evil save game system: combine(ink_ribbon, red_ink): the saved game will be in an altered form when loaded 10 août 2021: **User & Adventure (== "God and Ball"): the game is played by alternate controlling of each character: mouse and keyboard "omniscient roaming" of God vs "joystick control" earthbound roaming of Adventure avatar some parts can only be done by God or by Ball **canvas pieces: some canvas area can be grabbed and put in slots **canvas pieces connections: multiscale circuit-seaming some circuits would be big and some very small, yet they all would have to be connected to go further in the game **(*)function easy drawing area: in this area, the user is asked to draw some function to complete the challenge user would try many different drawings workflow is: 1. drawing 2. testing previous function is automatically erased when starting drawing a new one 01 Septembre 2021: **challenge:Des chiffres et des lettres layout: safe area for combined elements goal operators base elements reset a combined element has two visual parts: top (square): litteral expression bottom (circle): simplified/evaluated value 06 Septembre 2021: **edudemo/edulab: DND addition posée avec la retenue qu'il faut emmener au bon endroit dev: gestion du layout **edudemo/edulab: DND multiplication posée avec la distributivité qu'il faut faire à la main et qui fait apparaître une addition posée en dessous 10 Septembre 2021: **challenge: stats: find the objects given: their count, their mean, their span, their median easy: 1D: x coordinate medium/hard: 2D coords **challenge: stats: find the mean, find the median: they are very small so that the student must compute the value before searching 11 Septembre 2021: ***idée de jeu: jeu de guerre un peu à la Clash Royale Soit au tour à tour, soit en temps réel. Deux châteaux s'affrontent, le camp A et le camp B. A et B se tirent dessus en s'envoyant des nombres. Le nombre qui touche est retiré aux points de vie du château. Chaque joueur peut construire des symboles d'opérations sur le terrain, pour amplifier les tirs ([+], [x]) ou minimiser les tirs ennemis ([-], [/]) Il y a un système de coût pour tirs et les constructions. Des expressions grossissent petit à petit au fil de leur course. On peut mettre des miroirs pour dévier les tirs ou pour les renvoyer. Si une expression est incomplète quand elle touche le château ennemi, alors elle ne fait pas de dégâts. Si une expression incomplète avec une vitesse Vy(A->B) = 1 rencontre un nombre avec Vy(B->A) = 1 alors les deux se fusionnent en un nombre qui a Vy(A->B) = 0 Si une expression incomplète avec une vitesse Vy(A->B) = 1 rencontre un nombre avec Vy(B->A) = 0 et Vx != 0 alors l'expression résultante a Vy(A->B) = 1 et Vx = 0 On peut enrichir une expression avec un quantum de momentum (symbolisé *, ou >>): S'il y a une collision alors le nombre résultat hérite du momentum total (et peut donc potentiellement continuer sa route) De cette manière, on "résiste" aux collisions. avec un quantum de traversée de miroirs (symbolisé -]->), pour ne pas subir l'effet du prochain miroir rencontré On peut imaginer des champs de bataille avec des châteaux en forme de U, pour inciter les joueurs à utiliser les miroirs. 22 Septembre 2021: **0? créer un script qui se rajoute un bloc à lui-même quand il est executé **0 ScratchScratch (comme ScratchGGB mais ici on a deux Scratch qui se contrôlent l'un l'autre) on peut donc écrire du code qui écrit du code **edulab: addition posée avec des horloges à 10 chiffres (chaque chiffre de chaque nombre est représenté par une horloge 0-9) Fractions: représentation Prime climb des inverses *** 0 représentation "PICS" (étoile avec espacements réguliers) 25 Septembre 2021: **bloom: représentation textuelle exemple: 3 - 2 x 0,80 + 10 "J'avais 3 euros. J'ai acheté 2 baguettes à 80 centimes chacune. Ensuite on m'a donné 10 euros." (5 + 2)/4 "On acheté une pizza et une bouteille de jus d'orange et pour payer, on partage en 4." 27 Septembre 2021: *arbre de calcul: "V operator": représenter un opérateur binaire par un objet en V exemple: opérateur x : \ / x qu'on peut utiliser avec [[3]] et [[2]], _que l'on touche en même temps_, pour former 3 2 \ / x 03 octobre 2021: **function scope variables: variables |spawn along with the function execution |move |update |die 06 octobre 2021: **Follower/binding: bind a model object [[]] to a representation object example: bind a number object [[]] to a number line which displays a marker for the bound object (This idea may have already been written down. Still, edu: the "number and number line" version seems very promising 11 octobre 2021: **outil "Simplifier la sélection entourée": Simplifier une branche d'arbre en l'entourant Simplifier un morceau d'expression **icObj::Concat reactor : any object touched by the reactor is .concat(.toStr())'d, so the object grows with every touch ***tree vs zoom level : as you zoom out, nodes are simplified (font corresponds to the current zoom level == tree level) 14 octobre 2021: **player gets penalty each time they use "eval" operator **prevent held object to grow outside prison when Z-scaled (*fun: edu: Little video show as in Zanki Zero (bunny and boy)), this time with math... 18 octobre 2021: ***supereasy collection creation: fromto ".." symbol: type 1..30 to get {1,..,30} collection dev: this implies interpreting input from user **force string input: use double quotes: type "" **[count[]] operator: [count[]] is a platform operator waiting for a [filter] operator to be put on [count[filter]] is a standard touch operator waiting for a collection to touch it [[collection]] * [count[filter]] = [[number of filtered elements]] example: [[1..10]] * [count(is_prime)] = [[4]] (primes below 10 are 2,3,5,7) [[1..10]] * [count(is_element)] = [[10]] (is_element returns true for any input) **edu: [strikethrough[filter]]: strikethrough elements that have been filtered edu: le crible d'Eratosthène, en mode iC: [[1..100]] * [strikethrough[is_2n]] = [[1..100 with even numbers struck-through]] [[1..100 with even numbers struck-through]] * [strikethrough[is_3n]] = [[1..100 with 2n and 3n struck-through]] etc. dev: this means decorating each element of the collection so that they can be struck-through 19 octobre 2021: **collection: layout wrt gesture By dragging here and there (interpret velocity and acceleration changes) OR By drawing 1. hold key and draw layout 2. the chosen layout is applied to the collection examples: draw 3 columns draw a box draw a rectangle draw a circle draw a disk ***edu: many examples at the same time! (using a collection) Instead of showing [[2]] * [inverse] = [[1/2]], then [[3]] * [inverse] = [[1/3]], etc. show: [[{2,3,4,5,6}]] * [c:inverse] = [[{1/2, 1/3, 1/4, 1/5, 1/6}]] 21 octobre 2O21: **[partition[filter]]: partition collection in 2 subcollections using filter edu: pour montrer les étapes successives du crible d'Eratosthène 26 octobre 2021: **select and move via temporary composite: 1. select multiple objects => a temporary composite handle spawns 2. move objects using the handle 3. when clicking out of the handle, the temporary composite is destroyed **city-like number: number appearance depends on zoom level: _100_, 2 x _50_, 2x5 x _10_, 2x5 x _2x5_ ----- zoom level ---> 02 novembre 2021: **button::draw: [draw a circle at: x<...>, y <...>] **stamp: stamp any object: create image containing the appearance of the object 05 novembre 2021: **progression circles à la Duolingo/Blockly games: cercles et arcs de cercles (*edu(/et utilisation du numérique en général): les utilisateurs veulent 1.pouvoir fabriquer des images facilement (composants paramétrés) 2.avoir des images qui s'adaptent au contenu (composants réactifs) **icObj.type = 'pixel' : constant homeScale and scale = 1, width=height=1, integer coordinates 06 novembre 2021: **icObj.type = 'cursor' : a temporary hud indicates the coords of the point ***railroad tracks "reach" riddle: player has to select(or forge) the correct starting number which will end at target destination there are many tracks each track is composed that way: a transformation area and an examination area (==switch) which is linked to other tracks each track has its own color (edu) example: [ ]=========[/ 3]======[is_even]--yes--> ========[+ 7]=======[mod 3]--0-->[destination] | |--1-->[destination] *target destination | |--2-->[destination] |--no--> ========[- 4]=======[> 6 ?]--yes-->[destination] |--no-->[destination] target destination may change once the correct destination has been reached **railroad tracks "fill" riddle: each destination has a number attached to it, meaning the number of times it must be reached you cannot use the same number twice at the start of the railroad tracks 07 novembre 2021: **edu::highlight: highlight means dimming other things and shedding light on the highlighted This would be useful when working with collections example: when working with [[1..100]], highlight all multiples of 5 all multiples of 3 all prime numbers, etc. 08 novembre 2021: **size ranges for each type of number representation size range ("center"): integer numbers in -100..100 size range ("small"): fractions size range ("big"): big sci numbers size range ("anywhere"): any sci number edu: basé sur la réflexion sur la taille optimale de chaque espèce vivante (les humains font entre telle et telle taille, les fourmis entre telle et telle taille, etc.) 12 novembre 2021: 0 create lesson (==front logo double-object + linked challenges) 0 create portal between lessons *edu/dream: student can grab a challenge and Z-drag it (via portals, etc.) to another place where it can also be useful => challenge is no longer a challenge, challenge is now a tool: "challenge hack" 13 novembre 2021: (*autour du "dive-in": on pourrait imaginer un codenames dans lequel on pourrait plonger dans les mots pour voir tout l'univers lexical associé, pour nous donner des idées de connexions **quest of pi: on commence avec 3 puis petit à petit on récupère les décimales étape 1: on commmence avec 3 et il faut se transformer pour atteindre un certain nombre cible étape 2: on commence avec 3,1 et il faut se transformer pour atteindre un certain nombre cible étape 3: on commence avec 3,14 et il faut se transformer pour atteindre un certain nombre cible etc. 28 novembre 2021: **PPPPLLLAAAASSSMMMMAAA!!! hint: Comme dans Mystical Ninja Starring Goemon, il y a un endroit qui peut nous donner un indice Il faut parfois faire beaucoup de chemin pour retourner voir Plasma mais c'est pas grave, ça réactive ***gamepad control/gamepad feel: RT/LT: zoom in/zoom out greenMouse: pour commencer un challenge greenMouse, il faut rester appuyé sur le bouton A quand on touche la valeur de départ et rester appuyé jusqu'à la fin du challenge quand on lâche le bouton A, on revient devant la "porte d'entrée" du challenge dans une SafetyZone, on peut lâcher le bouton A B pour "courir" 29 novembre 2021: **greenMouse challenge sausage: challenges are put together in a row, which will result in a sausage-look from a sausage ch1>ch2>ch3, we can build a harder challenge, requiring the use of more operators, by going back to start#1 and ending at end #3 this challenge would be a way to combine all we learned so far in ch1, ch2 and ch3 ***dessin à la manette: à la sketchful.io mais on dessine à la manette 11 décembre 2021: **quand deux collections se touchent / attributs de collection 17 décembre 2021: ***morpher: from/to pebbles (relative numbers) edu: pour faciliter la transition cailloux -> symboles 18 décembre 2021: ***Z-pebble-tree: a way to represent the commutative law for multiplication as for organisms, each zoom layer has its own "organumber" (i.e. number of components inside an individual cell) edu: la commutativité de la multiplication comme échange de motifs à 2 niveau de zoom différents 3 x 4 x 2 = 2 x 4 x 3 29 décembre 2021: (***hexMaps generation : use zscroll to shrink a grid so that it's now in a frame ("forest" frame for instance) which paints its cells in a "forest" way one frame for each map type so big maps can be made by assembling grids 07 février 2022: ***object configuration via "parameter touchSlots" touchSlot which change the value of a property in the held object, but an "OK" touchslot must be touched to confirm the change dropping the object without confirmation will cancel the change 08 février 2022: ***anyshape touchslot **Gutter touchslot (=="wrapping" touchslot) challenge border belongs to target touchslot so when you have the correct result you can validate it even more easily 03 mars 2022: **n-step'd multipathmade: record: obj1: move1 then move2 then moveN, then obj2: mov1 then mov2 then movN then objN: ... 08 mars 2022: ***writing pad Pick a placeholder, write digits sequencially or whole number at once : placeholder is now the written number Associated challenge : write then 2 ops then target (for example : find what to write in order to complete operation sequence : [[< >]] [+12] [+16] == [[73]] The ops _must be used_ (red light for unused and green light for used) for target to be touchable Last written number is kept as pad background **(*)step-by-step 'reveal' along computing (Pythagore): 1. A geometrical situation is displayed and some labels are wells (example : a and b in the canonical Pythagore config) 2. when a^2 is created via [[a]] * [^2], the square with area a^2 is revealed 3. etc challenge avec arrondi (opérateurs d'arrondi) **workZone/submitZone En haut on triture, on travaille En bas, on répond **edu:vérifier une fois une solution trouvée ***Time control / time picker/setter pour l'écriture/édition de fonctions complexes **fun/experience: Dizzy POV: pov's scaleX and scaleY oscillate around the mean value so that current scale is not precise, only mean scale is experienced **semantic disposition of text: main ideas in front, sub ideas are deeper (really "sub") autoread: keyframing reading povs there would be different degrees of reading: shallow: only front words full depth semi-deep easy: no-brainer textual pov keyframe animation: 1. some pov contain "title" icTexts 2. user types the sequence of words in a textConstructor: [povAnim: ["corbeau","renard","fromage","mare"]] => a keyframe animation is created, moving from titled pov to titled pov 14 mars 2022: ***scroll to control what is target in expression navigate expression tree by scrolling current target is highlighted when operated on, new target is operation result 18 mars 2022: **challenge:: (x;y) coordinates: 1.student grabs the point for which to determine coordinates 2.cross can only move vertically and when it has reached x-axis, then it becomes free 3.cross can then touch the appropriate x-coordinate, in an operator cloud around the grid 4.student has then to move back to the point so that it fills the x-coordinate slot 5.cross can now only move horizontally and when it has reached y-axis, then it becomes free 6.cross can then touch the appropriate y-coordinate, in an operator cloud around the grid 7.student has then to move back to the point so that it fills the y-coordinate slot 8.done 21 mars 2022: 0 refaire des maths complexes en essayant de les coder dans iC 11 avril 2022: **Voice control: greenMouse moves to perform the operations told by user trajectory is controlled so that no unwanted middle-man operation is performed Quand on fait rightClick pendant un drag, ça fait un draglock (on peut lacher le leftClick) et quand on rappuie sur le leftClick, ça reprend le drag comme d'habitude **"dragCancel": rightClick when dragging cancels last operation or simply ctrl+z while dragging 26 avril 2022: *pathmade:"draw below"/"instant trigger": 1. pathmade path drawing can start where an object [[x]] lies 2. when path drawing is done: pathmade touchSlot spawns right below [[x]] so that [[x]] * [pathmade] occurs immediately after end of path drawing **gm/pathmade challenge: draw function and start: function and gm are reset if target is not equalled 27 avril 2022: ((*en "recherche créative", il y a une inspiration qui vient du fait de vivre dans l'environnement des objets. C'est par la connivence avec les objets que viennent de nouvelles idées. Les objets, par notre intermédiaire, donnent naissance à d'autres, et etc. 29 avril 2022: edu: le fait de devoir se débrouiller avec moins d'opérateurs que prévu est une situation pédagogique forte 30 avril 2022: dump: IC::Weight and price: player must take the right weight of each product and get total price as target (correct target is not displayed): a pricedObject is taken from a drag well then we display = image (tomato) + weight + price, starting object weight is 1kg IC::pathmade:: operator level: when object follows path, its level is also downgraded to the path level (level of operators crossed along the path) so that user functions are well separated from primitive operators IC::gm: first with x, then with 5, 15,... Ic::edudemo avec segment coupé en 10 morceaux (Z-scroll pour montrer les dixièmes,centièmes...) Et aussi les dizaines, centaines, etc. IC::growing ruler : starts at 1grad and then grows or shrinks : unit1 is kept visible **IC::(rei) challenges: target is cryptic (3/2 * x + 3/2 * x + 5) (coming from another operator set) **IC::gm VS (2 players): two sides of operators, one shared target IC::incarnated number Lock and key : Object is key and incomplete door to perfectly fill Line Square ... **challenge: Que va faire ce chemin ? On peut suivre le chemin pour avoir la réponse On gagne plus de points si on trouve sans manipuler 02 mai 2022: **challenge:gm:numeration [+ 10^6,..,+ 10^-6]: "rootScaled" operators: [+ 10^6] is at big scale, [+ 10^-6] is at tiny scale z-scroll is at the heart of the gameplay: contactArea and "contact scale" allow scale-specific interactions **challenge:gm:prime decomp: [x 2,x 3,x 5,x 7, x 11, x 13, ...] **edudemo:gm:prime decomp "by hand" (try / 2, then try / 3, ...) (use inverse operators or undo when "it does not work") 03 mai 2022: ((le temps de la récolte *[ 0 numération: 0 opérateurs dans le désordre (random on operators order) exemple: [+10,+1,+1000,+100] 1 [+10^3, +10^2, +10^1, +10^0] 1 valid display 0 paires [+k * 10^(n+1), - 10^n] pour voir s'ils ont bien compris (il faut qu'ils arrivent à se débrouiller) 0 version longue: [+10^6, ..., 10^-6] 0 version semi-longue: 7 opérateurs 0 version longue: avec opérateurs au dessus 1 ensure target is integer when working with [+ 0.5]-like operators (0 operator must be used nk times 0 relatifs 0 [+10,+1,+0.1,+0.01] start dans [ -5; 0] et target dans [0;5] start dans [-10;-5] et target dans [0;10] start dans [-15;-10] et target dans [-10;-5] ** 0 display graduations at center with initial/current and target 0 approximate 0 sqsqrtpow 0 relations order 0 misc *] 04 mai 2022: ***challenge::gm::révise tables: [x 6] [x 7] [x 8] [x 9] [[1]] [t t] [x 2] [x 3] [x 4] [x 5] simplifier 1 x 4 mais ne pas simplifier 4 x 4 challenge::gm:pow [t 2^3 x 5^4 x 7^2 t] challenge::gm:functions [[5]] [t t] [f] [g] [h] label: f(x) = 3x + 2 label: g(x) = 5x - 1 label: h(x) = x + 10 [[5]] * [f] = [[f(5)]] [[f(5)]] * [g] = [[g(f(5))]] **challenge::gm:système d'équations: each equation object is also a substitution operator for the active equations object [[x + 5y = 8] * [[x = 2y]] = [[2y + 5y = 8]] [[2y + 5y = 8]] * [réduire] = [[7y = 8]] **la soustraction "sobre" (la soustraction des petits): faire une transformation nulle quand on essaye de retirer plus que possible 05 mai 2022: challenge::gm:units [grow unit]/[shrink unit] 0 m [/ 10 (number) x 10 (unit)] 0 m² [/ 100 (number) x 10 (unit)] 0 m^3 [/ 1000 (number) x 1000 (unit)] **display mathsteps step by step solving with ic::gm moves and interactions (make it a-live) https://github.com/google/mathsteps 06 mai 2022: **(*)gm::stained gm: if you use a red operator, gm is stained red [[1]] * [+3 {red}] = [[4 {red}]] colored target: if target is blue and gm is red, it won't validate edu: c'est un levier pour amener les élèves à n'utiliser que certains opérateurs, ou alors pour les amener à chercher d'autres opérateurs, même s'ils sont _loin_ **structure:challenge::ping pong: validated target becomes initial, player continues holding gm, operators are changed, old initial is set to new target so gm goes right, then left, then right, etc. edu: this allow chain-testing different skills (one skill ->, another skill <-, etc.) edu: cela habitue l'élève à des enchaînements de transformations (comme dans les longs programmes de calcul, ou dans les longues séquences de déduction) 07 mai 2022: **gm::composite operators: tree-like: [x 2 x 3] <=> [x 6] [+ 3 x 4] <=> [+ 12] sequential: [+ 3) x 4] <=> [+ 3] then [x 4] use them for frac pow numexp litexp *gm::"out_of_the_box": player has to transform target instead of initial (there's no other way) ***gm::teleport-spread challenge: challenge is spread on many courses : using a teleport-modified operator teleports to "same position but on a different course" edu: units: one course per measure unit course-shift operators: [<--] [-->] [ ] [ ] [ ] [ ] [ km] [ hm] [ dam] [ m] [ ] [ ] [ ] [ ] **zone unit-projector: zone is operator which converts incoming object's unit to zone's unit edudemo: function "painting": dragged is operator starting configuration : a collection of numbers along the x-axis, each corresponding to their x-axis coord when user touches an x-axis [[number]] with the [f] dragged operator, [[number]] transforms into [[f(number)]] and moves to its corresponding y-axis coord [f]_dragged * [[x_value]] = [[y_value]] (champ d'innovation interactive 08 mai 2022: edudemo: units: legend-scroll: unit segment adapts to scale (à la kookleMaps) **units-bloom: show different segmentations of object wrt different units **fractal operator/shared isTouched: a big [x 2] operator contains smaller operators inside [+ 3] [x 4] [/ 5] [x 2] [[object]]_small * [x 2]_small = [[object]]_big but [[object]]_big does not immediately react with [x 2]_big, since isTouched is shared edu: this allows progressive growth of number 09 mai 2022: (delirium: true-scale piano: use ic::xylophone keys as true piano keys to make music with il faudrait trouver un moyen de se déplacer rapidement dans le scale: ?"scale gloves"? (se recompliquer la vie pour le plaisir) **create a collection of equivalent operators: [/ 2] <=> [x 1/2] <=> [x 2^(-1)] <=> [x 0.5] ... edu: equivalent operators to create advanced challenges *[creation]"randomness à la rescousse": générer des challenges aléatoires à partir d'une grande collection d'ingrédients et garder la recette quand c'est bon 11 mai 2022: ***![gm::challenges]: _different rewrites_ for initial/target and operators (!THIS IS ACTUALLY VERY IMPORTANT!) edu: étant donné que la réécriture/simplification est le vecteur principal de transmission, en fait, c'est là que tout se joue ! (Du pareil au même, il y a une infinité de réécritures ! dev: "dynamic rewrites" il faudrait programmer des réécritures qui s'adaptent au niveau de compréhension de l'élève élève en cours de compréhension: mettre des réécritures "explicitantes" élève qui a compris comment ça fonctionne: réécriture "cible" 15 mai 2022: (idée bizarre à essayer: "random eval" operator: [[3x² + 8x + 9]] * [random_eval(x) {1,2,3,4,5}] =_exmpl [[3(3)² + 8(5) + 9]] each math.SymbolNode(x) appearing in the expr tree has its own evaluation (eval inverse operator: deval [[3*2² + 8*2 + 9]] * [deval 2] = [[3x² + 8x + 9]] 17 mai 2022: *edu: the more the student understands, the less we can simplify/rewrite the expressions because the number is less and less a writing but more and more an idea (2d-array of challenges for compound units: m m/s m/s² 18 mai 2022: gm::challenge::stats: user can grow a collection of values and then use an operator to get to target [add value] [add value] [add value] (may be random) [[initial collection]] [[target value]] (may be empty) [statitistical operator (== collection operator)] 0 moyenne 0 frequence 0 étendue (((idée farfelue: avec 2 écrans: affichage inversé: l'affichage correct des opérateurs est sur l'autre écran, il faut regarder l'écran de l'autre, et l'attendre avant de valider car sinon ses opérateurs sont rafraîchis (P1.operator.display is on P2.screen) gm::challenge:geometry: soul-moving mouse: gm's body does not move but gm's soul does, and this activates the operators which transform gm's body edu: this allows transformations such as translations, rotations, homotheties, ... 20 mai 2022: **gm::challenge::litexp: operation combination: [x 2] [/ 6] for target, [/ 3] for op 0 litexp: operation combination: [x 2] [/ 6] for target, [/ 3] for op 0 sqrt: sqrt1: racines faciles sqrt2: racines et [x (-3)] initial: [[1]] operators: [x (-3)], [sqrt] target: [[-9]] 2 flavors: show error: (afficher brièvement [["erreur!"]] ou [["impossible"]] quand on veut faire sqrt(-3) ) enable/disable: disable [sqrt] operator when gm is invalid arg for [sqrt] sqrt3: réécriture de racines 0 développement automatique: [[(1 + 2)]] * [x 3] = [[(3 + 6)]] 0 [estampiller motif en haut à gauche] [sym horiz] [sym vert] [rotation] [colorier en rouge] [protéger] (à la color balls) 0 carrés colorés (ou chaîne de caractères): multiplication qui recopie le motif à la fin VS multiplication qui multiplie chaque carré [[abc]] * [x 2 "copy"] = [[abcabc]] [[abc]] * [x 2 "map"] = [[aabbcc]] 0 dessine quelque chose : des opérateurs [coordonnées 2D] sont donnés en haut, et rafraîchis après chaque touch, [[crayon]] * [coordonnées 2D] = un point est inscrit dans le repère à droite ((faire un truc avec les nombres en écriture à l'envers (symétrie axiale pour introduire les nombres négatifs) 0 cycle 2/3: [[000]] [[549]] [changer chiffre des centaines] [changer chiffre des dizaines] [changer chiffre des unités] 23 mai 2022: gm::challenge:litexp: écrire l'expression littérale qui correspond au programme de calcul 0 eq1b: use close-to-0 rhs [[x - 67 == 1]] [[x - 38 == -2]] 0 eq2_add: +/- magic 0 [[x + 13 == 22]] should become [[x == 22 - 13]] rhs__start must be kept as is, in order to demonstrate the +/- magic => rhs starting value should be treated as symbol **edu: "symbole numérique" 0 eq3_magic: make them use magic ** magic operators: [- = --> = +] [+ = --> = -] [✕ = --> = ÷] [÷ = --> = ✕] 26 mai 2022: **symbolify(mathNode): use random generated string for symbol name (on peut rendre symbolique n'importe quelle node) 27 mai 2022: ic::gm::"target by tests" challenge: built gm must pass all target tests target test is gray at start target test becomes green when passed, red when not passed ic::gm::ghost denial ic::gm::par break: gm dies if above par ctrl-z can bring gm back to life if drag is still on 30 mai 2022: *[structure]gm::challenge:en 4 opérations _exactement_ [- ] [- ] [- ] [x ] [[initial]] [[target]] [+ ] [+ ] [+ ] [x ] *gm::challenge:vecteurs v1: [[initial]] et [[target]] et [[current]]: montrer le vecteur et ses coordonnées v2: [+ vecteur], [- vecteur]: montrer le vecteur et ses coordonnées v3: there is a [norm] operator and target is a number **gm::challenge::numexp:edu: réutiliser les "nombres expressions" des réussites précédentes dans les nouvelles instances des opérateurs au lieu d'écrire [x 4] on écrira [x (13 - 5)/2] **gm::challenge::numexp:tables de multiplication en nombres expressions (on rafraîchit les opérateurs toutes les 10 questions) **gm::challenge: moving operator changes its effect (its "node_b" if it's a binary operator): |-----------------------------------| |zone(1) |zone(2) | | | [+ 2] [/ 2] | |-----------------------------------| |zone(3) |zone(4) | | [x 3] | [- 4] | ------------------------------------| on peut faire la même chose avec des node_b en litexp [x (4 - )] fun: bouger le gm well change la valeur initiale et bouger le target change la valeur cible challenge:zone(+10) to zone(-10) in lines zone(+10) --------- zone(+9) ------- ... edu: this would be used as a summary of the use of relative numbers with [+][-][x][/] this could be displayed with a gradient: positive : red, zero: white, negative: blue **[structure]gm::challenge: use each operator at least once before challenge refreshes user accomplishes initial --> target many times, so that they end up having used at least once each operator of the challenge already used operators are highlighted so that user knows which one remains an operator that has been already used can still be used edu: les amener à pratiquer tous les chemins, même ceux qui sont chiants **(*)gm::challenge::numexp: fabriquer des "morceaux équivalables" dans le target, que l'utilisateur devra équivaloir en utilisant les opérateurs **gm::challenge::conversion/equations: [[initial: 1 blue gem]] [[target: 22 red gem]] [x 2] [+ 5] ... [conversion operator: 3 blue gems = 1 red gem] conversion operator is always "last move" ***tables X decimal: variante 1: [x 6] ... [x 9] [/ 10] [[1]] [[0,32]] [x 2] ... [x 5] [x 10] variante 2: [x 0,6] ... [x 0,9] [[1]] [[0,04]] [x 0,2] ... [x 0,5] **gm::challenge:proportionnal: target is missing cell in a proportionnality table **[display]gm: object as string: show [[un]] instead of [[1]], [[deux]] instead of [[2]] [[un]] * [+ 5] = [[six]] **[display]gm: operator as string: [ajouter deux] [soustraire le nombre de départ] (initial banner displays what was initial object) **[display]gm: target as string: [[somme de 32 et 4]], [[différence entre 4 et le produit de 5 par 10]] edu: pour faire assimiler le vocabulaire, on demande uniquement des cibles du genre [somme de < > et de 4] [différence entre < > et 4] [produit de < > par 4] [quotient de < > par 4] avec une zone de challenge: [] [] [] [] composer le nombre de gauche [[]] [[]] [+ 4] [- 4] [x 4] [/ 4] **tree scroll(==highlight scroll): scrolling changes which part of active litexp object will be operated on [[3 + _1_]] * [x 2] = [[3 + _1 x 2_]] [[_3 + 1_]] * [x 2] = [[_(3 + 1) x 2_]] **edu: tables: réactivation instantanée: au tour n, afficher dans banner2 (au dessus de target) l'égalité que l'élève vient de réussir au tour n-1 une image statique qui va potentiellement se fixer dans la tête de l'élève fun: chiffre de César: [.a] [.b] [.c] [.d] [[""]] [[xtyz]] [<<3] [>>3] **gm:challenge::fractions: utiliser indiféremment [/ 2] et [x (1/2)] dans le challenge **gm:challenge::fractions: montrer avec des visuels (coeurs à la Zelda par exemple) que [/ 2] et [x (1/2)], c'est différent mais ça revient au même [/ 2] = on applique / 2 à l'ensemble [x (1/2)] = on applique x 1/2 à chacun [[3 coeurs]] * [/ 2] = [[1,5 coeurs remplis et 1,5 coeurs vides]] [[3 coeurs]] * [x 1/2] = [[3 coeurs à moitié pleins]] ((Is [( )] the same operator as [symbolify] ? 01 juin 2022: gm::challenge::frac:: frac stacks **[structure]gm::challenge:color collection: bottom operators are actually buttons that switch between top operators collections **gm::challenge:color sequence: player must reach [[target]] using operators and respecting colors order [] [] [] [] color collection operators [[initial]] color order: green;red;blue;red;white [[target]] [blue] [white] [red] [green] **gm::challenge::numexp: 3 [eval]s allowed: allow player to evaluate its numexp 3 times [=] operator (there exists: saturating addition/subtraction: result is clamped to stay in [min;max] **gm::probabilities: blinking operator: pour montrer [x X(w)]: afficher des réalisations à chaque tick: RandomNode(arr_values, arr_weights) operator is constantly blinking with possible outcome values **gm::probabilities: static operator + temporary blinking output (Mariokart-style): output blinks in the probability-style during 0.777 seconds before locking on a value **gm::probabilities: permanently blinking object: [x 2] [+ 3] and such operators change random range but object continues being random 02 juin 2022: **gm::range: [[range]] [[target range]] [∪ [2;3]] [∩ [-1;1]] [complementary] [∩ ℤ] 1. easy range 2. [x 2] can be interpreted as grow any component by 2 **gm::sets 03 juin 2022: gm::challenge:: obstacle waterfall: [operator] will be applied in turns edu: il faut prévoir à l'avance l'effet de l'opérateur 06 juin 2022: **gm::challenge:dec_to_sci [[target]] == [[2 x 10^2 + 4 x 10^1 + 3 x 10^(-1)]] 1. small exponents 2. all exponents (3. shuffle terms --> edu: may bring confusion 3. sum of minisci 4,6 x 10 ^3 + 1,2 x 10^1 **(*)gm::challenge:money: [[target]] is a certain amount of bills and coins and operators are [+ 5€] [[current]] is displayed in bills and coins too 1. [+ 1€] [+ 5€] [+ 10€] [+ 50€] 2. subtract operator 3. mult operator 4. divide operator 5. transition vers les équations: utiliser deux monnaies avec un taux de change facile (5 reals = 1 euro) 6. transition vers les équations: acheter quelque chose **gm::opérateurs conditionnés: [if input>100: x 10] [if input<0: + 25]: il faut trouver un chemin pour aller de [[initial]] à [[target]] edu: this way player practices arithmetic as well as logic 07 juin 2022: gm::challenge::numexp/litexp: factorize/develop i:[[0]], o: [+ 2(x + 1)] [- 3(x + 4)] [+ 6x] [- 4x], t: [[5x - 10]] 1. with step simplify 2. without step simplify 3. develop/factorize gymnastic [factorize] [develop] [[0]] [[2(x + 2) + 3(y + 4) + 5]] [+ x] [+ y] [+ 1] **gm::new argument building workflow: [[0]] * [+ 2] = [[0]__+ 2_ (proto object) [[0]__+ 2_ * [x 3] = [[0]__+ 2 x 3_ [[0]__+ 2 x 3_ * [realize] = [[0 + 2 x 3]] ***[structure]gm::"super" gm: a super challenge is proposed, and in order to activate one of its operators, the operator's sub challenge must be completed [[super initial]] [[super target]] [[super op]] [] [] etc. [] [] [] [] super op's challenge edu: this structure is interesting because it promotes decision making because it can grow scale-invariantly because it shows the moving back and forth from top-level to low-level because user can complete all sub challenge if they have no clue on how to solve super challenge because solving a sub challenge may give ideas on how to solve the super challenge 09 mai 2022: **gm::at least images: for unsupported browsers, provides a few images of each challenge to display in classroom **gm::different types of target slot: "writing": expression must match exactly value: expressions can differ as long as evaluation is the same ***gm:teintures de franchissement: i:0 o: [+ 25] [- 25] [if>100: paint red] t: [red -50] edu: cela oblige les élèves à passer par certaines valeurs *** on peut complexifier encore en mettant la couleur comme condition: [if(red): x (-1)] edu: on mélange arithmétique et logique remarque: technique de game design à l'ancienne (Super Metroid, ...) 12 juin 2022: **gm::challenge::frac: simplify(n) [[frac{5x6x7}{6x8x9}]] * [simplify(6)] = [[frac{5x7}{8x9}]] operator display: [frac{stroke(6)}{stroke(6)}] (?**symbolification levels: [[symbolified(level 2)]] * [operator working on symbolified(level 1)] = [[symbolified(level 2)]] 17 juin 2022: **gm::challenge::litexp: expression as arg: banner: A = 3x + 2 , B = 5x - 4, i:[[0]] o:[+ A] [- A] [+ B] [-B] t:[[11x]] **gm::challenge::num: make a number which reaches inside of cloudy area the number line is diplayed a part is cloudy a bloom is displayed (segment bound to [[current]]) target touchslot still exists player can validate when segment end is inside cloudy area edu: this is to make link number as segment of length -> number as point on the number line 20 juin 2022: **gm::motifs bitmap et opérateurs sur les bitmaps inverser les couleurs inverser le bit central décaler gauche/droite projecteurs: rouges deviennent verts colonne de droite devient entièrement noire **gm::mathador touch ***gm::"l'Atelier": système d'équations i:[[10x + 9y = 2]] o:[platform +] t: [[x = ?]] [[5x + y = 1]] [x 2] [x 3] ... [x (-1)] [[y = ?]] [+ 2] [+ 3] ... **gm::π:: broken line/curve bloom: when doing * [+ 1]: a segment is appended to the broken line/curve when doing * [+ π]: a half-square curve is appended to the broken line/curve when doing * [+ π] * [+ π]: curvature is reversed so that the line does not close itself 23 juin 2022: ***gm::clear dying curse when reaching target in order to show different solutions edu: this way we can display different equivalent expressions gm::challenge: many ways : challenge renews when player has found n different possible solutions 27 juin 2022: **edu:: key: next display mode: pour passer facilement de [+ 3] [✕ 2] à [x ↦ x + 3] [x ↦ 2x] et montrer que l'opérateur ne change pas, seulement la façon de l'écrire 28 juin 2022: **gm::challenge::sequence operators: snap the sequence there is a snap slotted platform operator in the center bottom and top operators only work when snapped in platform operator [+ 2] [✕ 3] [- 8] [+ 4] [[i]] [platform with snapslots: [] [] [] [] []] [[t]] [-1] [+ 10] [✕ 7] [/ 2] **gm::challenge::litexp: build then eval [+ 3x] [✕ 4x] [x 3] [- x] [[x]] [[12]] [x <-- 2] [x <-- 3] 30 juin 2022: **[structure]gm::challenge: 3 targets with chests: reward is operator which may help to open the other chests *[mechanic]gm::Merge: [+ 2] *merge [+ 3] = [+ 5] **(*)curse: diminishing number: [[1]] -time> [[0.98]] -time> [[0.96]] edu: this is to insist on the fact that numbers have neighbors, that the number line is full of numbers [[-1]] -time> [[-1.02]] -time> [[-1.04]] **diminishing curse operator: [curse: diminish] **"glass" curse: must stay pair ***Interface: PAUSE: freeze GM and free mouse cursor GM.state = Frozen edu: this is to enable conversations with students at the middle of an attempt **gm::challenge:litexp: build a litexp which satisfies the transformations in target banner example: {3 -> 4 ; 12 -> 15; 20 -> 21} [[0]] [] [+ x] [- 2x] [✕ 4] [/ 5] ***edu: concept introduction: concrete situations challenge mix mix standard number transformation challenges separated by similar transformations challenges of not-number things example: i:[[pizza drawing]] [[quarter of a pizza drawing]] [- 1] [+ 2] [✕ 5] [/ 4] edu: operators _may stay numerical_ to promote a discussion around _units_ in some case, [[pizza]] * [- 1] = [[7/8 of a pizza]] in another case, [[pizza]] * [- 1] = [[1/4 of a pizza]] in another one, [[pizza]] * [- 1] = [[nothing]] **[structure]gm::challenge: make 0 edu: use number symbol so that [[current]] is [[i +/- arg (+/- arg...)]] numer::analog computing: i: [[29 x 42]] t:[[0]] [- 1218] [- 8112] [- 128] [- 12184] edu: pour habituer à la relation entre [[- 50]] (nombre négatif) et [- 50] (soustraire 50) negat: [[50 + 12]] [[0]] [- 50] [- 62] [+ 52] [- 3] 26 juillet 2022: **iC::TH (TreasureHunt): mettre des chasses au trésor dans une partie /fun du site (qui peut servir de tutoriel) **iC.obj: followMe: one-way screen-pushed voyager ***(*)paper user interface: QRCode-cardback usecases: paper jukebox: user has a deck of cards with song names, which will play as soon as their qrcode is scanned paper zoo: child has a deck of animal cards, which will spawn in ic ***GM as card game: cartes opérateur ([x 2], [+ 4], etc.) qrcode sur le dos de la carte objet sur le téléphone [[3]] pour appliquer l'opérateur, on passe la carte opérateur sur le téléphone, dont l'objet va se mettre à jour ***ic for tablets: left half: pan/zoom right half: draw **Twinstick drawing: LeftJoy Pan RightJoy Move/Draw RTLT zoom/dezoom **on drop addition: [[2]] *d [[3]] = [[5]] ***edu: calcul mental en 2 temps: 1. montrer des objets, plus ou moins mélangés, chacun en un certain nombre d'exemplaires 2. Donner le prix unitaire de chaque objet et demander combien ça fait Rq: on peut ajouter des billets qui fonctionneront comme des objets à prix négatif **create patterns using probabilities: [[100X + Y]] is represented as a comb ***dynamic bloom (==bloom X probas): dynamic segments and colors **gm:challenge: partie entière/partie décimale: Target is some part of initial, player has to CLAMP using [x 10], [/ 10], [floor], [decimal_part], ... **gm:challenge::functions: 1. [d/dx], [* x], [+ 1] 2. [intégrer avec une constante aléatoire] **gm:challenge: last thing is to evaluate: 1. player creates litexp 2. player uses [x <- 3] operator to transform litexp into value Using assignment operator transforms all operator into [id] gm:challenge:solution/no_solution: player has to choose if there is or not a solution (-1 point if they say there is no sol when one exists) gm:opérateurs de grignotage de tablette de chocolat: [-1 sur 2], [-1 à la fin], [x2 horiz], [x2 vert] (validation sur le principe des serrures) **easy: this.qrcode: show qrcode of current url for others to join 27 juillet 2022: **easy: construction/mutation from text object: iCTextConstructor example: to generate QRCode image: 1. create iCTextConstructor 2. write "qrcode myFabulousInputText" as args then iCTextConstructor mutates into icQRCode or icImage example: to generate video object: "video https://myAwesomeVideos.lol/vid1.mp4" (**game: time puzzle: pieces are videos and user has to find the right frame for each of them in order to recreate puzzle (some of them may be static in order to give a little hint) 01 août 2022: **easy: vitrifier: lock all objects scope vitrifier: lock all objects fully inside screen rect boundary 02 août 2022: **(*)(TH)timewise double-object: front object is video and back object is shown only when video.currentTime is valid this way, player has to concentrate on the video content in order to determine where in time is the back object edu:this way we can associate an exercise/challenge with a special moment in the video **drag-and-drop heliport: this object waits for user to dnd content in it it may be data, link, text... 05 août 2022: ***to record a recording (!= record): in order to create tutorials that show record creation and use ****functions which output functions (pathmade which outputs pathmade): in order to have functions as first-class objects **Th:rainbow anagram of rebus: rainbowify(arr_symbol) edu: autosum(collection of objects and their prices) show intermediate numerical expression show result **(*)challenge sausage with [uncurse] and p[GM_dropslot]p intermediate challenge sections p[GM_dropslot]p allows to pause for a while, and to work with a intermediate result [reset] operator brings back to start | [+ 4] [- 3] [+ 1] [uncurse] | [+ 4] [- 3] [+ 1] [uncurse] | [] [] [] [reset] [[i]] | p[GM_dropslot]p | p[GM_dropslot]p | [target] | [- 1] [+ 5] [+ 10] [+ 6] | [- 1] [+ 5] [+ 10] [+ 6] | [] [] [] [] edu: this system allows the making of very complex problems ***TH:ICU (à la pokémon snap): player has to take captures of items in a list inside the ic photos are automagically placed on the side of the corresponding list item, along with a checkmark **Z-index for paths: OOO: last created is followed first many ways to do it but "remember previous 'owner'", so that paths are env-agnostic, seems elegant *ic::video:controls:fun: slider is far away from video, or too big/too small **iMc: infiniteMusicalCanvas: music contains different scales of content ('zooming' == 'reducing playing speed' ) **ic:calendar: one cell for each day, which may contain a lot of information you can put an unlimited amount of stuff in any day's area you can get dive into a previous day and pick content from there ***ic:p2p: no master server, only a web of clients ***easy: portal creation ('echo' portal (==object-based portal)): 1.select in canvas the object to portal into 2.create echo portal 3.move the echo portal at the desired spot now, entering the echo portal will do the same as entering the original object **[structure]ic::challenge:experience impermanence: when any operator triggers, it also affects all other operators (and [[initial]], and [[target]]) example that is actually useful: [MAJ]* {[.a] [.b]} = {[.A] [.B]} activation of MAJ operator transforms [.a] and [.b] operators into their uppercase equivalents 07 août 2022: **ic::time portals: portal drives you to videoObj _at time x_ 10 août 2022: **serialize as .js: const = {}; + textConstructor(infinishute ) in order to create maps or webpages: textConstructor(infinishute house), textConstructor(infinishute road)... 11 août 2022: **edu: th for maths: this could be used as homework answer should be a generator so that each student has a different solution (prevent cheating): generator example: a word starting with the 2nd letter of your firstname generator example: (last digit of your birthyear) x 100 + (last digit of your birthday) 14 août 2022: **ic:hardsplitter: destroy image into shards vocabulary:endoTouch (==inner touch) ***ic::control bloom: long press on icobject makes the _control bloom_ appear. Then you can pick and drag one anywhere you like. Typical usecase: icVideo: play, pause, slider,... Other usecase: icImage: endoTouch hardSplitter for gunshot animation ***searchbar portal popper: search results are portals and there is a gobacktosearchresults keyboard shortcut **(**)ic:spatialized audio **ic::eyetoy: object generation is triggered by particular webcam patterns (for example: bubbles come out of the mouth) **easy input: white is transparent: white (or detected bg color) is 'alpha:0' **TH:hidden objects: click to collect **[concept]ic: les différents niveaux de publicité (pris au sens premier du terme): plus profond, plus intime **ic::growing blob: object bounds grow like tentacles till it reaches a growth-stopping object ***p2p canvas kaleidoscope: no main server, only a myriad of client environments 15 août 2022: (keyboard + touch: even more possibilities !!! ***textConstructor + "bud object": create clickMe "bud object" which will then require config steps to fully deploy example with cart edudemo (which requires an image selection step): 1. textconstructor: "edudemo cart" --> a clickMe bud object is created 2. clicking on bud object spawns the "import images" fileExplorer, user chooses images 3. edudemo instance fully deploys ***textConstructor: spawning keyword can be registered in TextConstructor directly inside iC workflow: 1. user creates a group of objects (which we could call a miniEnv) 2. user selects the group 3. keyboardShortcut: register in textConstructor --> (say "potato") so that textconstructor: "potato" now spawns a clone of the original miniEnv remark: the miniEnv could be more structure than content (something with snapslots or paths for example) 17 août 2022: **portal paths: path goes through portal usecase: self-destructive programs: portal gets to rect containing program and erases it ***icObj.type="attractor": object attracts surrounding .isAttractable elements usecase 1: snapslot + attractor there is a question on canvas and a webcam input to answer kid spawns [[4]] with his fingers (via webcam input) ("ultra easy input") and [[4]] is slowly attracted to answer snapslot if [[4]] is the correct answer, answer snapslot will color green and [[4]] will stay in place if [[4]] is not the answer, answer snapslot will flash red and destroy [[4]] **from canvas to HUD: clicking on canvas object makes HUD element appear/disappear **contextual HUD: entering/leaving canvas area makes HUD element(s) appear/disappear *bounded spread: spread in enclosed area by smallScaling elements remark: encore une fois, l'idée, c'est de bien faire comprendre que c'est pas parce que c'est borné que c'est pas infini. Il suffit juste de "regarder plus fin". **(*)zIndex reverser: if zIndex reverser is on area, all zIndex priorities are reversed (though zIndex reverser stays on front) edu: this object may act as a revealer for grid-based riddles 25 août 2022: **easy: clone(n): instead of yielding 1 clone, user specifies how much they want 2 main flavors: - "let me see what i'm doing": clone command via keyboard, arguments are on board: user wants to create 30 clones of objectX: 1. user creates a mathNode [[30]] 2. user grabs objectX 3. user "keynitiates" clone command 4. user touches [[30]] with activated objectX 5. clones are created near [[30]] OR arguments are transformed into clone operator via keyboard: 1. user creates a mathNode [[30]] 2. user "keynitiates" transformation of [[30]] into [clone: 30] 3. user touches [clone: 30] with objectX 4. clones are created near [clone: 30] - "don't let them see what i'm doing": 1. user grabs objectX 2. user "keynitiates" clone command 3. user types in required arguments 4. clones are created near cursor **icTrail: pathmade + trail: when activated, path draws itself this could be used to create romantic writings or drawings infinishute::infinitePortrait: draw an ic of yourself, so that others can browse and discover you ***HUD portals: HUD object behaves like HUD when cursor is outside object rect but behaves like a portal when cursor is inside this allows to create always-accessible, always-near areas (if there are other HUD objects at 'same level', they may stay at this level and not be transported into the portal area) (but the contrary may also be possible) (as well as any situation between these 2 boundaries (==some follow, some stay)) ***HUD portals::browse and collect: if getting close enough of a new collectible hud portal, it automagically snaps to HUD (a 'world' may have, say, 10 such portals to collect and then complete) a completed hud portal challenge will have a different appearance on screen (no more in HUD, or greyed, or, if containing nested portals, may indicate '10%', '50%', and a progress indicator) **easy: mindmap: icText/icSegmentedLine --> icSegmentedComposite (or icTree) feature: be able to export the tree/graph structure in textual form **edu: reactor: euclidian subtractor: [-12] * [[135]] = [-12]{1} , [[123]] [-12]{1} * [[123]] = [-12]{2} , [[111]] 29 août 2022: 0 Ic-ized web : create proof of concept web navigation (For a start, spawn ichtmlElement when clicking on URL) IC storyboarding : create application storyboard in IC Example : put next screen storyboard inside button **IcBegin: Example: click on icBeginRuler begins a ruler session in which the standard tool keyboard shortcut activates the ruler (HUD indicates that the current tool is ruler) Edu: [icBeginToolX] is located in an exercise area dedicated to toolX practice **(*)Multiscale handwriting: start writing at scale:1, then, _as you continue writing_, zoom to scale:10, so that the line is thick at start and then thin, and then maybe thick again combine it with a pov animation and the text line thickness stays the same but the rest zooms in/out this is like writing in a dimensional shift **[store] operator as simple 'layouter': objects 'in' store are simply laid out (horizontally, vertically, anything). They are close-to-not coupled with the store : group select laid-out objects and then do what you want with them (any moving of stored objects kills their bind with the store) **(*)[Repeat(n)]/[end_repeat]: autopath between loop bounds 2 balises: une pour le début et une pour la fin : un chemin est automatiquement tracé entre les deux. Bouger les balises bouge le chemin avec. Toutes les structures de contrôle peuvent être faite en suivant ce principe edu : répéter un programme de calcul avec les élèves pour leur montrer que c'est la même structure qui se répète plusieurs fois (entourer d'une couleur différente chaque morceau 'racine', pour chaque itération) **iCRandomBranch: on dessine d'abord puis on assigne les poids edu: Arbre de probabilité avec trait d'épaisseur proportionnelle au poids et démonstration de tirages aléatoires sous la forme de parcours de l'arbre : on voit que le plus probable c'est le passage par les gros traits **iCConditionnalBranch : on dessine d'abord puis on assigne les conditions Mathgame.fr : créer une catégorie activités élève, et une catégorie activités prof Pour chaque activité prof : un petit texte pour expliquer les contrôles clavier, un petit texte pour le déroulement de l'activité **IC:solar system: draw path relatively to other object (moon around earth) example: 1. draw sun-centered earth trajectory around sun 2. draw earth-centered moon trajectory around earth 3. animation will allow moon around sun 'resulting trajectory' to be seen 30 août 2022: ***easy:define object properties by touching core object example: 1. user imports 5 [[image: strawberry]] (they all have the same image src) 2. user picks one [[image: strawberry]] and transforms it into an object core [[image: strawberry]] --> [[core]] 3. user creates [[3]] and makes it touch [[core]] now, [[core [[3]] ]] is a more complex object, it has the property: .value=3 the other [[image: strawberry]] instance objects are transformed into composites 4. if we select the 4 instance objects, and sum their .value property, the result will be 12 5. 2 display flavors: -instance objects don't change: they all look like a simple [[image:strawberry]] (yet they have properties) -instance objects get the same visual surroundings as [[core]] and follow [[core]] as it mutates 6. 3 editing flavors: - we may turn any instance into [[core]] as a result, the previous core becomes an instance (there can only be one core) - [[core]] never changes: keyboard shortcut + click on instance brings to [[core]] then one can edit [[core]] keyboard shortcut + click on [[core]] brings back to instance - we may turn any instance into [[core2 extends core]] (inheritance...) ***easy:object methods by touching core object it is the same as for properties, except now, we touch [[core]] with [operator] so now, polymorphism can happen: say we have [[strawberry [[3]] [x 2] ]] then [[strawberry]] * [strawberry] = [[6]] [operator] can be anything: for example, a pathmade operator (this may get tricky) **edu: cart path: cart items have [+ ] method to get cart total price, you make [[0]] follow a path along the items **[[hitbox_extension]]: a property which is not really a property in order to add properties to [[core]], it is nice to extend [[core]]'s hitbox, and [[hitbox_extension]] does exactly that then any object touching [[hitbox_extension]] will be added as a new property Considering all instances as 'references' of the same object, then the object can be mutated at different places using pathmade procedures (atomic) pathmade procedure: a pathmade which ends on a property-to-be: the conveyed object will be conveyed to this new property (because it will land on it) edu: but this is not pretty functional programming, and should be considered only anecdotically **layout: 'cart arrange': create lines/columns of identical objects edu: comme ça c'est plus facile à calculer **layout: inline cart: create 1 line consisting of different segments of identical objects so that the cart path is straightforward **(*)icEye (==screenRectImageListener): this object reads image input of given screen rect and reacts to particular image input output may then be redirected via a path to outputArea, to become the input of something else edu: qrCodeScreenRectImageListener over webcamStream = webcam qrcode reader edu: blueColorScreenRectImageListener: output [[1]] if blue color is detected inside, [[0]] if it is another color. (Don't output anything if there is no object inside rect) edu: le développement autour de la webcam est facilité car on peut d'abord passer par une étape où l'on glisse des images dans la zone du listener 31 août 2022: edu: challenges simples: _puzzles en mosaïque_ basés sur la symétrie juste à prendre des icRect colorés et les replacer au bon endroit 01 septembre 2022: operator bullet: [x 3] * [[2]] = [[6]], and [x 3] is consumed 03 septembre 2022: *GET100 game: pretty physical cards' cardbacks by spreading tentacles from qrcode ? will this hinder qrcode recognition ? *(*)GET100 game: bg gradient following gameState: 0 is blue and 100 is red example: if the gameState is current 45 and target 100: bg gradient will be yellow --> red 04 septembre 2022: *GET100 game: card front could show a visual representation of the operator example: ___________ | | | ° --> °° | | | | [x 2] | |___________| 08 septembre 2022: *colorPicker palette-painting: 1. import image of painter's color palette 2. use colorPicker to pick colors from palette (as if it were a true palette) 09 septembre 2022: *[ on coreify: when core is designated: no alike object has yet been informed to the system, and the system finds alike objects (there is a filter for likeliness) => "legitimate" alike OR alike objects have been previously "forced-informed" to the system: they may not be particularly similar to core => forced alike createIcGhost object and put it next to core ghost is a composite touching core with property object adds it to ghost once property object has been added to ghost, it can freely untouch core ghost can be moved away from its related core ghostLink: core.ghost -----> alike0.ghost (echo) -----> alike1.ghost (echo) echo allows overriding inheritance: "alike0 extends core" destroying core.ghost destroys all the forwarding from core to alike we can imagine a geminiLink between all objects ("everyone is core") core.ghost (gemini) <-----> alike0.ghost (gemini) <-----> alike1.ghost (gemini) (? if empty core is coreified again, then its previous ghost should be destroyed coreify(empty core) = uncoreify(empty core) == original, "simple" object supereasy look and feel: all icGhost should stay hidden core should be hightlighted: stroke, strokeWidth... if property object untouches core, then it is removed from ghost easy look and feel: core ghost is shown, alike ghosts are hidden if property object touches core, then it can move away from core (it is now a ghost property) if ghost property object touches ghost(==composite handle), then it is removed from ghost ]* **(*)"pathmadeFunction1.output --> pathmadeFunction2.input" link can be created by using ghostlinked duo pathmadeFunction1.output touches ghostLinkedObj1 ghostLinkedObj1 ghostlinks to ghostLinkedObj2 ghostLinkedObj2 touches pathmadeFunction2.input when the object which is following the paths untouches ghostLinkedObj2, it automatically removes from ghostLinkedObj1 and ghostLinkedObj2 the ghostlinked duo is a serving hatch, a tunnel **(*)ghostLineage: coreify(ghostlinked) to achieve proper inheritance, one may coreify an already ghostlinked object: 1. select forced-alike 2. coreify(ghostlinked): ghostlinked which had ghost1 is now core2 with ghost2 (and it keeps having ghost1) 3. select ghost1 and touch core2 with it: ghost1 is now a property of ghost2 forced-alike ghosts now have ghost1 and all its contents as props 10 septembre 2022: edu: easy: build answer: record answer (GM) and when student clicks on icRecord, it plays answer record 12 septembre 2022: (dump: IC::qrcode user input/qrcode recomposition: icEye: this slot awaits for the right camera input (qrcode for example) or simply awaits for user to tap to capture current camera frame ("to-be-filled slot") (example: rally checkpoint validation frame (player must take photo at spot X carrying object Y)) IC:: angle et force (location aware touchoperators) IC::angles et longueurs (le zéro du rapporteur change, le zéro de la longueur change) : connect dots IC::will(_touch)/did(_untouch) modifiers Create pattern using probabilities 100X + Y donne un peigne ***Dynamic bloom : bloom X probas : dynamic segments and colors Exp et log: [exp] [log] [sin] [cos] [tan] edu: l'utilisation du tree scroll est pratiquement incontournable (to easily edit expression) **IC::gm::hidden value interaction: show that change happened but don't show object différents points d'interrogation pour montrer qu'il y a eu interaction mais ne pas montrer le résultat **easy: ondrop addition: [[2]] *d [[3]] = [[5]] (**easy: icMode this object is an immortal singleton (like Supervessel) available modes: "easy", "std", "supereasy" change mode by clicking on it (**easy: swap to easy mode: icTextConstructor("mode: easy") (so you don't have to know where icMode is) (**easy: background color changes with mode: easy: blue std: green supereasy: pink remark: ça sent le menu tout ça, en plus un menu complêtement éclaté et dispersé... autrement dit: si icMode n'est n'est jamais implémenté, c'est peut-être pas si mal. **easy: (x;y) tuple: using "on touch set property" engine [[(x;y)]] is a composite and [[x]] and [[y]] are cores if you want to associate value [[7]] to [[x]], you simply touch [[x]] with [[7]] [[7]] *_core_touch([[x]]) [[(x;y)]] = [[(x:7 ; y)]] **machine: cartesian coordinate plane with [[(x;y)]] input [[(x:7 ; y:3)]] * [[machine: cc plane]] = point (7;3) is added to plane (and [[(x:7 ; y:3)]] may be consumed) ***edu: function plot pathmade manufactory: a manufactory is a pathmade interlocking of functions and machines 0. user creates a collection of value_x loop(value_x) { 1. put [[value_x]] as input of pathmade function f and get [[value_output]] 1.5 [[value_x]] is retrieved using a bypass path around function f ((pathmade function: identity)) ((==a simple wire)) 2. create [[(x:value_x;y:value_output)]] 3. put it in cartesian coordinate plane machine to plot point } edu: l'idée est de montrer toutes les étapes, et de montrer la construction du graphe de la fonction au fur et à mesure 15 septembre 2022: ** gm:challenge (with exploration part): find function general formula 1. system spawns blackbox function (each time with a different color and a different name (f,g,h,...)) [f (orange)] ([x -> 3x + 4]) 2. there are many values available to try on function: [[0]], [[1]], [[2]], ..., [[10]], ... [[0]] * [f (orange)] = [[4]] 3. gm is [[x]], and there are platform operators to create litexp to try on target touchslot *one could create unremovable properties with coreConfig.canUntouchFunc (what would they be used for ?) **(*)gm:spaghetti challenge: user can only draw 1 path to bring [[initial]] to [[target]] value, operators are scattered here and there this is the same idea as line 5041 "challenge: show me a path", but this time with loops as the primary concern pattern art with sequences of color patterns would be a nice variant of this challenge edu: of course, user can draw loops and go back again to using left screen side operators edu: the interaction is so simple that it would be attractive edu: there is also a nice side effect with pathdrawing: if player stalls the path while pathdrawing, to think about what to do next, the attempt will take more time when finally triggered so they may better prepare the path mentally before drawing it => prérequis impératif: corriger les problèmes de double touch qui soulent => prérequis impératif: la GM (ou au moins sa contact_area) devra toujours garder la même taille 16 septembre 2022: **edu: use growing icEngined to have a talk with students around speed and length **edu: use rivetedSegment and HUDSegment to have a talk with students around fractions for example: show 1/3 1/3 1/3 with HUD Segment and show different lengths with rivetedSegment 17 septembre 2022: **edu: gemini/echo (and computed/composition) can be used to create "reactive" eduDemos eduDemo: x=, f(x)=f()=...: we use an echo of [[x]] in f([[x]]) so that, when updating [[x]], f([[x]]) updates automatically eduDemo: show [[x]] and create a big spread collection of reactive computed([[x]]): 2 * [[x]], 20% * [[x]], [[x]]^2, 10 * [[x]], ... edu: pour donner "la sensation du nombre" 18 septembre 2022: **(*)GM(composite): GM is a composite and target is a composite [structure] GM(composite)::challenge: sequence of transformations: we create [[ [[x]] [[f(x)]] [[g(f(x))]] ...]] edu: cette idée est bonne car elle montre les différentes étapes de transformation example: GM(composite)::challenge: "factor quest": target is a sequence of values, many [x ...] and [/ ...] operators are available examples: [[target]] = [[ [[1]] [[2]] [[6]] [[36]] [[12]] ]] [[target]] = [[ [[1]] [[10]] [[100]] [[25]] [[5]] ]] edu: the idea is to have a mental factor decomposition of basic numbers [structure] GM(composite)::challenge: append elements example: GM(composite)::challenge: sequence of colored rects: target is [[ [[blue]] [[blue]] [[red]] [[blue]] [[blue]] [[red]] ]] => this could be upgraded to challenge: draw path: sequence of colored rects GM(composite)::challenge: "ascending order": gm is a store reactor and target is to have all values sorted in ascending order **GET100::variant: Volley: team1 area is [0, 50[, team2 area is ]50, 100], 50 is net, the rest is out of bounds (Service may be random the goal is to send the ball back to the other side, using the operator cards we may have 3 touches on each side, or else it will be too difficult to send the ball back Smashing player may use special [protect] operator, that will force the other side to use 1 touch to [unprotect] **(*)[loop]: a path-targetting operator: [loop_begin(3)] [loop_end] comme sur une partition de musique cet opérateur _crée un chemin qui boucle_, par dessus le chemin hôte qu'il shunte le chemin créé prend la priorité qu'il redonne une fois que la boucle est terminée *edudemo/challenge: place object near its correct length (ruler or arrow): use zScroll to scale object 1. 1 instance of each object: to work on orders of magnitude 2. multiple instances of each object: to work on fractions 3. composition of objects: arrow.length = object1.length + object2.length: to work on sums of decimal numbers 21 septembre 2022: **easy: use mouse to define gemini/echo example: 0. press key to begin definition session 1. click on icText1: gemini source 2. click on icText2: echo DONE! **easy: icComputed: "= this (clicked) + that (clicked)" (visiCalc sans le tableau) Computed is composite(icText__formula, icMathNode__result) clicked objects in formula may be icMathNode or icComputed edu: pour introduire les formules de tableur **easy: assign value to symbol [[x]] by putting [[4]] over it [[x]] should now be considered [[4]] edu: [[x]] should now be slightly dimmed: opacity: 0.5, or grayed so that we see that [[4]] is the value to consider **edu: reified spawned objects: to spawn a [[perimeter]], you have to select the target polygon then what happens, is that polygon side lengths objects are created and [[perimeter]] is simply a computed of the objects that are already on canvas (sum of side lengths) so that destroying a side length object should either: not be possible before removing [[perimeter]] object OR destroy [[perimeter]] object as a side effect edu: comme ça on voit d'où ça sort, on montre à chaque fois comment on a fait et ce dont on a besoin pour le fabriquer **icGeminiLink: between obj1 and obj2, and carrying the gemini engine visually: we can show the link between the 2 objects gemini: 2-sided arrow echo: 1-sided arrow destroying the geminiLink destroys the gemini behavior 22 septembre 2022: *edudemo: function evaluation: top: [[1]] [[2]] [[3]] [[4]] ... [ ] middle: / "forwarder" / bottom: [ ] f([[x(core)]]) = [[]] gm:challenges: relative numbers 0 target: [[ +3 ]], gm rewrite: [[ [[+1]] ]] * [+ 1] = [[ [[+1]] + [[+1]] ]] 0 target: [[ +3 ]], gm rewrite: [[+1]] * [+ 1] = [[ (+1) + (+1) ]] 0 target: [[ [[+1]] + [[+1]] + [[-1]] ]] 0 simple additions: [+1] [+ (-1)] edu: use color__positive, color__negative (for example: red and white) ** 0 use non-consuming platform operators like: [+ [[-1]] [[-1]] [[-1]] ] 0 operator mix: [+2] [+3] [-2] [-3] 0 transform initial with [+ 0] operators, target is [[?]] initial: [[ [[+ 30]] + [[- 14]] ]] [[ [[+ 30]] + [[- 14]] ]] * [+ (-1) - (-1)] = [[ [[+ 29]] + [[- 13]] ]] 0 faraway additions: target: [[97]], operators: [+4] [+6] [+3] [-1] and inverse 0 relative: htu 0 relative: dec 0 use [[opposite of 6]] instead of [[-6]] ** 0 target is [[opposite(initial)]] challenge::key challenge: player must manipulate the objects to make a "key" appear ("key" is likely to be a mathNode, to validate at [[target]]) edu: typical example: manipulate a pool of [[+1]] and [[-1]] until only result remains 23 septembre 2022: edu: grayed operator (==no effect operator) only to show effective inverse operator grayed([+ 1]) has effective inverse operator [- 1] grayed([+ (-1)]) has effective inverse operator [- (-1)] 25 septembre 2022: *(*)touchSlot.isEnabled --> locked icObj.state[touchSlot0] = .Touched 0. touchSlot0.isEnabled == true and icObj.state[touchSlot0] == .Untouched 1. icObj * [touchSlot0] --> icObj.state[touchSlot0] == .Touched 2. touchSlot0.isEnabled = false --> icObj.state[touchSlot0] == .Touched (locked) this lock mechanism may have a nice purpose => forced sequence of operator use tutorial "learning" step **edu: relative numbers: [smart additive split] we have to do [[+3]] + [[-8]] [[-8]] * [smart additive split] = { [[-3]] ; [[-5]] } [[+3]] + { [[-3]] ; [[-5]] } = [[-5]] [random additive split]: [[-8]] * [random additive split] = { [[+5]] ; [[-13]] } 27 septembre 2022: ***GET100: physical board game: gameboard is a [0;100] or [-100;100] number cell line initial: there is a pawn at 0 when player plays card, they move the pawn to the result number cell when pawn reaches 100, team wins the pawn and a new pawn is put on 100: now target is 0 (number cells may have a circle decomp area) edu: [-100;100] is obviously the most interesting gameboard each operator has a corresponding color: +: orange -: blue x: yellow /: violet edu: players may have a calculator next to them to check result edu: players may use a ruler when multiplying: 1. measure distance from zero 2. move away from zero by repeating it n times variants: [protect()] operator: next card should be of the specified color to remove protection example: [protect(blue)] should be followed by [- ...] a protected pawn should be put aside (so that we understand it's protected) combo card: effect + protection: example: [+ 1, protect:violet] [assign()] operator: [assign(27)] --> value current becomes 27 edu: pour la notion de variable en algorithmique ***GM:challenge: from point A to zone B (using (at most/exactly) n operators): example: 1D: initial: [[value: -7]] target: [[interval: [10;15[ ]] edu: faire comprendre "le passage du 0" example: 2D: initial: [[point: (-7;-3)]] target: [[rect: (TL:(5;5), BR:(10;1)) ]] **iC:copy handle (FR: poignée de recopie): same behavior as in a calc sheet formulas should be shifted, etc. **(*)edu: gang dots(like _Exploding dots_, but clearer): putting dots close to each other automagically creates a gang putting gangs close to each other automagically creates a supergang, etc. edu: zooming in lets you see inner content so the 10 times 10 times ... is more obvious 29 septembre 2022: ***(*)get100::VOLLEY: [-100 ; 100] and 0 is the net max 3 touches, player cannot touch ball twice in a row Team1 is in [-100 ; 0[ say the ball arrives at [[-88]] typical turn is 1. reception: bring the ball close to zero, but stay on team's half-plane [[-88]] * [/ 11] = [[-8]] 2. pass: get over 0 [[-8]] * [+ 13] = [[+5]] 3. smash: get as far a possible, but do not go out of other team's bounds [[+5]] * [x 9] = [[+45]] it is also possible to go out of one's bounds for convenience 1. reception: [[-88]] * [- 20] = [[-108]] 2. pass: [[-108]] * [- 2] = [[-110]] 3. smash: get as far a possible, but do not go out of other team's bounds [[-110]] * [+ 180] = [[+70]] OR [[-110]] * [x (-0.5)] = [[+55]] receiving team sees _incoming ball as numexp_ and must decide if they receive or if they let the ball touch the floor for example [[((-55 / 11) + 20) * 8]] may be off-bounds numexp may be shuffled for more challenge: [[8 * ((-55 / 11) + 20)]] receiving team may only have <10> seconds to determine if they take it or not then numexp is evaluated if receiving team has decided to receive an off-bounds ball, team must take care of it if receiving team has refused to receive an off-bounds ball, receiving team wins the point if receiving team has refused to receive an in-bounds ball, other team wins the point each team has a draw pile, a discard pile if team2 not able to bring the ball back to the other side, team1 scores 1 point each player in team2 can then choose to discard one card in their hand and draw another service: 3 flavors: - initial value is (side ]0; 100]: [[-50]],side [-100; 0[: [[+50]]) and player doing the service plays an action card - there is a service value on each card - there is a service value on some cards. If player can't serve, the point is given to the other team. - there is a service operator on each card - there is a service operator on some cards. If player can't serve, the point is given to the other team. side ]0; 100]: service operator could be [- 157], [/ (-2)], [x (-0.33333...)], [+ (-130)], ... => maybe service operator is just standard card operator this would induce more "back play" (== ball going out of bounds on team's side only for convenience) 0 rules: cards in hand, cards of each type... 0 2V2 0 3V3 0? 1V1 division: if result is not a whole number: 2 flavors: - that's ok and continue with fractions - action is invalid and nothing happens but action count is still incremented show colored division marker segment for each card divisor 0 play against computer 0 show volleyball pitch, players and animations when playing cards 0 madness: game hosting phone moves along [-100;100] physical game board using a wheeled robot module TODO: 0 fine tune a standard card set for each team 3 flavors: - one common draw pile for the team - each action has their own draw pile: reception (side ]0; 100]): [/ 2] [/ 3] ... [- 30] [- 40] [- 50] ... [x 30%] pass (side ]0; 100]): [-5] [-10] [-15] ... [x (-1)] [/ (-2)] ... [- 120%] smash (side ]0; 100]): [x 2] [x 3] [x 10] ... [- 15] [- 25] [- 30] ... [x 300%] [[0]] is counted as not crossing the net advanced: [+ 1+] [+ 1-]: if ball is on [- 1] then [[-1]] * [+ 1+] = [[0+]] is now on ]0;100] side if ball is on [- 1] then [[-1]] * [+ 1-] = [[0-]] keeps being on [-100;0[ side rotate: 1 player in pass slot, 2 players in reception slots: player in pass slot cannot perform reception injury: all actions are 50% less effective charge shot: shot is 100% more effective consumes 2 actions cannot be used when receiving perfect pass: consumes 0 actions next move can only be: smash charge smash nothing (other team's reception) running: consumes 1 action next shot _performed by running teammate and only this turn_ is 100% more effective random smash: smash result = original smash result + rand_in([-5;+5]) to_nearest_prime smash: smash result = nearest_prime(original smash result) blocking counter: before smash, receiving team may put a card face down (scan card front qrcode) if smash result is in blocking counter interval, then counter smash is blocked then again, many flavors for follow up 30 septembre 2022: **volley100: action pile symbol only on card back 03 octobre 2022: **volley100: advanced: literals [+ x] [× x] [x <- 3] rule: last team hit must end with a numerical value (all symbols must have been evaluated before next team plays) or else playing team loses current point *** [poll] (==noActionify next action) [poll] then [/ 7] helps receiver check if [/ 7] is valid [poll] then [x 5] helps smasher see if smash is block-countered with the result of [x 5] this operator could be extended for any iC use. It's the "what-if" operator. One polls consequences. 05 octobre 2022: *easy: challenge creation: specify target template using instances and computer extrapolates automagically example: "target could be for example 3x²+4 or 3x+4 or x²+6x ... , __you get it ?__" **edu: litexp: color gradient animation for x and above x: blue color gradient animation x²: orange color gradient animation x^3: purple color gradient animation edu: animation is there to show that it is a variable, that the value is not known yet edu: next step in learning process is to slowly get rid of the colors gm::challenge: litexp: build [[3x²+4]] (and other x² litexps) using [+ x] [× x] [× 3] [+ 4] edu: this challenge is rich, it proposes many different situations and strategies **(*)[structure]gm::challenge: user-triggered simplification step via simplification operator examples: [distribute] gm::challenge: distribute: initial: [[3x+4]], target: [[30x+40]], via [x 10] and [develop] operator [[3x+4]] * [× 10] = [[10 × (3x+4)]] [[10 × (3x+4)]] * [develop] = [[30x+40]] [reduce] gm::challenge: reduce: initial: [[3x+4]], target: [[5x+2]], via [+ 2x] [- 2] and [reduce] operator [[(3x+4) + 2x - 2]] * [reduce] = [[5x+2]] gm::challenge: reduce: initial: [[3x+4]], target: [[5x+2]], via [+ (2x-2)] and [reduce] operator **(*)edu: "troup algebra": [× x] as level up operator, [+ x] as add level 1 troup, [+ 1] as add level 0 troup each level may have a color: level 0: gray level 1: blue level 2: orange level 3: purple there is a column for every level sort columns in level descending order edu: comme pour les relatifs avec les cailloux blancs et noirs, juste avant de faire, le calcul littéral **icPreciseSlider: slider knob can be zScrolled for extra precision when sliding it, then it autoScrolls back to its "slider aesthetic" size *edu: number line: bound slider: |-------------------------|-------X-----------------| value: [[26]] unbound slider: |-------------------------|-------------------------| for students to try and place value **edu: slider resize VS slider extend (extend shortcut: shift + resize): what happens if slider resizes horizontally ? work with rulers and slider clones **icSlider.smartExtend: when going out of bounds, slider extends accordingly 08 octobre 2022: **eduDemo/challenge: TargetM100100 ((road to volley100)) ui: 1. slider on top with: [[initial]] marker [[previous]] marker [[target zone]] zone (?an arrow going from [[previous]] to [[initial]] with operation written on it 2. [[previous]] * [op_previous operand_previous] = [[initial]] (smaller than 3.) 3. [[initial]] * [op_current ] = initial, previous and target slide in a 3-color window if operand_input is valid { previous = initial ; initial = result; op_current = random(+,-,x,/) ; } if operand_input is invalid {show operation result, it is out of target zone} alternate display: instead of displaying [[A]] * [x ] = we could display [[A]] * [x ] ∈ [value_min__zone ; value_max__zone] for students to get used to "∈" we could also use a _finite set_ for target zone 09 octobre 2022: **icTextConstructor X webSearch: [textConstructor: q(, )] examples: [textConstructor: q(image, banana)] [textConstructor: q(synonym, hope)] web search engine is set in iC params 12 octobre 2022: edu: comme on voir avec le slider, le plus important n'est pas le résultat mais l'outil il faudrait concevoir des challenges dans lequels les outils sont sur le devant de la scène 0 un challenge avec un rapporteur en plein milieu 0 un challenge avec un compas plein milieu 0 un challenge avec un repère en plein milieu 0 un challenge avec un énoncé en plein milieu, c'est écrit en gros et ça évolue en fonction des soulignages, des barrés, des entourés, des encadrés, etc. 0 un challenge avec un stylo en plein milieu (durée de vie) edu: slider::arc_of_circle **icMultiSlider: a slider with a dynamic number of knobs: creating a knob is like creating a variable edu: time based progress-indicator trigger on machines: when placing input on machine, machine does not start instantly machine starts after input has kept still for the duration of the progress-indicator trigger edu: with such machines, we can create eduDemos in which time is left for student to perform computation, before moving to next step **icPoint (==without homeScale) (==exact) / icSpotPoint (==with a homeScale) (==precise only up to a certain scale) geometry / presentation both icPoint and icSpotPoint are metaObjects: there can be crosses, circles, squares, ... 14 octobre 2022: ***game: PriOpera: rebuild target exp (numexp or litexp) using 10 operator cards always the same 10 cards [[target]] is : [[initial]] *+ {cards} 2 flavors: - player's [[initial]] is chosen by game - player has to choose the correct [[initial]] (there are also [[initial]] cards) this game can be built around qrcode physical cards or around pure virtual display a click-only interface would be : [ [[]] [[]] [[]] [[]] ] initials [ exp__current ] [ [ ] [ ] [ ] [ ] ] operators [ [ ] [ ] [ ] [ ] ] [ [ ] [ ] [ ] [ ] ] [ exp__target ] to create more complex expressions, there could be "breakers": [ ... + ... ] [ ... - ... ] [ ... × ... ] [ ... ÷ ... ] which create 2 expression slots **(*)game: EqNinja: like FruitNinja, but here you turn = into ≠ = should only be slashed when necessary game tempo accelerates with player's success 15 octobre 2022: (*)(*)(*)from thing to concept: 1. user drags a "concrete" icMathNode and drops it on an icSlider.knob 2. icSlider.knob configures with icMathNode's .mathNode "formal" object icMathNode is the default reification of mathNode to be more precise, reification-dedicated icMathNode could be named icReiMathNode in deeds: icReiMathNode.mathNode = geminiSource(mathNode) icSlider.knob.mathNode = icReiMathNode.mathNode.echo() icReiMathNode's "interactive setValue" should not overwrite geminiSource(mathNode) with a new math.ConstantNode icReiMathNode's "interactive setValue" should keep existing geminiSource(mathNode) and mutate its insides **game: TargetM100100::cards version: player has 6 cards in hand and must choose correct card(/card sequence) ui: 1. slider on top with: [[initial]] marker with number label [[target zone]] zone with number labels for [min, max] 2. GM::[[initial]] icMathNode 3. GM::operators (player's hand) 4. button: [declare impossible] 5. timer (top-right) 6. label: score (top-right) rules: si on réussit à atteindre la zone cible: a fresh randomly picked operator replaces the operator that has been used si on pense qu'on ne peut pas jouer en 1 coup: 2 flavors: - soit on déclare que c'est impossible en 1 coup et si c'est vrai, le système donne un point et une nouvelle main si c'est faux, le système enlève un point et laisse la main inchangée - si le système détecte que c'est possible en maximum coups: on doit trouver une séquence d'opérations correcte, sinon il donne automatiquement une nouvelle main variants: [[target zone]] is now [[target set]] (could be [-5;1] U [10;30] U {51} U {90}) there is a [[poller]] icMathNode input which only accepts constant values, to check where [[poller]] is placed on the number line edu: to help player while they ponder **gm::challenge: TargetM100100 [[initial]] * [op] = [[numexp1]] ... [[numexp]] * [targetTouchSlot] **mixedScale objects: objects which cannot get too big if ic.scale < obj.homeScale: object behaves like any object --> object is small and can get smaller if ic.scale > obj.homeScale: object behaves like a scaleless object --> object has maximum size and cannot get bigger typical usecases: segment number labels any label that describes something inside an object 09 novembre 2022: ***game: Thunderstruck context: points and lines mechanic: every seconds 1. a transformation of player's current position (later marked by a cross) OR a particular location on the field (intersection of (AB) and (CD)) is given 2. player has seconds to get to target position 3. when time is out, only a small area around target position is safe, the rest is thunderstruck if player is thunderstruck, they lose HP player has to survive has long as possible ui: keyboard or controller ((or mouse)) ux: it has to be fast paced and fun 10 novembre 2022: **(*)TargetM100100:variant: From A to B (via C(<->1)) when students start to get how to go from A to zone Z, gradually reduce zone Z length and then it's time to get from A to B (zone has length:0) to show that B = A x B/A, point C, with x position == 1, could be used A / A = C C * B = B **show sum dynamically, on selection: when selecting an area containing objects, dynamically show sum on the side objects may be fruits, numbers, symbols... ***core replace(==replace all): 1. activate core replace 2. [[x]] *cr [[strawberry]] = [[x]] (all strawberries are now [[x]]) **eduDemo: spread: [[x]] is segment, [[x²]] is square, [[x^3]] is cube **eduDemo: factorize: factoriser, c'est équipartitionner un groupe hétérogène 0 [factorize active selection] **eduDemo: move and rotate axes: context: 2 axes: (Ox) and (Oy) 5 labeled points, with their coordinates written below: A(+2,+1), B(1;10), ... the coordinates of a point are updated when the point is dragged if the axes are moved or rotated, the coordinates of the points are updated there could even be blue coordinates and red coordinates, with different axes, (O x y) and (O x' y') ('zone' is a sub-object in the 'segment' environment 'segment' is a particular object-construction context all objects created in this environment are related to the root 'segment' object it is a 'planetary' dependency zone has no meaning without underlying segment 11 novembre 2022: **game:Right and Down: Numbers Edition: 6x6 grid with start at top left and end at bottom right grid is filled with operators such as [+ 5] or [× (-1)] player controls [[]] initially at top left target condition is at bottom right examples: [> 0] [< 0] [> 20] [< -20] [[]] keeps its value from level to level edu: every step involves calculation. So the student may retain some of them (for example: [[7]] * [+ 4] = [[11]]) variants: [fill red] to change the color of [[]], as target has also a color condition [> 0, red] locks and keys as in the original game ... icSegment::[divide in ] (==[equipart ]) [divide in ] --> modal to input [divide more], [divide less] --> no modal :) blink/fade divisions when transforming: (1/4, 1/4, 1/4, 1/4) **(*)pathdrawing + keyboard arrows = squarePathDrawing challenge: use squarePathmade operators to get through a maze (the same operator may be used multiple times) 17 novembre 2022: **volley100: ball display is mathNode TargetM100100: numpad popover 21 novembre 2022: **(*)game: Cards of Ops (2 player game) rules: each player must play a card so that [[current]] * [c] > [[current]] operator cards: [■ (-10)] ... [■ (+10)], with ■ in {+,-,×,/} ([/ 0] is not in game) ==> 43 cards setup: deal all cards: 22 cards for P1, 21 cards for P2 when starting a new round, starting value is [[0]] scoring: 2 flavors: - sudden death (à la CardsOfSpirits): game only has 1 round - many rounds: player with most points wins ((C'est l'adjectif qui fait le nom. Avec l'adjectif numéral "un" ([1 x]), je peux créer le nom "1" ([[1]]), en disant simplement "un un" ("[1 x] [1 x]" devient "[1 x] [[1]]"). Ca y est, on a invoqué [[1]]. 22 novembre 2022: **0 drag'n'drop equations (depuis le temps que quelqu'un aurait dû le faire...) 24 novembre 2022: ***gm::litexp: rajouter une [safetyZone] et un [platform +] (safetyZone également) pour que les élèves puissent fabriquer chaque terme séparément it brings a whole new field of possible challenges which is _way more complex_ (**when objects will be able to manage other objects, _in any form_, be it proxies or wrappers, then things will evolve. (*(hack)if GM, while in safetyZone, has its curse disabled, then using a teleport inside safetyZone would allow GM to roam free, uncursed **game: multiplayer factory: each player has its own factory room, with its own machines and wells and stuff. There are pipes connecting the different factory rooms Each player has a narrow vision: they only see their room Players can communicate by voice and using game's inner communication system There is an input pipe and an output pipe Every 2 minutes: there is a new challenge, and players must cooperate to provide the correct output A player may have a room full of operators, which they should bring to the others players A player may have a room full of numbers, symbols, etc. 25 novembre 2022: **conductive operator:bag: put objects on its platform, click and hold the operator (bag) symbol: you are now holding all the objects that where put in the bag edu: pour faire des challenges sur l'aléatoire * icObj.hp / icObj.shield refactor greenMouse curse behavior using gm.hp: at start: gm.hp == 1 gm drops on non safety floor: - 1 hp when gm.hp == 0: gm.im_dying_now => there is a singleton to manage all death certificates: DeathSecretary when gm dies: DeathSecretary creates a death certificate, which may contain a death curse clause when DeathSecretary reads the death certificate: it resolves all contained death curse clauses **challenge:gm:priop: layout: top row: expression rewriting operators: [( )] [﴾ ﴿] [♺] [⧢] add_paren remove_paren circular_permutation shuffle mid row: [[initial]] [[target]] bottom row: [+ 2] [+ 5] [× 2] [× 3] "rightmost-only operators" in this challenge, only rightmost part of expression is operated on: [3x + _2_] * [× 3] = [3x + _2 × 3_] edu: understand the priority of operations **challenge:gm:"full atelier" layout: [[1]] [[target]] [platform +] [platform -] [platform x] [platform /] easy: [[initial]] == [[1]] normal: [[initial]] == [[100]] hard: [[initial]] == [[math.pi]] and target is [[a × math.pi + b]] *holding a composite: all composite must be .isHeld when holding a non-mobile part of it **(*)translation gm-based controller: gmified composite handle can serve as a controller when releasing handle, handle goes back to origin but controlled object keeps its position by repeating handle hold-then-release movements (each of them being equivalent to a translation), we can control an object's position edu: show "vector history" with opacity 0.33 challenges: get out of a maze tr1. constrain handle to move only along x-axis and y-axis tr2. constrain handle to move only inside a shaped-box (it may be a cross, a heart, etc.) **rotation challenges: a few(3 |~x~|~x~|--5--| challenge: "Singapore" vibrating segments: show that x + 5 + x = 2x + 5: initial |~x~|--5--|~x~| target: |~x~|~x~|--5--| *game: num pong: ball is mathNode there are operators spread on the court ball will touch any operator on its trajectory player has to use L/R buttons to change racket sign: negative ball will only bounce on negative racket the more time passes, the more operators spawn on the court 04 décembre 2022: game: reorder: challenge ver1 (simple): layout mid row: [[a]] + [[b]] × [[c]] - [[d]] != [[target]] ^ ^ ^ ^ unmovable operators != then == symbol (when target reached) gameplay: reorder objects to reach target challenge ver2 (more complex): layout: top row: w[[x]]w w[[3x]]w w[[2]]w w[[10]]w (object wells) mid row: [+] [×] [-] != [[target]] movable operators (switch pairs via dnd) gameplay: fill holes and reorder operators to reach target *size-related appearance for operators: [+ 100] is big, [+ 10] is small, [+1] is very small edu: relier la numérique de position avec l'analogique de taille **gm:challenge: make it zero: target is always [[0]], many different operators are available expression may not be not simplified after operator touch examples: initial: [[(x+3)(x-4)]] ops: [- x] [× 4] [+ 3] [x ← (-3)] target: [[0]] initial: [[2(x+2) - 10]] ops: [- x] [× 4] [+ 3] [x ← 3 ] target: [[0]] edu: l'idée principale est de créer des _accélérateurs de compréhension_, pour les mettre dans le bain, les plonger dans un nouvel environnement commencer à faire germer les idées, commencer à les habituer à certaines mécaniques/fonctionnements **game: the layout game: target is a collection arranged in a particular way (==with a particular layout) loop: (1.) add object to collection (2.) reorder objects (3.) use appropriate layout many layouts may be nested edu: pour amener aux structures en arbre 05 décembre 2022: **[structure]gm:challenge: 2+ inputs and platform operators: transition from unary operators to binary operators edu: user has now to use platform (==binary) operators, alongside classic unary operators, to reach targets example: i:[[x]] [[2]] [[y]] ops: [+10] [- 4] [x 3] [x 4] [platform +] target: [[3x+4y-6]] **[structure]gm:challenge: 2+ "single-use" inputs and 2+ targets: find the correct input to transform for each output one input should be able to reach 2 targets, whereas the other should only have one reachable target there is a button to reset challenge back to its immaculate form (as always player should be able to make mistakes and correct them, without any retribution) example: inputs: [[x+3]] [[x+2]] ops: [- 3] [x 2] [- 4] targets: [[x]] [[2x]] **game: factory exprs: same as _Factory balls_ but with math exprs edu: the goal is to enact priority of operations edu: after priop has been acquired, other challenges, with "special" operators, involving more logical reasoning, may be served special operators: masks: only operate on unprotected part of expr [[3x + 2]] * [mask_left(toggle)] = [[|3x| + 2]] [[|3x| + 2]] * [/ 3] = [[|3x| + 2/3]] [[|3x| + 2/3]] * [mask_left(toggle)] = [[3x + 2/3]] mask_top, mask_bottom (for fractions) mask_center, mask_center_big colors grow: t becomes t+1, x becomes x+1, y+1 becomes y+2,... [[3t² - t + 4]] * [grow] = [[3(t+1)² - (t+1) + 4]] letter specific operator: [[t+4x+1]] * [x: x -> 2x] = [[t+8x]] all letters operator: [[t+4x+1]] * [*: * -> 2*] = [[2t+8x+1]] conditional number operators: [[3t - 4 ]] * [>0: n -> 2n] = [[6t - 8 ]] [[3t + (-4)]] * [>0: n -> 2n] = [[6t + (-4)]] is_pair, is_odd, is_prime, ... **gm:challenge: symbolic constants: math.pi, sqrt(2), f(-1), ... edu: manipulate those symbols as if it were [[x]] or [[y]] **gm:challenge: sqrt(2): [[sqrt(2)]] * [x sqrt(2)] = [[2]] [[2]] * [/ sqrt(2)] = [[sqrt(2)]] **gm:challenge: math.pi: [[math.pi]] * [cos(...)] = -1 [[math.pi / 2]] * [sin(...)] = 1 **gm:challenge: iterative f: f(f(1)), f(f(f(-2))) "simple": i: [[1]] [[2]] [[10]] ops: [f(...)] target:[[]] "complex": i: [[1]] ops: [f(...)] [+ 2] [- 5] [x 4] [/ 7] target:[[]] **challenge: egg hunt: find objects in space and put them on platform to match target platform this requires the execution of a complex move with the mouse: z-scroll while holding the object edu: no way back should be precised so that players are driven to put marks in space and create their way back (Petit Poucet) 06 décembre 2022: game: quality check: if an operator doesn't work as expected, put it away and take a new one. edu: 1er objectif pédagogique: avec l'informatique: attention aux apparences, et attention aux bugs edu: 2eme objectif pédagogique: anticiper l'action des opérateurs variant: ecological: if an operator doesn't work as expected, dive into it and repair it. **(*)game: parameterized key shape: target is a slot with a particular shape, key is composed of segments with length == [[parameter]] many segments have same parameter: coupled variables layout: _ _ ______ _| |_| |_ _____| | _| | |_ |__ _ _ _| ___ __| |_| |_| |________| key shape gameplay: it is a logic game in which player must assign valid values to parameters step by step example: target.someSegment.length == 2 and current.[AB].length == [[x]] => player should do: [[x]] <- 2 challenge1: key's segments have pure or constant parameter values: key.[AB].length = [[x]], key.[BC].length = [[2]], [CD].length = [[x]], [DE].length = [[y]]... difficulty can be increased by increasing the number of segments gameplay1: segment length assignation is only possible via coreification edu: pour insister sur le côté: "une variable, c'est une longueur qu'on peut rendre réelle" gameplay2: segment length assignation is done via click and drag (==object stretch) edu: pour insister sur le côté: "si je vais bouger ici, je fais bouger là, car c'est la même variable" edu: répondre à la question "Mais c'est quoi x ?" challenge2: key's segments may have composite parameter values: [AB].length = [[3x + y]], [BC].length = [[y]], [CD].length = [[x]],... dev: attention à créer des challenges qui ne soient pas trop insurmontables edu: montrer que certains problèmes, qui ont l'air solubles en manipulant, requièrent une résolution "papier crayon", en les posant proprement 09 décembre 2022: ***vibrating blooms: [[4 + x]] can be a reprensented with a constant reictangle and a vibrating reictangle edu: visualize equations: an equation has a solution when both side have same length (vibrating segments scan values in a certain range) ***flash when equal: pause(0,7 sec) and highlight both sides when both side amount to the same value ("a solution has been found") sides can be represented as: lengths areas numerical evaluations 11 décembre 2022: **assignment operator: used on litexpr: [[(3x+4)/5]] * [<- 2] = [[(3x+4)/5(==2)]] edu: show that it affects [[x]], and that it amounts to solving equation: (3x+4)/5 = 2 careful: (∃n / expr_1 <- n => expr_2 -> n) ⇏ expr_1 == expr_2 (∀n / expr_1 <- n => expr_2 -> n) ⇒ expr_1 == expr_2 gm:challenge: proportionnality: i:[[3x]] ops: [[<- 3]] [[<- (-30)]] [[<- (-2)]] [[<- 5]] target: [[2x(==-20)]] variant: with geometric shapes areas: i:[[shape(triangle).area]] ops: [[<- 3]] [[<- (-30)]] [[<- (-2)]] [[<- 5]] target: [[shape(square).area(==10)]] **gm:challenge:do your sqrt yourself: player has to use right triangle machine to create sqrt-valued gm then used to reach target layout: i1: [[1]] [[2]] [[3]] [[5]] op1: right triangle machine with <[[input1]]> and <[[input2]]> and [[gm__output]] op2: [+ 1] [- 2] [× 3] [/ 4] target: [[3 sqrt(34) + 2]] variant 1: hypotenuse machine: gm__output.value = sqrt(input1.value² + input2.value²) variant 2: right angle side machine gm__output.value = sqrt(inputH.value² - inputRAS.value²) gameplay: view map by scrolling while continuing to move "hero" (there is no map screen, map display is only dezoomed-display) there still can be fog of war == undiscovered greyed areas "Supreme Commander meets Adventure" 17 décembre 2022: **(*)game: tennis100: layout: -----|------------|------------|----> -20 0 20 Player A's side | Player B's side gameplay: service: Player A: play a service card game: Player : 1. play an interval card (interval must contain ball value not to lose point) 2. play an operator card (ball must go on the other side without leaving court) Player's hands are semi-visible: half of player's hand is visible to the opponent, so that they try to put the ball where the opponent cannot go (?every player "sees" themselves in the [0;20] area, and opponent is in [-20; 0] area edu: insister sur la symétrie centrée en 0 des nombres relatifs variants: [+ 1+] vs [+ 1-] card: if ball is in [[-1]], [+ 1+] will go on the other side if ball is in [[-1]], [+ 1-] will not go on the other side **challenge: tennis against a wall: layout: ^ wall -----|----------------------------- | ^| | || | ball + | | v 0- [] target gameplay: challenge1: given [[initial]] and , user must click on the spot so that [[initial]] * [+ ] = [[clicked spot]] /modulo wall/ challenge2: user must choose a strength value so that: [[initial]] * [+ ] = [[target]] /modulo wall/ difficulty: easy: [[0]] is before wall, and wall is at [[10]], [[initial]] is around [[0]] normal: [[0]] is after wall, and wall is at [[-10]], [[initial]] is around [[-20]] normal+1: [[0]] is before wall, and wall is at [[100]], [[initial]] is around [[90]] normal+2: [[0]] is after wall, and wall is at [[-100]], [[initial]] is around [[-110]] **(*)[structure]qrcode game: 3-phone way: no physical qrcode cards, virtual cards are shown by players' phones (en route vers la dématérialisation) PhoneA PhoneG PhoneB gameInit: PhoneG creates new game and generates 2 qrcodes, one for PlayerA and one for PlayerB _GameState is only hold by PhoneG_ PlayerA scans their qrcode PlayerA gameArea is init'd PlayerB scans their qrcode PlayerB gameArea is init'd game can start game: PhoneG awaits for qrcode PlayerA chooses card and a qrcode shows on PhoneA's screen PhoneG reads PlayerA's qrcode gameState is updated _GameState is only hold by PhoneG, which knows exactly playerAState and playerBState_ then PlayerB chooses card... remark: ** if phones had 2 screens: front and back, selected object(==card) would be shown on front qrcode would be shown on back and scan on PhoneG wouldn't require the clunky flip/scan/flip 18 décembre 2022: (***game of games: a game to cover the history of video games there is a roms' path (graph of nodes, each node is a video game) we start at foundation games: pong, space invaders, pac man, ... player has to play game for a certain time (say 10 or 20 minutes) OR finish level 2 (or kill boss X or ...) to unlock next game in the tree dev: this is a super-layer to build over emulators+roms it would be nice to code it as an html page that has permissions over user's filesystem, and which would only require user to have a compatible installed base of emulator+roms **vibrating segments:: x²-"unit"-squares 2x +~~x~~+~~x~~+ s s s x x² x x² x s s s 2x +~~x~~+~~x~~+ s s s x x² x x² x s s s +~~x~~+~~x~~+ *ui: easy spawn (for **(*)"spontaneous" edudemos(==teaching situations created on the fly)) Key1: 0.1unit-sized segment Key2 1.0unit-sized segment Key3 10.0unit-sized segment **gm:litexp::japanese symbols: instead of [[x]], use a japanese symbol (example: [[あ]]) 04 janvier 2023: *edudemo: réduire une expression littérale: les x² sont des carrés, les x sont des rectangles fins et les unités des petits carrés réduire une expression littérale, c'est faire un tas pour chaque famille **vibrating segments allow the creation of "variables without a name" indeed, there is, primarily, no need to name the segment we use. It simply is "this". and we can clone this unnamed segment to create multiple instances of "this undefined variable thing", _all varying the same way_ edu: then we can eventually assign a variable with a name to ease later reference dev: vibrating segments _internally_ have a variable (in order to vibrate), which can then be coupled with a _external_ symbolic variable => 2 flavors: "pure" vibratingSegment: no external symbol is attached to it when spawned pre-coupled vibratingSegment: an external symbol(example: [[x]]) is already attached to it when spawned **floodFill X vibrating segments: floodFill of a vibrating area creates a vibrating floodFilled object **(*)color gradient segment: a 1D-gradient color pattern extends from end to end this is a another way of representing the difference between variable segment and constant segment, but without movement this time (more quiet) edu: this allows the display of [[x²]] as a 2D-gradient colored square 0 1 2 1 _______ 0 |0 1 2 1 1 |1 2 3 4 2 |2 3 4 3 1 |1 4 3 2 **vibrating color gradient segment edu: length vibrating segment is to emphasize ontologic difference between [[x]] and [[2]] (one is variable, the other is constant) edu: color vibrating segment is to emphasize ontologic similarity between [[x]] and [[2]] (both are numbers) **(*)challenge:gm:units: [[mm]] to [[km]] by using [x 10] [x 100] [x 1000] operators initial and target are units [[mm]] * [× 10] = [[cm]] 05 janvier 2023: **vibrating segment: both ends must vibrate (differently) in order to truly feel the variable nature of the segment if the segment has one end pinned to a fixed point, then only the other(==free) end should vibrate **polyLine: composite(segment1, segment2, ...) by sticking ends (==polyLineEngine) **polygon = polyLine + polyLine.point_start == polyLine.point_end **PolygonMosaic: group of polygons, each sharing at least one side with at least another polygon edu: vibratingSegment-based polygonMosaic: what would you choose for [[x]], [[y]], [[z]], to make a house ? to make a tree ? etc... **PolygonQuasiMosaic: polygonMosaics linked by polyLines ***variable segments 1D-polyLine resize ***eduDemo: 2x + 5 = 14 solving by resizing variable segment polyLine: |~x~|~x~|--5--| (before resize) |~~x~~|~~x~~|--5--| ( after resize) |-------14--------| then user can hover [[x]] to get its value or there may be a little [[]] box next to [[x]], dynamically displaying its value ***challenge: 2x + 5 = 14 "Singapore solving" workflow: |~~x~~|~~x~~|--5--| |~~x~~|~~x~~| |~~x~~|~~x~~| ( |~~x~~| ) |-------14--------| ==[cut(5)]==> |-----9-----| ==[comb(2)]==> |-4.5-|-4.5-| (==[keep(x)]==> |-4.5-| ) *|~~x~~|~~y~~|--5--| resizing ? ==> use blue points / black points as in Geogebra **(*)game: variable segments + constants segments: build target shape using initial collection of segments variable segments can be resized, constants segments cannot be resized a logic game could be built using this game mechanic **(*)game: build to satisfy constraints: there is a set of constraints: A ∈ [BC], C ∈ insideOf(Triangle(D,E,F)), etc. initial is a set of objects: points, segments, squares, circles, etc. target is "objects have been assembled so that the set of constraints is realized" 2 flavors: dynamic (fit for learning): solved constraint is painted green when realized challenge is completed when all constraints are realized asynchronous (fit for examination): pressing [CHECK] button paints realized constraints in green challenge is completed when pressing [CHECK] button with all constraints realized (before giving students paper and ink "mindful" challenges, it's better to ensure that the universe we are refering to is somehow known if not well grasped. (so the preliminary "visualization" step helps students to build in their mind their own replica of this universe 07 janvier 2023: *polyLine making/unmaking: making: release segment end when close to another segment's end unmaking: select inner joint and Shift-B to separate parts composite segment controls: on an end point: single click and hold: move all double click and hold: move end point (if segment has fixed length, move end point in allowed circle) 11 janvier 2023: **(*)gm:spaghetti challenge: polyLinePath: the path is not a handDrawn curve but a polyLine => the polyLine may be edited if the target is not reached edu: keep what is OK and change what is NOK **polyLineGraph: polyLine with branches and loops 2 flavors: oriented and not-oriented ****pathMade programming: polyLineGraph / branch synching (=> pathMade programming is now fully achievable) path is made of oriented polyLineGraph if 2+ branches end up at a crossroads, their carriers are synchronized to yield the carriages at the same time, so that a multi-argument operator can then trigger *curve: Bézier, spline... **polyCurve: composite(curve1, curve2, ...) by sticking ends *icObj.type = "uniformSConveyor" can be touched anywhere on touch: 1. object center = closest straight conveyor point 2. move object center along conveyor points at conveyor's speed (same speed along all path) (*icObj.type = "customSConveyor": custom speed function can be specified along the path (**game: cannons: at sConveyor's end, object keeps its velocity so the player could put operators along cannon's path, so that the boulder becomes bigger (boulder could be mathNode) but it then gets closer to a physics game **(*)game: circle targets: gameplay: 0.there are 5 targets put on an outer circle (all in [[0;360[[ integer number interval) target.value == angle at which it is put on the outer circle while there is an unshot target: player builds mathNode projectile via standard greenMouse interface: challenge right side slot is the cannon slot player then moves cannon and shoots mathNode projectile on target (there is a [shoot button]) edu: have students used to angles in degrees on a circle **floodFill: square fill: flood fill by recursively filling with squares of decreasing power size **(square) collection: sort by size edu: show a way of measuring areas 15 janvier 2023: *comfort: key: get back to main scene pos and scale **inputProperties.number (same as inputProperties.color and inputProperties.opacity) inputProperties.number == 3 => spawn_regularPolygon() ==> triangle inputProperties.number == 4 => spawn_regularPolygon() ==> square easy: keep the same behavior as for color: change value by scrolling, show when setting, fade when set range: [[-10, 30]] **inputProperties.symbol inputProperties.symbol == x => spawn_vibratingSegment() => a segment with external variable [[x]] spawn_vibratingSegment() => another segment with external variable [[x]] resizing first segment auto resizes second segment because they share same length(==[[x]]) easy: keep the same behavior as for color: change value by scrolling, show when setting, fade when set set: {"x", "y", "z", "t", "a", "b", "c", "d"} 19 janvier 2023: toxicode's "/progress generator" is a very powerful tool if players answers well, repeatedly, player lifts to upper difficulty level if players answers wrong, player falls down to lower difficulty level edu: this smart staircase should be used to get closer to student's true own current "state" ==> "trial-tailored" interactive learning (comme un tailleur qui prendrait les mensurations du client, en essayant de le faire passer dans des pochoirs géants (gabarits)) BACK TO BASICS: **challenge: carry: challenge area: sandbox area: 1 4 4 + [slot1] [slot2] and next to it: + [slot3] ___________________ ______________ 3 1 . . sandbox area: if player puts [[8]] in [slot3] then 1. a carry is written in the valid column 2. 1 2 is written as the result of the operation challenge area: if player puts [[8]] in [slot2] then 1. a carry is written in the valid column 2. 1 (==expected result) is stroked and 2(==result of operation) is written **challenge: from tree to litexp: indirect GM [[initial]] is gm leaf node [[target]] is litexp 1.player builds tree from gm leaf node 2.player drops tree in a safetyzone when they think it's ok 3.an indirect litexp greenMouse slot is then updated with the tree's corresponding litexp 4.player picks up the indirect gm and completes challenge by moving it to target touch slot edu: insister sur le lien arbre de calcul <--> litexp **(*)challenge: Singapore building of litexp: multi-options GM: player has to choose the right gm to start with target is a vibrating segment corresponding to a displayed litexp player must build vibrating segment corresponding to litexp using operators example: [[target]]: |~~x~~|-2-|~~x~~|-2-|~~x~~|-2-| litexp: 3(x+2) [[inital]]: [[x]] [[2]] [[3]] [[3x]] arr_op: [+ 2] [+ x] [× 3] [× 2] difficulty: easy: many ways normal: 2 ways hard: 1 way **challenge: relative numbers: place number list on number line, one by one: initial: [[ [-5;-9;2;7;-1] ]] 1. [[-5]] should be grabbed from list and put at the correct spot on the number line 2. loop: [[-5]] should be grabbed from number line and dragged to [[-9]] correct spot etc. dynamic display of operation being built: if player is at [[-8]], starting from [[-5]] then show [-3] arrow on top of number line, from [[-5]] to [[-8]] edu: have player experience [[-5]] * [move 4 units to the left] = [[-9]] (<=> [[-5]] * [- 4] = [[-9]]) 01 février 2023: easy: pov: 1. shift + KeyP + 1: save pov1 2. KeyP + 1: spawn goto pov1 button **challenge: equations: make [[x]] from litexp: target has value label, initial is litexp, user must "unpack" [[x]] every time current litexp is transformed, target's value label updates accordingly 02 février 2023: ***pov-scope'd button behavior: button behaviour is different with each pov scope edu: this allows up-down-left-right interactive presentation, using pov-scope'd [gotopov] buttons for example: virtual visit of a site using key pictures **pov-based hinting for treasure hunts: if user is stuck, user presses button and is brought to "next step's" pov **easy: pov (alternative) 1. KeyP: create pov with [[ label]] 2. [icTextContructor: gotopov ] --> creates gotopov button **supereasy: pov 1. KeyP: create pov (this creates a narrow-bordered rect) 2. right-click on pov: copy link to pov 3. CTRL-V: paste link to pov (== [gotopov] button) **ultraeasy: pov set pov: Shift + space **icObj.type = "popping": when cursor hovers this object, object gets a little bigger **(*)cursor-based zoom: when cursor in on popping object, zoom occurs on popping object dev: imagine a world map with popping pictures on each capital, if cursor is out of popping object, zooming on capital is still possible 03 février 2023: **a map and a visit: if each site is a popping with a bound pov, one can create a map (which can still be used as a map) and in which a visit can happen (via gotopov sequence) **a map and many visits: map can be covered by many visit trees, which can intersect **down_select: KeyW+select: select objects that cannot ordinarily be selected (example: povRect) obj.selectionLevel 08 février 2023: **easy: preformed pov star: center pov with up-down-left-right povs then user moves the up-down-left-right povs to the desired locations **easy: modular pov star: spawnPovStar(nb_children) **pov coalescence(== pov fusion): keep only 1 pov when the 2 povs are very similar ***pov-bound button relays: if KeyUp is pressed when roughly at povX, then KeyUp relay triggers and forwards press to underlying button ***area omniTracker: when player has its pov contained in rectX, a pair of floating eyes follows its every move this can be used to indicate that this area is particular edu: this may be used for hinting **omniTracker: this can be used to create fear and the feeling of being observed edu: this can be used to show that teacher is observing student's screen **ui: highlight parts when composite handle is selected *?ui: shift-click: select next (round robin of objects under cursor) **ui: move to front, send to back: use same key as for zIndexEditing (Digit2) **challenge: safeLock mathNode constellation: 1. there is a big 360 degrees protractor 2. some mathNodes are put around protractor center 3. these mathNodes can only move by rotating around protractor center 4. challenge is completed when player has put all the mathNodes at their valid locations mathNode value must match the chosen angle example: [[35 + 20/5]] must be put at 39° [[4 - 20]] must be put at -16° == 344° 12 février 2023: **easy: {[[lock]], [button_toggle_lock]} couple if [[lock]] with .isLocked==true is in contact with a button or an operator, then the button or operator does not trigger edu: when can create chained of locked unlockers: [button_toggle_lock1], [button_toggle_lock2] locked by [[lock1]] [button_toggle_lock3] locked by [[lock2]] etc. **text: dynamic background: (close to a visualNovel) as player changes pov above an icText(== reads text), images move and take place of background if(pov in areaX) {bg == imgX}, if(pov in areaY) {bg == imgY}, ... textColor is adapted to bg img 16 février 2023: **icObj.type = coreArea; Everything inside inherits from coreArea props ***marking ifs and trigger-on-marked operators: (program by drawing) condition1(obj1) == true condition1(obj2) == false [[obj1]] * [if(condition1)] = [[obj1]]* (obj1 with marker) [[obj2]] * [if(condition1)] = [[obj2]] (obj2 is left unchanged) [operatorX] only triggers with marked objects then [[obj1]]* * [operatorX] = [[obj3]] (obj1 has been transformed) then [[obj2]] * [operatorX] = [[obj2]] (obj2 is left unchanged) ***easy: easy creation of trigger-on-marked operators: trigger-on-marked operators may be operators which have been coreified by putting associated if-marker upon it (coreification) (everytime an [if(<>)] is created, the associated marker is also created) [std operator] -----put if-marker over it-----> [trigger-on-marked operator [ ]] [ marker ] [ ] negative markers: condition1(obj2) == false [[obj2]] * [if(condition1)] = [[obj2]]¤ (obj2 is negative-marked) trigger-on-positive-marked area/trigger-on-negative-marked area: all objects contained in area are trigger-on--marked ***virtual marionnettes: live performances of multiplayer iC actor1 controls marionnette1, on left side actor2 controls marionnette2, on right side spectator has limited pov, and does not see the surrounding "backstage" backstage assistants may help actors by sorting accessories and marionnettes and also by changing background and animating the scene so we can make live plays and child stories **icObj.type = "marionnette" object has many sprites: 'front', 'back', 'left', 'right' when moving object from left to right, marionnette sprite is auto switched to 'right' => better child stories *double pointer: one pointer is coarse, the other is precise and only moves in a area centered on coarse pointer 02 mars 2023: 0 dominos with negative numbers: * * o == -1 o o path-drawing: scale down/up while drawing ==> scale down/up while conveying th: inside is outside labyrinth, pov jumps (position marker does not move, it's pov that moves) each pov show a cell composed of the entire outer map (square) each cell has its position regarding the outer map marked inside it example: [4][5][6] [1][2][3] when pov-jumping from pov [2] to pov [5], it seems that it's the position marker on the screen that is moving but it's only a change of pov (cell [2] and cell [5] contain almost the same image i.e. the outer map, but image [2] has position marker on inner [2], and image [5] has position marker on inner [5] ) ***pov-drag: hold object then gotopov this would allow picking specific objects from dedicated pools ***build particle animations by drawing path: 1.draw path _slowly_ 2.then use copies of it translated, rotated, scaled up/down, in an accelerated form (timewise scale), and delayed (timewise translation) **coreify: attach (particle) animation to object then play it on keypress or when object is held **(*)time control: when drawing path, time flows (time position goes -->) then time position can be controlled with T+scroll in order to create simultaneous/sequential animations or conveyor operations time position is showed using fadingHUD changing time position updates the space position preview of carved-in-time conveyors ***challenge: put the right thing in the source area 4+ challenges have an automatic conveyor set in [ [ ] ] [ ] [ [] ------------> [] ] [source area] [ gm [ ] target ] [ ] portal to source area player has to put the right operators in source area so that all challenges complete simultaneously ***challenge: variables via portals to platform-holding source area source area can now hold global variables, which are mutated in order to complete challenges (one after another) ==> cross challenges: you have to use other-challenge's initial in order to complete challenge challenge1: [ [[2]] [portal#1] [[5]] ] challenge2: [ [[3]] [portal#2] [[7]] ] source: [platform +]] => the big math challenge: 10+ cross challenges, source is for global variables, each challenge has initial and operators of a specific area of math **ic::everyone's board: board is shared to everyone and it is persistent just go to everyonesboard.com ***(*)presentations: book of leaves: (==portal half-traps): (revisiting zoom trap idea at line 60!) portals: [A] [B][C][D] [E] diving into [A]: when screen is totally inside portal [A], we are at A(source) then going up from A(source) shows A(source) surroundings (you don't directly go back to [A],[B],[C],... level) to go back to [A],[B],[C],... level there is quantum step transition to go through: clouds now surround A(source) there is a scroll resistance, which, if you insist, (or maybe use ctrl-scroll to indicate that a scroll step has to be crossed) let's you go up to [A],[B],[C],... level: clouds fade around [A] and [A] has always kept its place on screen, so it seems a continuous transition if you go up and A(source) is not visible then you stay in A(source) surroundings edu: this allows showing context around spotlighted areas, should the presenter's speech require it *show/hide-on-marked portals: conditional function calls using shown/hidden portals *portal revolver barrel: conditional function calls using sliding column of portals **challenge: decimals: cursor-aware operator there is a _position cursor_ on collection, and operator only applies to cursor'd: example: [[3 4 [5] 6 7]] * [+1] = [[3 4 [6] 6 7]] edu: the idea is to progress from [<-] [->] [^] [v] operators applied on a cursor'd collection of numbers to [× 10] [/ 10] [+ 1] [- 1] operators applied on a number (cursor is somehow always "units") challenges: 0. collection, no cursor: input target combination using [[3 4 5 6 7]] * [<- 2 (touch on 6)] = [[3 4 5 2 7]] 1. collection, no cursor: input target combination using [[3 4 5 6 7]] * [+1 (touch on 4)] = [[3 5 5 6 7]] 2. collection, cursor: input target combination using [<-] [->] and [<- 0] [<- 1] ... [<- 9] on [[0 [0] 0 0 0]] 3. collection, cursor: input target combination using [<-] [->] and [+ 1] (no carry) 4. number, cursor: input target combination using [<-] [->] and [+ 1] (carry!) 5. number, cursor: input target combination using [× 10] [/ 10] and [+ 1] 6. number, cursor: input target combination using [× 10] [/ 10] and [- 1] 7. number, no cursor: input target combination using [× 10] [/ 10] and [+ 1] 8. number, no cursor: input target combination using [× 10] [/ 10] and [× 3] => a number is an infinite collection of digits, some of them being different than zero **(*)edu: "approche subliminale" 0.get players used to start challenge with initial:[[1]] 1.then instead of starting a challenge with initial:[[1]] start challenge with a little liminal room with initial:[[1/4]] and [× 4] next to it so that players get that [[1/4]] * [× 4] = [[1]], _just by having done it repeatedly_ **(*)mario + portals: z-scroll with controller player controls character with the controller player puts character above portal player dives character in portal, using R button (z-scroll zoom-in) character is now in portal's source area **ic::good old paint mode: (==do not create new object but overwrite underlying objects' pixels) if player handdraws in old school mode, then all layers that are below "pen" will be "old-school drawn" (==pixelwise drawn) this allows creating O-puzzles easily transparent top layers allow adding notes or mutations over underlying objects **[structure]fragile gm: glass shatter/mark on error (==go-back-to-start penalty): have student think before they act there is a series of challenge that must be completed in a row in order to pass the test if you make a mistake, or a _bad move_(see example), the gm is shattered and you have to retry _from the start_, and the challenges may or may not refresh (so that students don't try to remember/try to remember what to do at step n) example: divisibility rules: [[987]] * [/ 4] = [[glass shattered gm]] because 987 is not divisible by 4 so that the student has to check mentally if the division is possible before doing it 05 mars 2023: ***false seams: (==portal seams) (~~horizontal portals) when screen displays A, user pans and easily goes to C so it seems that zones are like this: [A][>>][C] ([>>] represents the seam (it may be thick or not, even with width:0)) when they may actually be very far from each other (C could be anywhere) [A] [C] or even: [C] [A] **[Wow effect]Mario's big leap: character moves from zone1 to zone2 (very far from each other) by z-scroll zoom-out and then z-scroll zoom-in so it's as if the character jumped high and gained altitude, and then fell down like a meteor when it's actually a matter of scale **coreify area: conditionally-activating operator area (all operators inside require same condition) example: (incorepored condition is [> 0]) [ ] [> 0] ] [ [+ 4] ] [ [/ 3]] [ ] **[structure]challenge:gm: "lift/unlift": challenge area: [ ] [ [cond. op area 1] [cond. op area 2] ] [ [initial] [target] ] [ [cond. op area 3] [cond. op area 4] ] [ ] the game is to find a path to reach target via areaX then areaY then... => sometimes, player would have to make number negative (lift), only to use a [< 0]-requiring operator and then get the number back to positive (unlift) and continue transforming it we can also imagine changing the type of the gm (type lift/ type unlift): [cond. area 1]: [is number] [cond. area 2]: [is string] [cond. area 3]: [is array] [cond. area 4]: [is image] edu: we can speak about convergence and divergence: challenge with 2 areas: [> 100] area with [+ 10] [× 10] [< -100] area with [- 10] [× 10] this challenge setup is "divergent" ***ic:calendar + portal half-traps + false seams: now we got something really promising (21st-century tech) 08 mars 2023: **cursor attractor: if screen center is in zone, z-scroll is automatically aiming attractor center 2 flavors: zoom-in attractor: this is used to quickly zoom-in to the important part of the zone zoom-in attractor: this is used to quickly zoom-out to a big-picture view of the zone **funnel (== object vacuum / size adapter): drop things in a funnel zone and they will dive to funnel floor level 2 flavors: zoom-in funnel : conveyed object will get smaller zoom-out funnel : conveyed object will get bigger *scroll-accelerating zone: z-scroll in this zone uses a bigger factor: zoom-in/out is faster **scroll-accelerating cursor attractor: cursor attractor + scroll accelerating zone in order to easily get to the important area, scroll is fast at first then it gets slow when approaching (==eased approach) **(*)game: labyrinth in labyrinth in labyrinth... (hard walls) when character has got out of labyrinth#1 (small), character can be zoom-out z-scrolled, but then bangs on the walls of labyrinth#2, etc. dev: collision (prevent scale up when object collides walls) fun: same labyrinth structure could be used with different starting points at each zoom level fun: there will always be a doubt whether character is finally free or not because when can always imagine a bigger enclosing labyrinth 12 mars 2023: **easy: when freedrawing over an old freedrawing: enrich underlying freedrawing ==> only one object 16 mars 2023: *edu: utiliser une image de rapporteur dans iC pour faire des mesures d'angles rapporteur 180° rapporteur 360 rapporteur ammonite ***build instructions by moving/touching instruction "tobe" a tobe is an object that evolves from nothing to a fully fledged object layout: a certain number of [function keyword] and [[argument]] example: [replace] [add] [add_inplace] [append] [append_inplace] [[123]] [[4]] [["abc"]] [["def"]] workflow: 0. start holding empty instruction tobe: [] 1. touch a function keyword: the tobe starts to grow example: [] * [add] = [add] 2. touch as many arguments as needed: [add] * [[123]] = [add 123] [add 123] * [[4]] = [add 123 4] 2 flavors: instant trigger of instruction: as soon as instruction is complete, it is executed [add 123 4] *(i) = [[127]] forced trigger of instruction: when tobe touches an [execute] touchslot, instruction is executed (or tried to be executed) [add 123 4] * [execute] = [[127]] edu: 2 main paradigms: functional: a new object results from instruction execution old-school writing: one of the args is replaced by result of instruction execution fun: code is data, data is code: function keywords may be used as arguments example: [replace replace add] *(i)= [replace] is now [add] ***write functions that write instructions: [instruction tobe] X pathmade the result of the pathmade is an instruction **group touch: activeSelection is the touched object: selection{[[5]],[[5]],[[5]]} * [+ 1] = selection{[[6]],[[6]],[[6]]} edu: easy show the concept of map fun: challenge: operators only trigger with 3+ objects as input transform initial pool to target pool example: i: [[1]] [[2]] [[3]] [[4]] ops: [- 1] [+ 1] t: [[0]] [[0]] [[0]] [[0]] **collection touch: only children which may be valid args for op are mutated: collection([["abc"]],[[5]],[[10]]) * [+ 1] = collection([["abc"]],[[6]],[[11]]) **composite shallow touch : only operate on children top level **composite shallow touch iteration: breadth-first / depth-first, if first level has been op'd on, then operate on second level... 19 mars 2023: **instruction tobe X icTextConstructor: build object by moving mouse around *zIndex drawing: the smaller (scalewise), the deeper (zIndex wise) **easy: composite part(s) update: temporarily set selectedPart(s).isMobile=true when altLeft is keyDown isMobile wrt position isMobile wrt scale isMobile wrt rotation ... ****deep freeDrawing: enacting an idea written at line 390 ! edu: deep freeDrawing would allow easy check of correct use of transformation operators an extra-small part of the object to transform (a segment for example) would be a deep freeDrawing, which should be exactly positioned at point X for a validation pattern to appear thus, if validation pattern cannot be found, then the student has not followed the given transformation process **freedrawing: non-drawable zone: when in drawingMode, scribbling over this zone will make it visible, negatively, because this zone won't be drawn over dev: this is possible by using continuous-yet-composite freeDrawings via programmatical trigger of mouseup/mouseDown **freedrawing: rhythmed activation of freedrawing: user holds mousedown yet it creates intermittent freeDrawing 20 mars 2023: **(*)freedrawing: "continuous-intermittent" on change: brushWidth change color change *** z-index change (to easily draw "celtic" knots for example, or other "Wow!" stuff...) ... *avoid blur around objects (images for example): wrap in bounding path 22 mars 2023: LESSONS FROM an eduDemo: rot_puzz2.png(rotation challenge sheet) with rapporteur_ammonite.png(protractor): GET AS CLOSE AS POSSIBLE TO THE PEN AND PAPER EXPERIENCE => need a good protractor ux rotative movement innerPainting(==marking/erasing) on protractor => need to rethink part mobility in composite **[compositeSegment]: shift + drag point : locks everything but the held point ==> protractor rotative movement **(*)[compositeSegment]: ²(Backquote) while holding point: trace(==freedrawing based on moving object) **relative pan (keydown toggle): key1 down "inside" ²(backquote) down: 1. set relative pan origin 2. pan relatively to origin: the farther, the faster => this would allow continuous "deepwards" freeDrawing ***deeppath: deep freeDrawing + conveyor conveyed object changes scale as it follows the deeppath this allows writing function code on a lower level (as it is possible with funnels) 23 mars 2023: **button: show message on hudCanvas example usecase: show message until player has moved where message told them to go (game: _Imagine_ board game images on iC: play game in iC ***freeDrawing pan(s) (rightMouseDown while leftMouseDown): move paper along with pen dev: this is quite complex same thing for freeDrawing rotations => easy freeDraw rotating text a lot of flavors: screen border move: keyDownToggle(Key) while freeDrawing: pan when getting close to screenBorder pan gets faster when cursor getting closer to screenBorder 24 mars 2023: **freeDrawing pan: freeDraw while moving object (draw translation vector while moving object to its destination slot) **(*)eduDemo: translation: 1.create conveyor 2._pick object shade_(object does not move but we pick its "soul") and touch conveyor with it (==start of vector) 3.object is moved along conveyor edu: eventually, create clone of object before translation to show state.before and state.after edu: same workflow can be adapted to other transformations (rotation, homothety, ...) 25 mars 2023: ***screenStamp: stamp front-level canvas so that object visually stays where it was seen ***workbench: capture rect to everyday-life file format layout: a rect, a save_as button image workbench: capture area to .png "protransparent" layer: put this at lowest level to export png with transparent background for user to distinguish protransparent layer from others: this layer has animated content (waves, sparks, ...) pdf workbench: capture area to .pdf gif/webp workbench: capture _ area from time t_1 to time t_2 _ to .gif svg workbench: crop svg to workbench rect (if it's of any use... (?)) **spiraling freeDrawing text: freeDraw while rotating + zooming-in => spiral staircase with text ***minimize/maximize: area temporarily gets bigger (via zscroll zoom-out) to easy working with it edu: example: say we have a layout where the lesson it at top level and exercices are at a deeper level we could maximize exercises area(==bringing them at top-level) to be able to quickly peek at lesson while doing them and then minimize them when we are done **hyperlink: ictext + gotopov 26 mars 2023: *challenge:gm:translation: 1. select gm 2. draw vector and release 3. gm performs translation based on vector 4. if gm ends in target zone, challenge is completed we can show a score to indicate how precise it was edu: to avoid students drawing vector starting point on gm, create a _forbidden zone around gm_ in which starting drawing is not allowed **easy: fontScroll: KeyW+F (keyDown toggle) + scroll fontList may be updated by going to parameters::fonts area in the canvas drag and drop .ttf file (which will automagically be added and moved to fonts area) to add a new font ***workspaces: as users customize their canvases along with their personal usecases, canvases become workspaces examples: a mathematics teacher will have a base canvas with math eduDemos and math objects, etc. a manga enthusiast will have a base canvas with characters, backgrounds, etc. so there is a _long-term evolving canvas: the workspace_, which will converge to an efficient and comfortable tool and there are short-term evolving forks, each adapted to a very specific situation: the user's outputs 26 mars 2023: *challenge:homothety::"get in frame": select center and ratio so that transformed object lands in frame without overflowing 27 mars 2023: ***deepFreeDrawing: store deepDrawingTrajectory: usecase: 1. draw a hair once, going from thick to very thin (via z-scroll zooming in) 2. store deep drawing trajectory 3. now, to draw a second hair, no additional zooming-in is needed, as freeDraw follows the stored deep drawing trajectory so a lot of hair can be drawn by repetitive stroking other usecases: when repeating a pattern but always changing it a little when drawing it 29 mars 2023: **easy: edit path by pushing it (finger tool) **freeDraw::gradient: as you draw a line, it refreshes to always satisfy gradient: {startPoint: colorA, (current)EndPoint: colorB} dev: inputProperties.color__primary, inputProperties.color__secondary 30 mars 2023: **easy: zIndexFreeDrawing: send brush to front/back front: backquote + F back: backquote + B (though this will make drawing less resistant to "shaking") **zIndex-based puzzles: example: layout: a grid with 16 letters [A,...,P] a black snake-like path workflow: user has to translate the path over the grid, leaving only a few letters uncovered it's only when putting the path on the grid that the user realizes it was zIndex-ful **instant-activated touchSlot: touchSlot is touchable _only one single instant_, after user has pressed instantActivatedTouchSlot's assigned keyboard key, or a touchSlot-related [instantActivation] button so we can _prepare a conveyor with a ready-to-go object on its touchSlot_ edu: this way we can prepare animations and trigger them by hand 31 mars 2023: **ultra easy: zIndexFreeDrawing: front/back A/B-scroll: as if there where only 2 possibilities with mouseWheel Key< > + mouseWheelUp: modeA (back) Key< > + mouseWheelDown: modeB (front) this allows very easy drawing of overlapping/interlocking objects edu:math: draw cube edges (front, mid, back), and traverse cube with line (illusion of 'inside') edu:physics: draw semi-transparent cubes, cylinders, etc. using zIndex and show the passage of light **alt is for "alteration": composite part is sole target for modifications when alt is keydown **composite: alter handle: handle can be altered the same way as for any composite part: Alt + **easy: c-Scroll: change color of active object by alt + KeyC + mouseWheel **easy: v-Scroll: change opacity of active object by alt + KeyV + mouseWheel **autoScroll: like A/B-scroll but with a gradual transition (in steps) **edu: display compatibility of objects by showing that their handles interlock in a context of match-2 for example the handles are blob-like closed lines compatibility appears as intertwined lines the more crossups the more compatible **easy: edge (à la floodFill): draw a little edge around target object, using activeColor *pretty arrow: arrow end resizes along with current ic.scale, so it always looks like an arrow **(*)brush.scale in inputProperties to draw zoomed-in-type thin lines while staying at a zoomed-out ic.scale **paste with scale: Shift + Ctrl + KeyV: object is pasted at exact "same level" as copied object **eduDemo: easy build n-ary tree: zFreeDraw + cores example: draw root tree: a trident add a rect at each leaf, each cored together: burgeonning_trident = trident + cored rect leaves copy burgeonning_trident and add it to leaf1 core: other instances are automatically added a burgeonning_trident here: there are 2 flavors, depending on how cores are copied/pasted - recursive: if a core contains an instance of itself as a child, recursion occurs: a fractal is created - copies are different from the original: new cores have a different .level property: there are linked together but not with the parent or the children we can create the tree step by step 1 burgeonning_trident with .level=0 3 burgeonning_trident with .level=1 9 burgeonning_trident with .level=2 ... *game: 5min reproduction of famous paintings: using iC: each player has 5 minutes to reproduce the famous painting that is displayed, using freeDraw, in a specific area screenCapture is forbidden colorPicker is allowed then players vote for the drawing that is closest, artistically-speaking, to the original painting 1er avril 2023: ***easy: paste() (=="batch paste"): type how many copies you want 0. copy object(s) 1. press and hold Shift + Ctrl + V 2. type the number of copies you want (for example: 15) 3. release Shift + Ctrl + V 4. copies are pasted /!\: this shortcut won't work properly, since Shift will change Digit3 to End, and CTRL.3 means go to tab3 in browser 1 need to find a nice shortcut B for "batch paste": CTRL.B (initiate) ==> B (hold and release) Shift.Ctrl.V (initiate) ==> V (hold and release) ***ux: PrefixingKeys.Key (initiate) ==> Key (hold and release) workflow: 1. press prefixing keys 2. press key 3. release prefixing keys 4. do stuff with other keys (numpad keys for example) 5. release key ***easy: paste(): paste(2*3) for a 2x3 grid of copies use object.size to layout copies correctly CTRL.B then B.inputField("2*3"): create 2x3 grid of independent copies CTRL.B then B.inputField(".2*3"): create composite 2x3 grid of copies CTRL.B then B.inputField(". .2*2 .1*4"): create composite of composites: 2x2 grid and 1*4 grid **(*)paste variations using varying set: example: 1. freeDraw a t-shirt: with .fill = black 2. copy/paste with inputProperties.colors as varying set: a t-shirt with .fill= is pasted for every color in the set edu: pour rapidement mettre en place des situations pour l'étude des probabilités par exemple **freeDraw + core: 1. draw freeDraw object 2. set it as core 3. copy/paste (object2 is created) 4. freeDraw on core: object2 updates automagically 02 avril 2023: (Un jour on comprendra et on arrêtera de dire "C'était un cerveau." pour dire "C'était une main.". **freeDraw: invisible ink + revealer: it's only when under/over revealer that invisible ink gets visible ***freeDraw: winding paint: ("w-scroll"): "zIndex-rotate"(==wind around) selected line 1. select existing path or freeDraw object 2. enterFreeDrawing (keyDownToggle: backquote) 3. enterWindingFreeDrawing: (keyDownToggle: w) 4. scroll: freeDraw cursor is no longer following mouse cursor as it winds around ***freeDraw: radial thicking paint: easily paint stroke width along selected line ***(*)freeDraw: peerce fill/ peerce strength: this is like an eraser-layer which erases up to underlying layers so it is transparent and yet heavily impacting bottom layers it's like a tube traversing layers fun: this allows drawing windows on a freeDrawn house, so that we can see characters/marionettes through the window colored peerce: drill n layers then paint color == peerce.color at peerce.zIndex_low it's like a tube with a solid colored bottom end **easy: peerce: when drawing a closed shape, the interior is considered peercing ***freeDraw: comb paint: before drawing, type how many parallel strokes you want rightMouseClick how many strokes you want (nb_strokes == nb_rightMouse_clicks (no brainer)) edu: easy creation of tables: comb paint vertically then comb paint horizontally **random shake/tilt to enhance display of zIndex-freeDrawing: the "depth feeling" will be stronger **freeDraw: potato paint brush: brush shape is potato-like and changes at each stroke edu: to mimic child drawings shaking potato paint brush: change brush shape at each tick (ticks could be completely random, or regular, or in between) *dot notation for keyboard shortcuts: W.F means KeyF keyup'd while KeyW was keyDown we can imagine more complex formulas: Alt.W.F, Backquote.3.mouseWheelUp **edu: history class auto chronology: when a date object is added, near an image for example, a chronology counterpart (==point on a number line) is automatically added with a [gotopov] to the date pov **edu: math class auto number line: when a mathNode is added, a point is automatically added on a/the number line with a [gotopov] to the mathNode pov pour faire le lien entre opérations sur les nombres et transformations géométriques 03 avril 2023: **ic::events: onPovEnter, onPovLeave, onScaleBeaconEnter, onScaleBeaconLeave **pov:sideSlots: top-right slots are triggered when gotopov starts/ends [ ][] <-- on_entering_pov slot [ rect__pov ][] <-- on_leaving_pov slot [ ] edu: on_entering_pov slot could be used to trigger an animation of course content after student has pressed gotopov fun: on_leaving_pov slot could be used to trigger an animation (like a character waving goodbye) between different story scenes *theater:katamari operator could be used, with a low zIndex, inside a high-zIndex dinosaur monster facade, to create "eating" effect when dinosaur eats an object, it is actually stuck in its katamari operator stomach using a peerce tube could reveal all what dinosaur has eaten **math::expressions:[natureOf] operator: [[3 + 4]] * [natureOf] = [[sum]] eduDemo: use [natureOf] and [splitTopLayer] operator to decompose: [[3 + 4 x 5]]: sum of 3 and product of 4 and 5 **(*)dynamic screenStamp: if stamped object updates at its original location, then screenStamped object in hudCanvas, being its deep clone, is updated the same edu (math): this allows screenStamping parts of the homework list, and directly see when tasks have been completed edu (computer science): this allows easy logging **icObj.type = "scaleBeacon": when ic.scale is zoomed-in more than or equal to beacon.homeScale, something is triggered examples: canvas.bgColor is set to beacon.bgColor canvas.bgImage is set to beacon.bgImage HUDCanvas.message is set to beacon.message 2 flavors: infinite span limited span: beacon is working in specific area (a rect, or more complex) scaleBeacon's limited span could be set via a side slot, which would contain a [[reference]] to the [[area]] object **ic::eyetoy: artist is inside ic, at the back prerequisite: put some green paint(or a qrcode) on your free hand's index finger (the other is on the mouse) workflow: 1. create an icWebcam instance 2. create an icEye that detects the green dot(or qrcode) of artist's finger 3. enter a freeDrawing, with freeDraw cursor == green dot 4. onLeftMouseDown, a line is drawn so we get the illusion that the artist in the webcam rect is drawing **(**)ic::eyetoy(/bigBrother): people moving in canvas: synchronize user's icWebcam object in iC with user's screenPov so the person(mastermind) seeing all the users' icWebcams feels like it's behind the canvas when many icWebcams concentrate at same pov, display a distinctive grid to encompass them all 04 avril 2023: **'secret' pov: pov is so deep and far away that students can't try and find it they have to complete the previous challenge to unlock the associated [gotopov] there must be a mathematical formula to determine how much secret a pov is, with respect to another pov there must be a mathematical formula to determine how much secret a pov is, with respect to a canvas point (any scale possible) ***screenStamp is touchable: whole screen is like supervessel it may synchronize or not with its iC counterpart (if there's still one) **screenLock: screenStamp.isLocked == true ==> screenStamp is locked at its screen pos screenLock can allow screen effects: if screenStamp's original object is shaking, then screenLocked screenStamp will make screen shake shake could be left,right,up,down,low,high... ****ultra easy gotopov: screenLocked screenStamp touched by pathmade operator: screenpov now follows path path could be zDrawn, oriented... zDrawn texts like "Le chien du facteur..." could be easily written while screen is conveyed Main advantages : we can leave the path visible because, at any time, it only occupies a small part of the screen **(**)ui: screenStamp context: some ic operator may require context to work properly, this context could be the front screen example 1: there are 4 screenStamped objects: [banana, strawberry, apple, lemon] user clicks on a [random_from_context] button: a [[strawberry]] objects spawns in iC edu: pour les probabilités example 2: user screenStamps an image user starts drawing with a get-palette-from-context-image brush **screenStamp gotopov(==bookmark) you screenStamp an object and the screenStamped object is a [gotopov] to the pov you were in when you did screenStamp the original object remark: screenStamp [gotopov] should fade away when screenPov getting close to original object, because it would be overlapping ***lateCore: even old(==before coreification) pasted instances of obj now follow core edu: because we may almost always act before we think it's like a late refactoring **selection: select only _fully enclosed_ (standard selection) **selection: select everything fully or partly enclosed (shift + selection) ***composite: scroll through composite parts: default: breadth-first zIndexScroll allows diving in _composite child_'s parts (depth) (when there is composite in composite) ***load serial (==infinishute): how to merge current state with incoming state ? - inject here: infinishute__incoming.startingPov is now infinishute__incoming.currentScreenPov all incoming objects are adapted - keep original: all incoming objects keep their positions and scale, even though it visually collides with existing objects - let me choose: a big composite is made with all infinishute__incoming's objects and you put it where you want this would normally be the most comfortable solution and now, as it would have been too simple, one should manage zIndexes... ((and what about the icObj.id...)) but merging always require some attention - mark source? YES/NO we could add a read-only .incoming_source in all incoming objects so that we recall that they were imported - import as locked: all incoming objects are locked usecase: import context for kids to draw: import a house and a garden etc, and kids can draw their characters and objects **keyboardWheel: mash 3 adjacent keyboard keys in a specific order to emulate mouseWheel example: [A][Z][E], [A][Z][E], [A][Z][E]: scroll right (bold) [E][Z][A], [E][Z][A], [E][Z][A]: scroll left (bold) [A][Z][E], [Z][E], [Z][E]: scroll right (light) [E][Z][A], [Z][A], [Z][A]: scroll left (light) **pathDrawing: orientation: none/fixed/flowing: when enabling oriented pathDrawing, a little arrow over brush indicates the current orientation keyDown:Digit1: draw with flowing orientation(== the mouse move vector, as it updates with the drawing) keyDown:Shift+Digit1: setup fixed orientation (drawing is on pause while user chooses custom orientation) orientation may change nature in the path: flowing at start, then fixed, => this allows easy creation of very complex gotopov paths ((dev: shaking orientation...)) 05 avril 2023: **(*)deepFloodFill: floodFill objects with depth span: flood fill until deepest contours have been reached 2 flavors: composite of raster: floodFill object is a composite of standard(==raster) floodFills composite of vectorial: floodFill object is a composite of paths **gradient deepFloodFill: from color1 to color2, _depthwise_ workflow: 1. paint point with color1 at depth end 1 (say highest end) 2. paint point with color2 at depth end 2 (say lowest end) ==> depthwise gradient {from color1 to color2} is created the floodFill target may be: -the non-existing background void: a floodFill object is created -an existing object: the objects parts are updated with the appropriate colors variation: use existing other deep end color workflow When starting floodFill at deep end 1 with color1, depthwise gradient {from color1 to color_other_deep_end} is created. **(*)value-gradient path(==mutative path): a gradual mutation of object is operated along path example: value-assignment mutative path: path has {value_start:50, value_end:200} as conveyed object follows path, its default_assignable_property is set 50 then 51, then 52, ..., to finally reach 200 how to create it: 1. draw path 2. gradient floodFill path, but rather than with colors, this time with value_start and value_end **gradient for closed paths: circular gradient 1. paint point1 with color1 2. paint point2 with color2 the different paths linking point1 and point2 are gradient painted ***easy: freeDraw::autoAdd: if freshly drawn object, overlaps another object with same color, then it _creates new/is added to_ overlapped object composite => easy create tree structures, with nested composites edu: pour expliquer les arbres (de calcul par exemple): dessiner des noeux avec cette forme: ---o (une partie tige et une partie contenu) **composite::content: composite(content, arr_child) there are 3 parts: composite handle, composite content, and composite children **eduDemo: faire passer un arbre de calcul dans une boucle avec un simplifyTopLayer, pour voir les étapes de simplification successives **easy: path from deepable control points(==control circles): use point.scale and point.radius to control the width of the path pushing a point deep will make the curve go thinner around it **easy: path from colored control points: there is gradient for every pointA-to-pointB curve chunk 06 avril 2023: **composite:partUpdate: propertyUpdateEvent.bubbles propertyUpdateEvent(.position for example) if propertyUpdateEvent.bubbles == true, then parent composite will move too (and all other parts) if propertyUpdateEvent.bubbles == false, then only target part will move (propertyUpdateEvent.target) **composite:partUpdate: detach **selectFind: select all objects with same property / select all objects which make filter_func() == true spawn textField which waits for end-of-input (OK button or keyUp'd Return) **c-Scroll/-scroll on _icText selection_: change color/ of selected chars edu: pour insister sur des points importants en grammaire style-scroll: scroll between {bold, italics, underlined, stroked, superscript, subscript, ...} and of course, next typed adjacent chars keep style of previous char same for icMathNode ***freeDraw:adhesive(==sticky) joining: set joining object as tree root **freeDraw: single-sided tape adhesive: adhesive only on object it covers ***easy: (color) virus: intersecting a (color) virus object transmits the color edu: to create teams for example or more, subtly, to represent ownership or belonging edu: this allows tracing the "consequences" of one object (all "future-linked" objects will have virus color) 07 avril 2023: ***adhesive path: associate default movement to object workflow: 1. draw an adhesive path on an object (path.point__start on object) 2. when object is asked to move (by user click, or by any other trigger): the adhesive path is unboxed in place: the unboxed path is a non-adhesive copy of the path the object moves as conveyed by the unboxed path when done moving, the unboxed path is destroyed => we can associate many movements to an object **easy:rotation using adhesive: workflow: 1. if rotation.center is on target object: spawn adhesive rect on target object, with rect.center == rotation.center if rotation.center is not on target object: spawn adhesive rect with rect.center == rotation.center spawn adhesive joining rect and target object 2. rotate rect: it rotates target object wrt rotation.center **brushWidth:0 => draw points edu: demander aux élèves pourquoi on ne peut pas tracer une ligne avec cette brosse (infinité de points) **adhesive::only small drops of glue: only make path adhesive when necessary (like zIndexDrawing) ***pin (==adhesive _point_): to easily specify rotation center => easily create articulated object when alt-moving an articulation: other parts move to satisfy constraints => freeDraw while holding articulated object draw circle: freeDraw while holding free end of segment which other end is pinned **pinned part / locked part: trajectory of object should satisfy constraints along path edu: create clock with pin + circle-path pathmade **easy: min-max segment: draw segment that can only vary in [min,max] range 1. draw min segment 2. draw max segment 3. segment is now living in [min, max] range edu: min-max segment + trace : montrer des ensembles de points **gm:challenge:tables: clock-shaped: layout: a clock with [[x 1]], ..., [[x 12]] operators at the center of the clock: center-top: [target] center-bottom: initial (== [[1]]) edu: this allows working with tables and with clock usual number positions **easy: sizer: color virus triple-object: this is a touchSlot with 3 virus colors: if touching too-big object: object is colored red if touching right-sized object: object is colored green if touching too-small object: object is colored blue **icObj.type = "metric": adjustable segment + icMathNode showing its length workflow: 1. draw a segment and input its length 2. then when resizing the segment, the length icMathNode autoAdjusts **easy: relative-sizing of objects using mother metric / child metrics workflow: 1. create metric ("mother metric") then two cases: 2. type in size => child metric with corresponding correct-length segment is created 2'. draw segment => child metric with corresponding icMathNode is created **c-scroll: transparent color **easy: set image bgColor via c-scroll (add bgColor layer to img) **easy: set image tintColor via c-scroll (apply filter to img) **easy: copy freeDrawing composite as image to paste in paint.net ***adhesive floodFill: put together all that's been floodFilled **edge-scroll: E.mouseWheel: change object's edge width (could be negative) because edge-growth is not the same as scale-growth **freeDraw:erasing (==death stroke): workflow: 1. keydown ².X.mouseLeft: freeDraw ErasingFreeDraw obj 2. any object overlapped by ErasingFreeDraw obj is erased 3. ErasingFreeDraw obj is removed **easy:punch hole eraser: erase using any freeDraw object as overlapper: workflow: 1. select freeDraw obj 2. keyup ².Suppr: any object overlapped by freeDraw obj is erased =>edu:drawing: create punch-holed image and ask user to fill the gaps with their own drawing **easy: image::erase pixels (floodFill-style): keyup ².X 08 avril 2023: **icObj.type = "analyzer": the rect is filled with a representation of the analysis' result of what's below example: fraction rect color fraction: show different rects representing the fraction of each color present below object count fraction: show the different types of objects contained in the rect with their associated count pizza: 3, yellow car: 2, blue car: 7, banana: 9, ... edu: pour faire évoluer des situations de fractions **a-scroll: animation scroll: control anim progress with mouseWheel **a-path: path.start is anim.progress=0 and path.end is anim.progress=1 => path does not have to move, it can stay in place for seconds **composite of animated: [[composite of animated]] * [a-path] => all parts animate (individually) ***easy: morphological animation: extrapolation of transformation between 2 freeDrawings 1. draw freeDrawing_state1 2. draw freeDrawing_state2 an animation object is created with freeDrawing_state1 at anim.progress=0 and freeDrawing_state2 at anim.progress=1 ***icObj.move animation (to create animated object): icObj.move is an animation contained inside object animated object may have many different moves: icObj.move1, icObj.move2, icObj.move3, ... outer move: icObj.move changes position of main object: [icObj.move(go_left)] results in icObj being translated leftwards [icObj.move(go_left)], [icObj.move(go_left)], [icObj.move(go_left)] results in object being translated 3 times leftwards inner move: icObj.move only moves 1 part: the main object keeps same position but one of its parts moves *crossword-in-crossword (doubleObject): hint sentence for cell at top level is revealed wrt completion progress of cell's deep-level inner crossword 19 avril 2023: **snapslot on screenCanvas: autoscreenstamp **screenstamp puzzle : puzzle gets harder and harder as screen gets covered, well, not that much as what is visible is still infinite... ***temporary context: scroll iC and screenCanvas asynchronously/synchronously: screenCanvas can be used as context, and then we can move elsewhere in iC, and reuse that context in another situation edu: math: this allows reusing the same numbers, in different situations ***easy: keyframed morphological animation : draw keyframes and animation is autoCreated if there are multiple elements in each frame, keep same order **pathmade:resize: 1.Draw square path 2.Copy paste 3.Resize smaller Now one can move in a mini square path edu: pour faire comprendre les parametres (path=f(scale)) ***(*)reverseCanvas: any object created in IC has a reverse counterpart if erased, a grey 'shadow-stumb' always remains => easy draw and animate "champ/contrechamp" => easy 2-sided printing => easy playing cards creation **comb+zIndexScroll(+colors): => easy creation of rotating spirals (scoubidous/vortex) **zindexDrawing : allow Z around Y around X (closest zIndex enveloppe) **private space: this area is private, you can't see what's in there icObj.type = nail temporary virus color when setting depth of nail (colored objects have lower zIndex) allow depth setting of iCanvas.nail even when seeing reverseCanvas *color By numbers: for kids to use mouse : pick color, floodfill, pick color, floodfill... and to demonstrate cores : floodfill on core => all instances are floodfilled **(*)povlock/relativePov : to observe people on moving planet many perspectives on the same canvas: perspective cavalière ici autre perspective cavalière là perspective isométrique ici ... the canvas is not 2D, not 3D, it is a space available for every representation ***easy: povScroll(==scroll-controlled gotopov): no duration to input, animation progress is controlled via scroll chain-path: composite with a chain of parts : each part moves to next position (this way we can create revolving photos animation) (idée pour rétablir de la convivialité à table: le portable ne fonctionne pas quand il est proche des portables des proches (repas familial) si tu veux utiliser ton portable, tu es obligé de quitter la table et donc d'aligner ton absence d'attention avec ton absence physique ***push bomb (easy layout user action): everything in circle/rect is pushed out, and the surroundings too, everything following 'smoke lines' (best outwards paths for everything to stay coherent (like a fluid)) **animation: bouillonnement(==dynamic and eased, push bombing) : monter les idées devant, en pousser d'autres à l'arrière etc. **layout: topology of relationship: when X is at screen scale, if Y is topologically related to X, then Y is 'frontsided' (==brought to X.homeScale, the surroundings being downsized) so that Y is easily accessible via panning from X this makes a canvas with a specific look and feel for every new _idea_ (!= pov) that has gained focus easy: line-scroll: scrolling while creating line changes its shape the scroll set is infinite: one side is composed of sine curves of increasing frequency the other side is finite and composed of more casual shapes like half-circle, dashed, etc. line can then be fine-tuned using control points zIndexPicker: set brush zIndex to picked object's zIndex or -Infinite if clicking on empty canvas 20 avril 2023: ***(*)easy: customizable operators: inner-context based: this operator spawns a geminiShade of touched object inside it and operates on it, along an inner path touched object is only updated when all inner operations are completed (==when geminiShade is at inner path's end) the inner operations' process should be close to instantaneous, but it could go slower when examining/developing operator's insides (~~debug mode) workflow: 1. spawn customizable operator 2. dive into it (facade disappears and operator's insides appear) there is a customizable path in it (via controls points + branches can be added) 3. put operators on the path there is a [dummy-run] operator which allows easy development: it runs the program inside [dummy-run] has a toggle next to it to control its .isMutative property: .isMutative == true => touched object is mutated when gemini shade is at end of path 4. customize facade (write operator's name) customizable operators have a "C" displayed on their facade to indicate they are customizable example: [customizable_operator]: [---->----[x 4]---->----[+ 1]---->----] [[5]] * [customizable_operator] = [[21]] *physics:[gravity], [viscosity] then one could create a customizable operator with gravity and physics inside it to create a random number generator for example using a marble and nails (code and graffiti: since everything is display, code could now free itself from the starkness of text files comments could be paintings a manual entry could be a interactive trip **(*)easy: list-scroll: mutate selected object to next element in list ('< >'Key + mouseWheel) ux: to always keep hand on mouse element(of collection): selected([[]]) + '< >'Key.mouseWheelUp = selected([[]]) mathNode: selected([[25]]) + '< >'Key.mouseWheelUp = selected([[26]]) operator: selected([+ 1]) + '< >'Key.mouseWheelUp = selected([+ 2]) word: selected([[]]) + '< >'Key.mouseWheelUp = selected([[]]) **(*)ultra easy: copy of existing: list-scroll + _canvas is pool_ selected([[]]) + '< >'Key.mouseWheelUp = selected([[]]) => so user can type a lot of words on the canvas(as when brainstorming) and then find them back very easily edu: pour fabriquer des équipes par exemple, après qu'on ait déjà collé les noms depuis un logiciel de tableur selected([[]]) + '< >'Key.mouseWheelUp = selected([[]]) edu: pour réinvoquer facilement des expressions littérales déjà écrites screenCanvas could also be used as pool **(*)easy: utility operator: element of {utility operators} collection scrollable operator is marked with "↑↓" on its facade shift.'< >'Key.mouseWheelUp: mutate to next utility operator utility operators: {[+ 1], [- 1], [x 1], [/ 1], [^ 1], ...} **easy: platform utility operator: element of {platform utility operators} collection 21 avril 2023: **zIndex coarse layers: allocate zIndex range to object type example: (in a board game context) 1000-2000: world tiles 2000-3000: character pawns 3000-4000: equipment 23 avril 2023: **easy: anim: freeDrawing animation: freeDrawing making can be replayed from nothing to a set of paths **(*)easy: anim: build branched freeDrawing animation using time sync (à la SuperHot) 1. draw mother freeDrawing animation (==draw a line) 2. use a-scroll to freeze mother animation at desired timestamp (==at progress:0.4 for example) 3. draw time sync'ed child freeDrawing animation (==draw a branch) SuperHot effect: when drawing child animation, mother animation replays in sync brush move (moving is the only thing that makes time flow) relativeSpeed (of animDrawing): child animation drawing uses its own timescale: if child's animDrawing relativeSpeed is 0.5, then mother anim replays x2 faster when drawing child => when replaying: child will start drawing at progress:0.4, with its own speed, to be fully drawn at progress:0.57 for example **(*)easy: anim: branched freeDrawing animation using time sync + coreification: grow many branches at the same time **tutorial view: show keyboard keys and mouse buttons/wheel usage when realizing something on the canvas screenCanvas hosts keyboard view and mouse view *keyboard is an icObject (à la Press Ctrl): touching a key presses it ***hard path: this path cannot be crossed: trying to cross it while drawing results in drawn path following hard path's border when following hard path's border, cursor is temporarily disjoined from brush tip straight line is drawn when cursor can finally be met again partial hard line: hard line can be crossed if steering strongly enough crossDown hard line: hard line is preferentially crossed down if steering strongly enough ***underdog brush: this brush considers all the surrounding objects as "hard" => this brush cannot overlap a thing edu: comme quand on demande aux enfants de ne pas dépasser quand ils font des coloriages ***underdog kick: toggle brush.isUnderdog **(*)bleeding path: changes to current freeDrawing(brush) when crossed bleeding color: this path changes brushColor to bleeding path's color when crossed bleeding brush apparentWidth: this path changes brush apparentWidth to bleeding path's apparentWidth when crossed **sticky path: sticky path joins to current freeDrawn object when touched 24 avril 2023: **freeDrawing: path zoom level quantization: when freeDrawing.scale in zoomLevel.range__capture, zoom is temporarily not following zScroll, freeDrawing.scale sticks to zoomLevel.scale when freeDrawing.scale out of zoomLevel.range__capture, cursor is met and followed back again => entre deux palliers, il y a un tracé libre edu: pour facilement créer des structures de fonctions, sans avoir à utiliser un object attractor **pattern path: scaleless path (when replayed, its starting scale adapts to current scale, and we only care about _relative_ changes) **(*)path invocation: leave freeDrawing control to the machine, for a while workflow: 1. enter freeDrawing 2. draw a bit of something 3. invoke path: while ².mouseLeftDown: KeyW.mouseWheel to select path (preview of result is shown), release KeyW to launch path drawing path drawing may be instantaneous or not (user's choice) ** (we may consider for example the collection of all existing paths on canvas ("canvasPool")) this could be used to spawn already-drawn characters when freeDrawing text (font={drawn chars}) 4. continue freeDrawing where invoked path has left it (user is still ².mouseLeftDown) fun: pouvoir injecter des coeurs en mode kikoo, pendant que l'on dessine un truc 2 flavors: oriented path: path follows freeDrawing's last displacement vector(dx) as its first displacement vector non-oriented path: invoked path is drawn 'absolutely' **(*)pattern path invocation edu: "draw music" easily it's all the more powerful as existing music bits (==existing paths) can be injected as parts in a more complex bit and so on edu:math: easily inject variable segments fun: insert ultrasmall scale signature **random (pattern) path invocation *Drawer's mode: mouseWheel zoom/dezoom factor is lighter/softer *Rotaful mode: all paths are oriented by default: rotation is the way 25 avril 2023: (apprendre à jouer de l'iC comme on apprend à jouer de la guitare (étant donné que c'est _une pratique de l'instant_) **cursy pathmade: pathmade retriggers at path's end, so that object moves away [uncurse] operator stops pathmade recursion ***manual draw / auto draw: be drawing something manually while something else is being drawn automatically un peu comme en cuisine: lancer un dessin automatique de vagues, pendant que l'on fait les nuages à la main, puis arrêter les vagues (comme on éteindrait le feu)... **easy: path invocation: invoke _currently drawn path_ ==> easy repeat **(*)freeDrawing: double view (~~pov screenStamping): big picture painting view, with opacity 0.4, is on top to allow zoomed-in freeDrawing while keeping an eye on the zoomed-out result ².Shift.D: set double view's top view (use currentScreenPov) ².D: toggle double view display **(*)freeDrawing: dual view: user has 2 screens: display big picture painting on screen1 and working (==zoomed-in) screen on screen2 (**AI: complex object creation (by AI) from image import: example1: import a house image: front door is automatically made a door double object windows have transparency example2: import a toy truck image: wheels are automatically made rotate-able objects toy truck is automatically assigned a [forward] button which makes the truck roll forward **freeDrawing + list-scroll: change to next brush *spawn divided segment with ².KeyW() eduDemo: powers of 10: for every power of ten scaleRange: spawn divided segment + color beacon **(*)split _selected_ object with "'split' + KeyW()" segment: |--------| * [split(2)] ==> |----| |----| icMathNode: [[256]] * [split(4)] ==> [[64]] [[64]] [[64]] [[64]] image: [[image]] * [split(3)] ==> [[img__left]] [[img__center]] [[img__right]] path: split in parts according to curvilinear abscissa ... **zIndex floodFill: floodFill at particular zIndex (some curves may be open/closed wrt zIndex) example: there is a closed curve at zIndex:100 there is an open curve at zIndex: 0 zIndexFloodFill(100) with cursor in closed curve hole will result in floodFilling the hole of the closed curve zIndexFloodFill(0) with same cursor will result in floodFilling everything but open curve and closed curve will stay in front 27 avril 2023: *change selection border color when "soleSelecting"(==when selecting only selected object (not the whole parent composite)) reminder: keyDownToggle(Alt) for soleSelecting when something selected (alt is for "alteration") **eduDemo: inverse operator: easily create reciprocal operator [x |-> 2x - 1] * [inverse] = [x |-> (x+1)/2] *easy: platform drop: when platform-dropping obj1 on obj2, obj2 is temporarily acting as platform wrt obj1 when obj1 is held again, obj2's duty is cleared 28 avril 2023: ***zIndex is a position: allow same zIndex for multiple objects => no more braintwisting when cloning zIndex-ful composites: icObj_cloned.part1.zIndex == icObj_src.part1.zIndex 3 flavors: collision is bad: show "collision display" when two objects with same zIndex are overlapping collision is natural: color(collision) = avg(color1,color2) or more precisely: color(collision) = avg(color, weight: (nb_times color is drawn at this pixel) / (nb colors drawn at this pixel)) same stroke can cross the same pixel multiple times => this may give a "true paint feeling" collision is spectral: relative weight is based on distance to (closest-to-user integer zIndex + 1) example: obj1.zIndex = 34,3 => distance(34,3 ; 35) = 0.7 obj2.zIndex = 34,6 => distance(34,6 ; 35) = 0.4 weight1 = 0.7 / (0.7 + 0.4) weight2 = 0.4 / (0.7 + 0.4) color = color1 * weight1 + color2 * weight2 *icObj.type = "tearable_composite": move handle: all parts move move part: part is no longer in composite (it has just been torn off) 29 avril 2023: **[structure]composite is a key: composite(array of(colored rect with .isMobile = true)) completed challenge# gives the relative position of colored rect# (user places composite handle in handle snapSlot and moves colored rect# to its correct position) remark: if(colored rect with .isMobile = false), moving rect can still be done via alteration (see: alt is for "alteration") when all challenges are completed, the key is correctly 'realigned' typical key: composite16 (4 x 4 colored rect grid) which will then change to something that is not a grid variant: personal progress key: (no instant feedback on error) if student gives wrong answer to challenge, displayed relative position of colored rect# encodes the percentage of error of the answer at the end of all challenges, key encodes student's ability to complete the challenges game structure: composite keycode doors: door has a keycode reader: door opens when keycode is correctly 'aligned' (**(*)easy: scale-aware copy/paste 1. when copying, store scale__copy 2. when pasting, paste wrt scale__paste and scale__copy if you paste when zoomed in, pasted clone will be "smaller" than original **[structure]cloning site: snapSlot where object copy can be done (when disabled elsewhere) variant: where object copy can be done _once_ variant: single-use cloning site: only one cloning can be done player has to think carefully before cloning object *[relative sizer]: resize selected mathNodes wrt their value selected({[[1]],[[10]]}) * [relative sizer] ==> [[10]] appears 10 times bigger than [[1]] **adhesive: duct tape: putting duct tape over an object and the canvas makes it stick to canvas (.canBeMoved == false), while duct tape is on it *icObj.type = "visualArray" layout: indexes: 0 1 2 3 4 content: content0 content1 content2 content3 content4 when deleting content3, content4 automatically moves under index:3 *icObj.type = "visualDict" layout: key content "key1" content1 "key2" content2 when deleting key1, key2 and below automatically shift up 30 avril 2023: **dryScroll (=="zoomAdjustScroll"): KeySpace.mouseWheel updates screenPov without zScrolling selected object typical usecase: show what's inside a big object, zoom out to transform it and zoom back to show what has changed **possessive composite: part clone still belongs to parent composite **easy: needleStroke: ².Shift.mouseWheel: draw a needle segment joining circle1 at scale1 and circle2 at scale2 moving circle2 at scale2 while leftMouseDown updates needleStroke nicely (needle is kept straight) **easy: save screenPov as image: Shift.S *freeDrawing:: lock freeDrawing mode: ².CapsLock: to allow user to reach otherwise unreachable keyboard keys ².CapsLock to unlock 01 mai 2023: **ultra easy: create composite of clones: paste clones while in drawing mode enterDrawingMode() could be seen as enterCreateSomething() *easy: color lightness gradient while zIndexDrawing: auto darken when pushing deep 02 mai 2023: (*inception fan made art: the dream is collapsing **eduDemo: powers of ten: use small/big duo to easily zScroll at next power of 10 scale small/big duo is composed of 2 objects: small is at scale 10^k and big is at scale 10^(k+1) workflow: resize smallBig_duo(n+1) so that smallBig_duo(n+1).small.length == smallBig_duo(n).big.length *measure: scale distance: 2 flavors: A.absolute_scale / B.absolute_scale A.absolute_length / B.absolute_length in our everyday lives, it would be wise to get used to this, in order to have a better grasp on the world (0 ? icObj can't have 2 parent composites ? ? is there something to dig around that ? *freeDraw::copy/paste in freeDrawingMode ***easy:F-scroll: (== shapeScroll) scroll through utility shapes, or canvasPool shapes for object spawn as well as for object mutation **easy:F-input: F.numberTyping() or F.numberTyping() it's like a textConstructor but the typing part is not handled by the object (numberTyping is handled by iC) (fun: atelier de stylisme: créer des vêtements, des colliers, etc. 04 mai 2023: **calligramme: tout les objets sont des assemblages de textes, exemple: ----vaisseau ----spatial ultra ====missile ----rapide ----et puissant scale0: planète Zorgon III scale1: spatioport Wilkinzer Aerold scale2: cafétéria scale3: café (l'hygiène n'est pas une obligation en soi, mais il n'est pas possible d'édifier quoi que ce soit de grand sans hygiène il faut que les choses soient en place, il faut que les choses soient faites dans le bon ordre autrement, on reste au stade des petits essais, des petits riens fragiles, vite effacés par le vent **(*)batch paste(layout): central symmetry: objects are pasted forming a round 1. copy object 2. initiate batch paste .B("c5") 3. click on chosen center => src object stays in place while 4 bclones are placed wrt central symmetry translation: objects are pasted forming a line 1. copy object 2. initiate batch paste .B("t5") 3. click on pointA, click on pointB bClone#0 spawns at pointA, bClone#1 spawns at pointB, bClone#2 spawns at (pointB + vect(A,B)), etc. homothety: objects are pasted forming a "voyager" line 1. copy object 2. initiate batch paste .B("h5") 3. click on (pointA, scaleA), click on (pointB, scaleB) bClone#0 spawns at (pointA, scaleA), bClone#1 spawns at (pointB, scaleB), bClone#2 spawns at (pointBScaleB + vect(ASA,BSB)), etc. translation with alternation: ("translationABAB") 1. copy object 2. initiate batch paste .B("tAB5") 3. click on pointA, click on pointB => A B A B A +: ABCABCAB... +: any transform with alternation... ***generator-bound instance object: each new clone of this object is generator.yield() => batch paste of that object is interesting example: generator:random: [[random obj(ufhzer)]] * batch_paste(4) => [[random obj (kuhrt)]] [[random obj (irytr)]] [[random obj (njbvf)]] [[random obj (zazeff)]] generator:counter: [[counter obj(0)]] * batch_paste(4) => [[counter obj (1)]] [[counter obj (2)]] [[counter obj (3)]] **(*)easy: smart batch paste: given a copied selection of multiple objects, batch paste transformation is inferred by the system example: copied are 2 [[A]](almost the same object), one has scaleSmall and one has scaleBig => batch paste will infer an homothety example: copied are [[A]] and [[img]], both with same scale => batch paste will infer a translation with alternation **(*)easy: smart batch paste::inferred generator: [[pov5]] * batch_paste(3) => [[pov6]] [[pov7]] [[pov8]] *poly operation: object in selection are individually operated on, _at the same time_ [[obj1]] ------->---------- [op1] ------->---------- [[obj1']] [[obj2]] ------->---------- [op2] ------->---------- [[obj2']] _group selected_ dragged to touchSlots **function::arg#n touchSlot: [["abc"]] ------->---------- [ [arg#0: str ] ] ------->---------- [["abcabc"]] [[2]] ------->---------- [ [arg#1: number] ] ------->--- arg touchSlots: func triggers when all populated **remote operator invocation: make as if touched by chosen operator 1. select object 2. "B"(r_op) 3. click on chosen operator on canvas => [[selected object]] * [chosen operator] happens **batch remote operator invocation: make as if touched by chosen operator, repeatedly "B"(r_op5) batch5([[7]] * [+ 1]) = [[12]] **(*)anything invocation: system inputField acts like textConstructor (with more following steps) circle invocation: 3 flavors: center and point: "B"(.C) then click for center then click for point center and radius: "B"(.C5) then click for center (radius is 5) point and point: "B"(.CAB) then click for pointA then click for pointB edu: Geogebra mon amour *easy: simple utility operators for everyday use: [["AZERTYUIOP"]] * [lowercase] = [["azertyuiop"]] [["azertyuiop"]] * [uppercase] = [["AZERTYUIOP"]] ... (*reverse screen + duct tape: intricated front/reverse/front/reverse/... stickiness when duct tape overflows, overflowing sticky part is reachable on reverse side (la vitesse de la scalemière est une constante...: invariance par changement d'échelle / quantité conservée ? (l'information ? le "contenu")) 05 mai 2023: ***(*)buildOrder: when adding adhesive to an existing object, keep a counter on which building step it was the object upon which adhesive is drawn is called its support buildOrder is a position: many adhesive can have the same buildOrder 2 flavors: standard adhesion: newlyDrawn.buildOrder = support.rootSupport().buildOrder__max() + 1, and shift other buildOrders accordingly adhesion by alteration of support (when drawing over support with support.buildOrder < support.rootSupport().buildOrder__max() and iC.isAltering): newlyDrawn.buildOrder = support.buildOrder + 1, and shift other buildOrders accordingly parallel adhesion: consecutive adhesions to a support are assigned same build order adhesion to a zIndex-hidden support is possible (low zIndex): freeDraw::checkForSupport() is zIndex-aware brush has .zIndex:50, support has .zIndex:10 and is hidden behind object with .zIndex:100 ==> support with .zIndex:10 will be chosen for adhesion adhesion to support containing transparentColor is possible: freeDraw::checkForSupport() is transparentColor-aware transparent is a color like yellow or red whereas voidTransparent is void dev: use composite(content, arr_child) to create 1-part composites ***buildOrderScroll: for a composite, display only objects with .buildOrder in [0,buildOrderScroll] => when scrolling the composite gets more and more complex edu: pour expliquer des séquences de déduction logique edu: pour expliquer des séquences de construction (comme les lego) ***ultra easy: adhesive/buildOrder: set adhesive on when entering freeDraw with cursor over an existing object **weight-based "translaturn" (animation): part with a big weight will be more difficult to move, object shape is invariant 1. assign weights (could be done via a scroll) 2. grab a particular point of object and drag example: 1. big weight is put on top, small weight is put on bottom 2. when grabbing middle and dragging: top moves a bit, bottom moves a lot **2paths-based "translaturn" (animation): draw 2 paths, one for each object end, object shape is invariant the drawn paths do not have to keep object shape invariant, they are a draft input for the system system will then compute a field to move the object, always keeping its shape invariant variant: object scale changes, though object shape is invariant (deep paths) 06 mai 2023: **[buildOrder++] operator: touched object will display one more buildOrder layer example: children story: grow a tree by having it touch a [water] operator (which is a disguised [buildOrder++] operator), repeatedly **editOrder/editOrderScroll: scroll through successive edits of icText eduDemo:math: logic with discrete paths: example: 4 x 4 grid of colored rects 2 entry points 1 exit point directed arrows which allow moving from rect to rect student has to say if statement is true or false: if we entered in red rect, then we passed through the yellow rect if we entered in red rect, then the length of our journey is even student has to say if reciprocal statement is true or false **(*)adhesive: drop composite grid over composite grid: create "zipped" composite grid (==composite grid with duos) **icObj.type = "placeholder": this object mutates to assigned "true" object [[placeholder]] * [assign: [[1]] ] = [[1]] [[placeholder]] * [generator:random_string()] = [["fiuzezef"]] **icObj.type = "typed_placeholder": this object mutates to assigned "true" object, _when type is correct_ [[placeholder(string)]] * [assign: [[1]] ] => nothing happens [[placeholder(string)]] * [generator:random_string()] = [["ieohrezr"]] **composite grid of placeholders X generator: [[composite(placeholder1,placeholder2,...)]] * [generator:random_number()] = [[composite(number1,number2,...)]] remark: a certain arrangement of (typed_)placeholders could be called a "structure" 07 mai 2023: **(*)homeScale lock/unlock (toggle): Digit1.space => keep "small brush" while dezoomed 1. draw while zoomed-in 2. lock homeScale 3. zoom out 4. draw while zoomed-out: new strokes appear same-width'd as zoomed-in strokes => copy/paste with original size while dezoomed homeScale lock, copy, zoom-out, paste, homeScale unlock **(*)screenPov lock:allows freeDrawingZScroll control of brush but screen scale does not change ***screenPov lock::elastic homeScale lock: allows freeDrawingZScroll but homeScale resets to locked value on leftMouseUp 2 flavors: homeScale lock was set before screenPov lock: elastic homeScale is locked homeScale homeScale lock was not set before screenPov lock: elastic homeScale is screenPov.scale => (ultra)easy: create brand logos **zIndex lock/unlock (toggle): ².Digit2.space *alteration of composite1 in composite2: 2 flavors: soft alteration: move composite1 along with its parts sharp alteration: only move composite1 *easy: "forget the rest": erase non-visible parts of selected object (after a buildOrderScroll) 1. select "built" object(==object with buildOrders) 2. buildOrderScroll till object display suits you 3. Shift.Suppr: what you see is what you get: all non-visible, higher-buildOrder parts are removed 08 mai 2023: **easy: neighborScroll: selected part is root neighbor: get connected parts icObjs.neighbors(level1) = (icObj.parent)(optional) + icObj.parts scrolling up/down gives more/less neighbors: it spreads top and bottom of composite hierarchy **selection root/workingSelection: example with neighborScroll: selection root is root neighbor, workingSelection is neighborScroll result **easy: particle draw workflow: 1. draw simple particle (==rect or circle) moving 2. enrich particle via adhesion a bit more complex: 1. draw simple particle (==rect or circle) moving 2. a-scroll(==step through time steps) and, at chosen progress, enrich particle: - via adhesion - via buildOrderScroll (== chose buildOrder__max corresponding to keyframe) 3. automagic morphological animation ensures transition between keyframes - morphological(buildOrderScroll:1 --> buildOrderScroll:2) = interpolate buildOrderScroll:1.5 etc. built part is gradually growing to its final shape 09 mai 2023: **freeDrawing::plastic stroke/ elastic stroke freeDrawing can bear a little deformation caused by dragging a point inside it 2 flavors: plastic: deformation is permanent elastic: freeDrawing goes back to its original shape when releasing point deformation is a morphological interpolation rigidity can be painted, using a rigidityBrush, over the plastic drawing so that some areas will suffer less from deformation (to the extent that some 'protected' parts won't be deformed at all) **easy: buildOrder gradient: from buildOrder:1 to buildOrder:10 workflow: 1. start drawing on support with buildOrder:1 2. stop drawing on support with buildOrder:10 => freeDrawingObj will have buildOrder:1-->10 this object will gradually grow when animating buildOrder fun: growing tree animation **draw in time: time is a position: ?KeyF1 KeyF2? to control time position workflow: 1. start drawing with .time:0 2. stop drawing with .time:16 => freeDrawingObj will have .time:0-->16 this object will gradually grow when animating time it's possible to draw backwards in time (start at .time:7 and stop at .time:2) **icObj.type = "time": time, encapsulated adhesive drawing with time as support will begin a time-friendly drawing session ?KeyF1 KeyF2? can be used to move in time **freeDrawing::relief brush: multiple layered zIndex strokes when drawing example: 555555555555 ( 555555555555) 666666666666 ( 666666666666 555555555555) 777777777777 ( 777777777777 over 666666666666 over 555555555555) 666666666666 ( 666666666666 555555555555) 555555555555 ( 555555555555) zIndexScroll is still possible: reliefbrush(5,6,7).zIndex = 10 => reliefbrush(8,9,10) relief brush can have, for example, 10+ zIndex layers => create penetration effect (tubes, tentacles, ...) 10 mai 2023: *freeDrawing::BufferBrush: brushColor = mean color on buffer path (moyenne glissante) => like a finger effect workflow: 1. set starting buffer path 2. buffer path follows brush cursor path remark: a good buffer path length would be brushWidth * 2 *freeDrawing::DelayBrush: brushColor = color of delay path starting point (toujours un truc glissant) workflow: 1. set starting delay path 2. delay path follows brush cursor path *layout<->dataSource binding using coreification: workflow: 1. build layout with object 2. coreify layout objects 3. copy/paste layout objects in a dataSource area ==> data objects 4. updating data object in dataSource area automagically results in an updated layout object and reciprocally 11 mai 2023: **compose_with_adhesion(obj1, obj2): composite(obj1, obj2) will be created, and, if needed, will replace obj1 or obj2 in their composite hierarchy example1: composite1 = composite(A,B) compose_with_adhesion(B,C) ==> composite2 = composite(B,C) ; composite1 = composite(A,composite2) example2: composite1 = composite(A,B) composite2 = composite(C,D) compose_with_adhesion(B,C) ==> composite3 = composite(B, C) ; composite1 = composite(A, composite3) ; composite2 = composite(composite3, D) melt composites: dev: obj.compositeId -> obj.arr_compositeId A.arr_compositeId = [composite1.id] B.arr_compositeId = [composite1.id] C.arr_compositeId = [composite2.id] D.arr_compositeId = [composite2.id] composite3.arr_compositeId = [composite1.id, composite2.id] => composite3 has 2 root composites: moving composite3 will move both moving B: 2 flavors: only-my-branch move: B has 1 root composite: composite1 => moving B will move composite1 STOP => only composite1, A and B will move contagious move: B has 1 root composite: composite1 => moving B will move composite1, moved composite1 will move A and composite3, moved composite3 will move C, moved C will move composite2, moved composite2 will move D => all objects will move 12 mai 2023: **(*)easy: clones: freeDrawing::cloning paper: drawing over cloning paper yield 2 objects: the original instance and the cloning paper's instance cloning paper's objects are adhering to it variant: colored cloning paper: colored cloning paper(red) will yield red clones => edu: fabriquer des clones de différentes couleurs **freeDrawing::tracing paper = cloning paper with .opacity=0.4 **(*)easy: freeDrawing::cloning stroke: 1. in freeDrawingMode, before leftMouseDown, numberInput how many strokes you want: 2. draw the object you want 3. overlapped copies have been created it's as if strokes, in a 'tower' configuration, each for a storey, were made remark: it's like a comb stroke but all spikes are at the same spot *traversing backlight source: object with .isLightTraversable:true over backlight source will reveal its internal organs ***(*)adhere (==operateOnSelected__adhere): selected object is adhered to underlying _support(s)_ (compose_with_adhesion) 2 flavors: marked adherence: when adhering object1 to support, object1 is marked so it can easily be unadhered (object1.supportId = support.id) OR an adherence-type composite is created: composite(parts:[object1], content:support) with .cType="adherence" irreversible adherence: when adhering object1 to support, object1 is not marked so it cannot be unadhered (it can still be removed from parent composite, but it's way more difficult) smart adhere(==hard adhere): system infers the best support for each sub object to adhere to (==many adherence points) (when performing adhere() with multiple selected objects, or with composite) easy: clone_adhere (==stamp_adhere): keep selected object under mouseCursor and make clone adhere to support alterative adhere: adhere while .isAltering wand_adhere: adhere() after a wand tool: glu all selected objects together easy: terminal adhere: if no support registered when starting drawing: check if adhesion is possible at drawing's ending point easy: join adhere: adhere(==at start point) + terminal adhere(==at end point) ? what happens when adhering to oneself (loops) ? ***unadhere: remove selected object or its ascendant composite from where what it was adhering to **icObj.type = "objectSearch": drop object__part on it ==> references to all objects containing object__part will appear below it 2 flavors: gotopov links: a gotopov link for each object containing object__part will appear below it clones: a clone for each object containing object__part will appear below it edu: we can ~tag objects using adhere() with the same drawingObj (a symbol for example), and then we can them all back 13 mai 2023: ***(*)imobjgect: deformable image to suit your needs: (==svg on steroids): between an image and a concept (original idea: "cette structure qu'on appelle sourire") imobjgect library: collection of imobjgect for common drawn things: (grin, glasses, hair, clothes, ...) **movemento composite: everyone moves wrt its homeScale example: context: part1 is a scale1 part2 is a scale2 dragmoving part1 of 100 units ==> part2 is moved of scale2/scale1 * 100 units *telescopic pen: movemento composite + freeDrawing: handle and lead drawing something with pencil handle at scale1(big) draws the same thing at pencil lead at scale2(small) dev: quite a work to do to materialize the moving telescopic pen (each scale moves differently) **wand altering: altered object is set of wandtool-selected objects **variable segment::add_part(): select end point and drag a continuation segment on same line 2 flavors: constant continuation: continuation segment is a constant example: [----x----] ==> [----x----|------5------] variable continuation: continuation segment may be related to adjacent segment example: [----x----] ==> [----x----|-0.5x-] edu: show the effects of variations of x: variable segment will change, constant segment will not change 14 mai 2023: **(*)easy: mathnode: adhere is assign, unadhere is unassign adhere([[2]], [[x]]) ==> x is assigned value: 2 afterwise, unadhere([[2]]) ==> x is not assigned any value if adhering to [[x]] in an expr containing multiple references to [[x]] => assign [[2]] to each [[x]] **slice VS adhered: when slicing the object where adhesion occurs, adhesion is broken 2 flavors: soft slice: part which was cut in 2 is kept hard slice: part which was cut in 2 is destroyed *zIndex-slicer: a rect which can slice zIndexful objects, like ham **[physics] .isPushable: when another object collides, object is pushed **(*)oriented drag: dragged object orientation changes with drag direction => sweep(harvest) objects by pushing them with(in) a C-shaped freeDrawing **[physics] canvas is a fluid: velocity of objects is tamed down by viscosity *everchanging bg color: materialize bg fine tune to get comfortable update rate ***colors, they are a-changing! => varying colors colorPicking a varying color allows to draw stroke which color is varying but synchronized with colorpicked object 2 flavors: looping: color variation has a period everchanging: color variation is not periodic edu: show different heartbeats edu::maths: show [[6]] = [[2]] * [[3]] by combining [[2]].heartbeat and [[3]].heartbeat (EN: least common multiple) (FR:"ppcm") (**color::color is func: color = f() 15 mai 2023: ***edu::maths: rainbow pulsating numbers: visualiser l'écriture scientifique rainbow color spectrum for [10^n,10^(n+1)[ always the same rainbow, so that student finally gets that 9,90,900,etc. are 9 x 10^ (same 9, different powers) 2 flavors: vertical rainbow bars (coloration of x axis) with a disk for every integer: diameter = integer scalewise bg coloration: unicolored bg corresponding to screen scale: if scale is 9 color is blue, if scale is 20 color is orange => rainbow zScroll: size is color gradient rainbow zScroll freeDrawing: each stroke part with specific scale is colored with corresponding rainbow color pulsating: exponent is the period 20 = 2 x 10^1 => orange and period: 1s 200 = 2 x 10^2 => orange and period: 2s vertical rainbow bars (coloration of x axis): each rainbow bar could display its pulse (like a wave) edu: something small has fast pulse, something big has slow pulse edu: 9.2 * 10 = 92 (medium blue small orange times ten = big blue medium orange) les couleurs ne changent pas quand on multiplie par 10 les tailles relatives ne changent pas quand on change d'échelle: multiplier un nombre ne change pas sa "recette" **easy: opacity picker: same ux as for color picker **easy: doubleclick on image: replace image ***freeDrawing::zIndexInnerPainting: fine tune image by fine painting the zIndex of any of its pixels zIndexInnerPainted image is now a composite of multiples bit of image at different zIndexes it's an easy way to blend images together: 1. user puts imageFront over imageBack: precise location can be found by setting imageFront.opacity:0.5 2. user starts zIndexInnerPainting imageFront: undesired imageFront pixels are sent to back using mouseWheel facing image is now a complex blend of imageFront and imageBack *game: where's my what X iC: search for("kitchen tool", "10^(-2)"(colored green)) each [10^n,10^(n+1)[ scale span would have a specific bg color: [10^(-2),10^(-1)['s bg color is green *game: Q X iC: simple physics sandbox challenges, this time with zFreeDrawing enabled **adhesion: non-additive: adhere(obj1 with opacity:0.4, objSupport with opacity:0.4) results in continuous area with opacity:0.4 => this would be particularly convenient when freeDrawing **zTextField: "le chien du facteur...", this time with an editable textfield zTextField has a .path property to indicate the flow (with orientation) => this allows i18n (i18n of freeDrawn texts is way harder) **fun: zClaw: funfair claw machine: machine base and crane controls are at front scale toys are at deep scale (we cannot see them) launch catch sequence by pushing button claw.scale changes from front scale to deep scale claw tries to pick something claw.scale changes back to front scale, maybe with a toy edu: we could recycle this for random picking balls in a bag (probability course) *freeDrawing: reverse zFreeDrawing: zooming up makes stroke be thinner => to easily draw spikes or pimples **easy:freeDrawing::erase: as for adhere, starting support is erase target if no starting support: everything is erase target **(*)easy:anim::frame adhere/frameClone()/frameScroll: frameScroll: if object has multiple frames, show next/previous frame frameClone: create new frame with deep clone: then this frame can be edited (move arms, legs,...) frame adhere: create new frame with adhered object 17 mai 2023: ***easy: floodFill via stroke floodFill via gradient stroke floodFill via varying color stroke floodFill via frame-animated stroke => frame-animated floodFill same principles can be applied to border ***freeDrawing: floodFill adhere/_floodOverfill_: workflow: 1. draw main stroke: it represents floodFill surface it is tagged "floodFill_stroke" (2. add sub strokes to main stroke: it represents overfilling) 3. adhere floodFill stroke to target => target is floodFilled (+ overfilling follows sub strokes pattern) fun: tentacles overfilling, spikes overfilling, etc. frame-animated main stroke => frame-animated tentacles overfilling **zIndex X physics: rings, etc. **easy: freeDrawing::"floodFill kick" (press F while freeDrawing): current freeDrawing will auto fill, if possible, when finished **[CS]shortcut grammar: a key is to be conjugated ².F.click: floodFill at cursor ².F.stroke: floodFill via stroke ².stroke.F: floodFill kick: current stroke behavior is updated selectedObject.intlBackslash.F.A: floodFill adhere using selectedObject etc. => _shortcut grammar_ should be intuitive there is always a learning step, but afterwise the outcome is pleasure and freedom **[append stroke: ]/[append stroke pattern: ] freeDrawing_src * [append stroke: ] => stroke is adhered to freeDrawing_src at freeDrawing_src's "last point" elementary operators: [append stroke: ] [append stroke: down] [append stroke: left] [append stroke: right] append stroke pattern: like append stroke but continuing with freeDrawing_src's "stroke size" (edu: drawing with perspective: import perspective drawing image and draw over it (rescale till it's ok) *(**)freeDrawing: attractedZScroll freeDrawing(1-point perspective): zScroll is attracted to perspective center => ease drawing with 1-point perspective 2-point attractedZScroll (2-point perspective): system is smart enough to decide which attraction center corresponds to current stroke move (simply check orientation of last stroke move vector) **adhere on touchSlot => update touchSlot touch area adhere spinning object on touchSlot => touchSlot touch area is dynamic **(**)pov in query: use window.location.hash (#) to specify initial pov on canvas 3 flavors: coordinates povName id__pov **gotopov in browser history: when performing [gotopov], write window.location with corresponding # ?from=...&to=...&duration=3s => go back to previous povs using browser's <-back- button 18 mai 2023: **[color01:red,blue]: composite parts at even level will be painted red, composite parts at odd level will be painted blue [colorPrime235:red,blue, green]: composite parts at level will be painted color_ level 6 parts will have a dynamic color cycling from red to blue level 10 parts will have a dynamic color cycling from red to green edu: prime factor decomposition variant: easy read sync: color_ appears at same time for all parts containing this color *"void kick": while clicking with nothing held, void kick puts voidObject under mouse cursor voidObject is a legal target for [append] operators: [[void]] * [append "123"] = [["123"]] [[void]] * [append path_left] = [[path_left]] => easy creation of "orthopaths" (u,d,l,r) *eduDemo: [[92]] == [[9 x 10^1]] + [[2 x 10^0]] 1. spawn disk with area:92 loop: 2. using collection of disks:{...,disk(n x 10^m),...}, find the biggest disk that fits in disk(92): disk(9 x 10^1) 3. disk subtraction: disk(92) - disk(9 x 10^1) = disk(2) disk subtraction: disk_A - disk_B: hold(disk_B) above disk_A and press "-" *eduDemo: [[96]] + [[45]] = [[141]] 1. disk(96) + disk(45) = disk() decompose disk() using {...,disk(n x 10^m),...} and disk subtraction ***operate adhere: +,-,x,/,^ [[4]] + [[5]]: 2 flavors: raw: hold([[5]]) above [[4]] and press Key+ => before showing [[9]], display is scrambled [[4]] and [[5]] expository: 1.hold([[5]]) above [[4]] and enter adhereMode 2.move [[5]] at left of [[4]] 3.press Key+: a "+" operator will showfade between [[4]] and [[5]] after a little time (like 0.13 second), [[9]] appears => display is more communicative **freeDrawing::touch operator while freeDrawing: if possible, apply operator to brush, so that part that was already drawn is not affected example: freeDrawing is blue and, after touching [red] operator, freeDrawing continues with red color **(*)easy: write mathNode operator: numberWriting("+ 1") => [+ 1] operator is created numberWriting("+1") => [[1]] (mathNode) is created numberWriting("- 1") => [- 1] operator is created numberWriting("-1") => [[-1]] (mathNode) is created more: numberWriting("7 /") => [7 /] operator is created ([[2]] * [7 /] = [[7/2]]) numberWriting("2 + .. / 3") => [2 + .. / 3] operator is created (or [x ↦ 2 + x / 3]) argumentSymbol: when user types .. it is replaced by an argumentSymbol (☷ ♦ ⛆ ⛶ ❑ ➘ ➭ ⊡ ‽ ¿) multiple args: ..1 -> ➊, ..2 -> ➋ , etc. 19 mai 2023: **(*)expr-scroll: show different _formations_ of the same (math) expression ax^2+bx+c <-> a(x−α)^2+β <-> a(x−x_1)(x−x_2) (<-> ax^2+bx^1+cx^0 <-> ...) => math challenges: student can expr-scroll target expr to exhibit an easier building protocol (== gm transformation sequence) **physics kick: hold object gets physics-enabled until it stops => grab an object, physics-kick it, and throw it **worksheet-style expression building: while writing expression, click on canvas object to insert reference .... .... = .B2. + 3 * .H4. (worksheet formula) <---> [[icObj1 + 3 * icObj2]] (iC expression) .... .... this could be a general way to build a composite: [[icObj1 + 3 * icObj2]] like putting objects in the cart at the supermarket: click on this, click on that, type how many you want,... 20 mai 2023: **"physics kick": current held object becomes a physical object until it stops edu: hold an object, physics-kick it, throw it away, it moves, loses speed and stops somewhere **altering unadhere (kick): currently altered object is unadhered only after an unadhere kick workflow: 1. draw characterA with a ball adhered to their hand, and characterB 2. move ball to characterB: alter ball 3. give ball to characterB: unadhere-kick and then adhere to characterB's arm **(*)easy: query eduDemo: ic.html?eduDemo=1/4+3/7 **(*)easy: query challenge: ic.html?challenge&initial=0&ops=[+ 4, - 3, / 7, / 10]&ops_inverse&target=1/700 edu: pour mettre rapidement en place des situations d'enseignement 21 mai 2023: **colorization brush: anything on brush path gets .fill = brushColor ***easy: property brush (=="brush assign"): anything on brush path gets . = brush. => assign a particular number value to anything on brush path assign a particular zIndex to anything on brush path brush::propertyScroll: as for color or opacity, if property is "scrollable", then allow quick change of its value via scrolling if property is not scrollable, it may be defined via textinput ***easy: selection brush(=="brush select"): anything on brush path is added to current selection keyDownToggle.shiftLeft.isActive: add to current selection keyDownToggle.altLeft.isActive: remove from current selection ***propertyPicker/pickerScroll: pick any pickable property of underlying object pickerScroll: while picking(== while .leftMouseDown), mouseWheel shows underlying object's next property (key,value) pair => then generously brush assign picked property *use mobile phone as optical mouse: any student with a mobile phone can move mouse pointer in classroom's projected iC instance (since optical mouse is #1 input on iC) (a draggable mouse that uses a phone’s camera as mouse laser) phone would slide on student's table as would any standard computer mouse 23 mai 2023: **gm:challenge: from unit1 to unit2: simultaneous transformations keep same evaluation but change unit: simultaneously change quantity and unit the challenge is to create the appropriate operator by putting quantity change operator and unit change operator at same location gm has "soft-immutability" curse: if gm evaluation changes, then gm breaks **gm:challenge: from eq1 to eq2: simultaneous transformations gm has "eq soft-immutability" curse: if gm.lhs != gm.rhs, then gm breaks the challenge is to create the appropriate operator by putting lhs change operator and rhs change operator at same location edu: bien faire comprendre la règle "ce que l'on fait à gauche, on le fait aussi à droite" **easy: valueScroll: change value of selected mathNode N.mouseWheel when a (constant) mathNode is selected **easy: pow10Scroll: change pow10 of selected mathNode d.shift.mouseWheel when a (constant) mathNode is selected pow10Scroll([[123]], up) = [[1230]] eduDemo: scientific notation: [[ n == a x 10^k ]] selected object is an equation mathNode pow10Scroll => n updates, and k too valueScroll => n updates, and a too (and maybe k) ***brushWidthScroll: "elastic" by default, toggle for persistence to draw spikes 'elastic': when leftMouseUp, brushWidth goes back to its original value toggleElastic__brushWidthScroll to keep modified brushWidth after leftMouseUp brushWidthScroll: strong scroll step by default to ease drawing of spikes **delayedPow10HomeScaleScroll: change homeScale of object, but not now, object will go to its homeScale pow10 level by itself **pow10ZScroll: zScroll but pow10 by pow10 (throttle to prevent too-hard zScroll) **(*)WLR mouse: wheel-lmb-rmb mouse: so that _index finger is the scrolling finger_ 24 mai 2023: **easy:numberTyping::edit: when a (constant) mathNode is selected: edit selected mathNode 25 mai 2023: **floodFill with image: image bounds are now floodFilled obj's 2 flavors: wallpaper: floodFilling wallpaper image can then be moved, resized, etc. morphological: image is bent to mold floodFilled obj's bounds (with a transparent image (like png), we may consider image == non-transparent pixels) 26 mai 2023: *te+t: another way of reading: zoom in for details: more meaning in written on each word/on each letter a whole description is chunked lod-wise (lod==level of detail): at first glance, only one sentence is written, but if you zoom in, you see that more (and more) info is available. ***(*)charged: operations trigger only after leftMouseUp charged pathmade operator: pathmade path is followed only after leftMouseUp, starting at leftMouseUp location charged mathNode: operations are stacked (without simplification) and simplification occurs only on release edu: teacher releases mathNode after students have mentally tried to compute the result charged collection operator: apply operators sequentially, at a medium pace edu:CS: show sequential transformation of arrays, lists, etc. "charged" behavior may be applied via kick, or directly ingrained in operators charged::args: operator args are added via charge: if operator has correct number of args when releasing: trigger op(args) if operator has incorrect number of args when releasing: do nothing edu:maths::statistiques::moyenne: 1. click and hold [average] operator 2. when touching a value, preview under cursor shows updated formula [[(2 + 5) / 2]]* * [[4]] = [[(2 + 5 + 4) / 3]] 3. when releasing, formula is evaluated 28 mai 2023: **reduce: [[acc__initial]] * [reduce_friendly_operator] * [[value1]] * [[value2]] * [[value3]] ... **colorPicker: secondaryColor: ².C.2 ***(*)adn code: object code is written inside object, and can be edited add reference to other canvas object by dezoom-and-select'ing it => create and edit challenges directly in iC => mix visual coding and text coding (number generators could be created visually, number formats via text) (there might be visual adn code, and text adn code) 31 mai 2023: **gm:[next challenge] button appears after 5 completions use query vars to transfer context (progress, ...) **(*)easy:create litexp by superimposing samesamebutdifferent numexp: autodetect what is invariant and what is variable **(*)zScroll::craneScroll: keep screenpov unchanged and change homeScale of selected obj craneScroll + zIndexScroll: 1+2.mouseWheel => illusion of perspective **freeDrawing::comb: comb of existing comb: 2 --> 4 --> 8 --> 16 etc. **(*)freeDrawing::comb::orthScroll: when comb drawing, adjust spacing via scroll orthScroll(1-stroke freeDrawing) = orthScroll(comb(2) freeDrawing) (comb(2) is auto called) orthScroll(comb of comb) = orthScroll(last comb) (parent combs' spacings are left unchanged) **(*)easy: freeDrawing::"comb pop": set comb number by counting rightMouse clicks then use orthScroll to separate comb strokes ("takeoff") (comb number is then fixed) then draw with the multiple strokes comb antipop: remove a child stroke by alt.rightMouse clicking **custom shortcut to remote operator invocation: user sets its own keyboard shortcut to invoke operator **freeDrawing::comb::superdraw: assign properties to each comb stroke via freeDrawing operator invocation workflow: 1. user creates an operator to assign properties to stroke#1 (strokeWidth: 20, color: blue, etc.) 2. user creates an operator to assign properties to stroke#2 (strokeWidth: 10, color: red, dashed, etc.) ... n+1. user creates an operator for all strokes by superimposing the operators n+2. user creates keyboard shortcut to call this operator n+3. user starts comb-freeDrawing n+4. user invokes stroke-setup operator ==> comb is marvelous edu: draw electical cables/electical wiring diagram ***(*)freeDrawing: pause/resume **(*)freeDrawing::comb: pause/resume to allow specifying props of each stroke (or to comb a particular stroke **freeDrawing::comb: named strokes/comb dict this may be useful when creating/using operators which target specific name(s) 01 juin 2023: *comb/orthScroll+pathmade: one path for each arg, one arg for each path **comb+(color)Picker: pick at each cursor, for each path **FueledBrush: freedrawing adhere on constant mathNode: brush stroke can only be that long example: freedrawing adhere on mathNode(20) => stroke length will be at max 20 edu: pour comparer visuellement des quantités et pour aborder la longueur de la diagonale d'un rectangle 02 juin 2023: *eduDemo: scale invariance: zScroll on guitar frets high/low-pitch guitar string == "zoomed-out/in" guitar string as if there was only one infinite string but cloned and offsetted at different zoom scales *comb mutation: when one of the single strokes becomes a comb because of an operator touch example: ---- ----------- comb ---- * [make stroke double] = comb comb ====== ---- ----------- **(*)edu:math:expression is a comb: comb(1,1,1) * [+ 1] = comb(1,1,1,1) comb(1,1,1) * [x 2 (map)] = comb(comb(1,1), comb(1,1), comb(1,1)) comb(1,1,1) * [x 2 (scale)] = comb(comb(1,1,1), comb(1,1,1)) comb(1,1,1) * [/ 3] = comb(1) comb(comb(1,1), comb(1,1), comb(1,1)) * [/ 2] = comb(1,1,1) comb(comb(1,1), comb(1,1), comb(1,1)) * [simplify] = comb(1,1,1,1,1,1) => [+ 1] is a 1-comb-target operator, [x 2] is either a map operator, or 1-comb-target operator (scale) 03 juin 2023: **(*)edu:math:function graph is a comb: graph = comb(y=0 (constant func), y=value), comb's 0func is the touchable stroke, x moves to x_next after each touch for discrete n graph: comb(0, value (at n)) * [x 2] = comb(0, value*2 (at n+1)) for continuous function graph: [(continuous) + 1] operator: when comb's 0 stroke moves along this operator, a continuous mutation is applied to the graph ***icObj.type = "transport_seat" ("Les sièges de transport") (slightly different from portal) when zoom in is so that all screenPov is contained within transport seat bounds, zoom out bring you to _next transport seat_'s location this allows: freeDrawing started in transport seat 1 can continue in transport seat 2 (~wormhole) freeDrawing is continuous though it looks discontinuous transport_seat-based image search: 1. move screenPov to desired area 2. transport_seat kick 3. if another area on the canvas with the exact same insides has been found, zoom out will bring you there transport seat TAB-ing: pressing keyTAB will bring you to next transport seat in the chain 04 juin 2023: ***(*)ultra easy: combSetup: click on the different starting points before starting drawing comb main stroke is only used for its pointer, the marking strokes are the child strokes pointer alteration: alter comb main stroke's pointer position wrt other strokes (Alt) **colorScroll: colorFromAdhere: stroke color is starting point color => comb: each stroke color is its starting point color *[CS]: decorator.setInfiltration(propName, prop) {...}: set the prop to all objects down the decoration hierarchy decorator.removeInfiltration(propName) {...}: : remove the prop from all objects down the decoration hierarchy *[CS]: "ReduceDecorator": like CombBrush(arr_brush): one object facade for all objects like a leader 07 juin 2023: **(*)comb: pre-oriented strokes: each stroke has a mother orientation when comb drawing, even if mouse pointer initially moves upwards, the strokes will follow their mother orientation then their orientation will be relative to mouse pointer's orientation **comb: toggle orientation: to create sharp turns -------------blue--> ----------<--blue -------------red---> becomes ----------<--red *comb: magnetic recapture: each child stroke's pointer is driven to mouse pointer 2 flavors: passive magnet: mouse pointer has to move for the magnetic effect to trigger it may take some drawing for the child pointer to catch up with the mouse pointer active magnet: magnetic attraction happens even mouse pointer is still *comb: spinning stroke: mouse pointer's stroke is rotation axis for child pointers homeScale and zIndex are updated to create a 3D effect **comb: enveloppe: space between 2 child strokes is filled using a fillEnveloppe() function examples: an oscillating func is bounded inside enveloppe a random path is drawn inside enveloppe ... **(*)touchSlot: oriented touch: touchFunc(...,touchDirection) examples: [[ [1] ]] * [ stick [] ] (touching left side of op) = [1][] [[ [1] ]] * [ stick [] ] (touching right side of op) = [][1] touchSlot could be a disk => (touching op at angle 269°) **timeControl: CTRL-Z moves back in time (keyDownTimeout) and CTRL-Y moves forward in time (keyDownTimeout) *generalized stroke == piecewise stroke + we still consider there is a starting point, an ending point, though we have sometimes to leap space between 2 pieces is not considered part of the stroke **(*)challenge:GM: ball follows mouse pointer's orientation this allows: GM is segment: segment appears vertical when moved left/right challenge: transform segment [[segment(length:2)]] * [+ 3] = [[segment(length:5)]] target can be display without any clue on its length numerical value => edu: les élèves devront faire une comparaison entre les longueurs et les lier avec les valeurs numériques edu: parler avec les élèves de la précision challenge: pick the right point an oriented touch arrow operator is used to get abscissa of arrow-pointed point on an oriented-ball segment edu: pour la proportionnalité *fun: GM under bullet hell: avoid bullets while solving challenge **(*)challenge:GM: deep to deep: i:[[9 x 2]] t:[[(9+3) x 2]] edu: déconstruire pour mieux reconstruire **eduDemo: recursive func calls: show the emergence of fixed points **[CS]: transparent fallback to nugget property (== property of inner object in decoration hierarchy): if(obj.get["propName"] == null) { if(obj is decorator) { return obj.wrappedObj.getNuggetProperty("propName")} } } how much evil is this ? Same behavior can be applied to composition hierarchies but more than one matching property may be found => reduce(arr_found) more horror: by type! more horror: by duck typing! *[CS]intrusive decorator / protective decorator: intrusiveDecorator.setProp sets prop in wrappedObj if propName exists in wrappedObj protectiveDecorator.setProp sets prop in decorator even if propName exists in wrappedObj 08 juin 2023: **comb + adhere: try to have all pointers on support before drawing **freeDrawing: GhostBrush: freeDrawing obj is ghost (== only visible when screenPov.scale is around obj.homeScale) **freeDrawing: comb: toggleFollowOrientation: ².Space.R (keyDownToggle) **[CS]FlattenedDecorator(decoration chain): this decorator uses the "newest" props and funcs (== the highest found in the hierarchy) like when we use [flatten] on multiple image layers in paint.net 09 juin 2023: **comb + colorPicker: each pointer picks its underlying color **comb::RadialComb: 1. set comb center 2. set child pointers 3. when drawing with mousePointer, other pointers reproduce move wrt their own radial orientation => draw flower petals **comb::ShapeNormalComb: 1. set shape 2. set child pointers 3. when drawing with mousePointer, other pointers reproduce move wrt their own normal orientation => draw flower petals with a deformed receptacle **GM: [simplify frac top_bottom pair]: [[frac{6 x 2 x 2}{7 x 5 x 6}]] * [... x strikethrough(6) x ... / ... x strikethrough(6) x ...] = [[frac{2 x 2}{7 x 5}]] **GM: random appearance of additional "x 1" in frac numerator, or in product: [[frac{6 x 2 x 2}{7 x 5 x 6}]] * [/ 2] = [[frac{6 x 2 x 1 x 1 x 1}{7 x 5 x 6}]] [[frac{6 x 2 x 1 x 1 x 1}{7 x 5 x 6}]] * [x 6] = [[frac{6 x 2 x 1}{7 x 5}]] [[3 x 4]] * [x 2] = [[3 x 4 x 2 x 1 x 1]] edu: pour faire comprendre qu'il y a toujours une infinité de "x 1" à disposition **comb::circle lock: when in circle lock, a combBrush pointer is locked and dissociated from mousePointer moving mousePointer results in child brushes doing perfect circle-ish trajectories 2 flavors: -main combBrush pointer is locked: perfect circles -a child pointer is locked: "perfect turns" *comb:opacity-rainbow comb: opacity of outer strokes decreases with distance to main stroke => "real stroke" effect if comb has enough child strokes, this may yield a "very soft"-stroke effect 10 juin 2023: *wandScroll: magic wand's tolerance is controlled by scroll *freeDrawing::inner painting: 3 flavors: strict: repaint happens only drawings with color == starting color (even though starting color is "transparent") soft: repaint with a tolerance (repaint color is adapted to src color, color_new = func(color_src, color_dst, tolerance)) dumb: allow repaint of all that's non-void **orthScroll: soft change (avoid showing big steps on screen) shift__dst updates when evolving "in the same direction" (increasing or decreasing) soft change func adapts micro steps to evolving shift__dst soft change stops when micro_step is "close enough" to reach shift__dst **edu:math: brush as bloom: - brush.width could be a representation of brush.value - brush.value could be at brush pointer's location - brush.value could "heartbeat showfade" on brush stroke, just a bit away from brush pointer ***comb::[comb] freeDrawing operator: brush touching this operator suffers comb() => edu: math: create litexp via combing [+], [-], [x], [/] are freeDrawing operators [[singleBrush]] * [<- 3] = [[singleBrush({3})]] [[singleBrush({3})]] * [+] = [[childBrush__top({3}), childBrush__middle({+}), childBrush__bottom]] [[childBrush__bottom]] * [<- 0.14] = [[childBrush__top({3}), childBrush__middle({+}), childBrush__bottom({3.14})]] we could also have touched [+] at first, and then assign the values this allows drawing the operator hierarchy first, and then assign the values ux should be friendly: orthScroll is made unavailable focusScroll allows choosing which childBrush is touchable comb are resized so that it's always readable ***comb::[collapse]: if all child pointer offsets are (0,0): keyUp Space: go back to single brush single_brush = collapse_func(comb.arr_brush) => this may be another way to setup a brush example: childBrush__top is used to set texture childBrush__bottom is used to set color [collapse] freeDrawing operator: comb touching this operator suffers collapse() edu: a cool way to do math: [collapse] == [=] addition: [[childBrush__top]] * [<- 3] = [[childBrush__top({3})]] [[childBrush__bottom]] * [<- 0.14] = [[childBrush__bottom({0.14})]] [[comb]] * [collapse] = [[singleBrush({3.14})]] partial collapse: only collapse some child brushes remark: once again, it's interesting because it is a reduce() auto collapse(== "array collapse"): when all child pointer offsets are (0,0), automagically melt into single brush collapsed.value = array of child brushes values remark: edu:[CS]: [[comb]] is transformed by [n-ary operator] [[collapsed]] is transformed by [input-is-array unary operator] **[structure]GM:challenge: brush based challenges => a whole new lot of challenges to create 11 juin 2023: **(*)comb::snake stroke: this stroke has fixed length like in snake game if snake has snake.value then value is displayed at snake's tail |sssss| |sssssss| [[4]]ssss| |ssssss| |ssss> **(*)comb::snake::[tree] ("spaceship"): snake touching this operator suffers tree() snake touchable areas are: snake's head empty slots in tree [[4]]sssssssssss [[4]]sssssssss> * [tree: +] = [+]ssssssssss> [[ ]]sssssssssss ^ |_ empty slot (waiting to be assigned) edu: pour faire des litexp/numexp, et travailler sur la structure syntaxique **[init assign]: this operator only accepts [[ ]] as first arg [[ ]] * [init assign: 3] = [[3]] [[9]] * [init assign: 3] = [[9]] (ignored or throw InputError or set [init assign: 3].enabled = false when working with [[9]]) => edu: forcer les élèves à d'abord constuire la structure et rajouter le contenu après **(*)easy: comb::"args comb": workflow: 1. in combSetup mode, add brushes' pointers on the objects you want to refer to 2. start drawing comb: the strokes are magnetic-recaptured into a compact n-stroke 3. [[compact n-stroke]] * [n-ary operator] = [[ouptput m-stroke]] (usually output is a 1-stroke) "args snake" follows the same principle **GM:challenge: oriented angles: GM is a trigonometric circle with angle inscribed on it there is a specific angle color wrt its modulo 360 -1080 -720 -360 0 360 720 1080 purple red orange blue green yellow **GM:challenge: hours and minutes: GM is a clock [+ 0.5 h] [+ 10 min] [/ 2] ... **(*)ultra easy: objectComb/objectOrthScroll: create object collection the same way as for a freeDrawing comb workflow: 1. hold object 2. comb/orthScroll with held object will automagically create new objects with everything still under mouse control => now user is holding a collection (the objectComb) 3. held [[collection]] can be transformed by an [n-ary operator] (strict) or each element in collection can be transformed by a [unary operator] (soft) objectComb flavors: combClone: created collection = [heldObject, ... clones] edu: pour montrer en parallèle différentes transformations d'un même objet combPlaceholderPop: created collection = [heldObject, ... emptySlots] edu: pour montrer les fonctions qui prennent 2+ arguments en entrée combWithGenerator: create collection using generator.yield() edu: pour créer ultra facilement [[ [[1], [[2]], [[3]], [[4]], ...]]] remark: orthScroll(objectComb) mutates elements (vertical) spacing edu: séparer les objets pour que la présentation soit plus claire remark: by default, collection does not have .orientation => to move a collection == to translate a collection **heldObject.disable()/.enable(): to allow moving object when surrounded by operators, _without touching them_ visually, disabled heldObject has .opacity:0.4 **"font" for freeDrawingObj: postprocess freeDrawingObj with specific customization example: we define a "FreeDrawingObj::stroke::a" with the following characteristics: in the middle of the source stroke, we spawn a little root-like stroke, starting orthogonally 1. user selects (by scroll or by typing) that they'll draw a FreeDrawingObj::stroke::a 2. user draws a stroke 3. when the drawing is finished, FreeDrawingObj::stroke::a specific customization occurs: stroke has now a root-like stroke in the middle dev: the [define] part is the heaviest - define src - define dst => infer transformationFunc so that dst = transformationFunc(src) **easy: conditional formatting setup by touching conditional formatting operators conditional formatting operator is ternary operator: [[.value%2 == 0] ? [.color <- green] : [.color <- black]] workflow: 0. hold object 1. enter setupConditionalFormatting 2. loop: touch conditional formatting operators 3. leave setupConditionalFormatting => conditional formatting operators will be automatically called after each update of object object is cursed with onChange-curse edu: math: pour montrer: les nombres pairs/impairs les nombres positifs/négatifs les nombres inférieurs à 1/plus grands que 1 les critères de divisibilité quand deux objets sont séparés d'une certaine distance: [[distance(..,B) >= 10] ? [.color <- green] : [.color <- red]] ... creating conditional formatting operators is the tough part ? need a DSL for operators ? 12 juin 2023: **freeDrawing::draw with generators draw base stroke and generator does the rest flavors: constrained: generated = generator(base_stroke, canvas) generated drawing won't overlap on another obj, it will be constrained in available room it gets free: generated = generator(base_stroke) generated may overlap other objects 13 juin 2023: **ic::math::rational numbers: numberTyping explicit: 6.55'123' implicit: 6.5512312312... enhanced decimal display: random-colored periodic sequences keep the color of the periodic sequences when transformed: [[0,blue(123)red(123)green(123)yellow(123)...]] * [x 1000] = [[blue(123),red(123)green(123)yellow(123)pink(123)...]] GM:challenges eduDemo: 0. [[q]] == [[42,53'165']] 1. [[42,53'165']] * [x 100] = [[4253,'165']] [[q]] * [x 100] = [[100q]] 2. [[42,53'165']] * [x 100 000] = [[4253165,'165']] [[q]] * [x 100 000] = [[100 000q]] ... numberTyping("1.123123... + 8.4'56'") dev: outche **numberTyping: irrational numbers (implicit): create sequence-based irrational numbers by typing the first elements of their trailing sequence numberTyping("0.1234...") ==> Champernowne constant (0.123456789101112...) **GM:challenge: decimal numbers:: insignificant/trailing zeros: when doing a.b + c.d, require that b and d be prepared with the same number of trailing zeros [[3,45]] * [add trailing 0] = [[3,450]] platform [+] only activates when all args are correctly formatted: [[3,45]] * [+ {4,119}] => not the same format: nothing happens [[3,450]] * [+ {4,119}] = [[7,569]] (same format: OK) **edu: formatted-input-only operators 14 juin 2023: **(*)explicit identity: identity-like operators (==operators that don't change the value) (formatting, simplifying, ...) should share a common style (color, border, ...) example: color: grey, borderWidth: thick sub-categories of identity operators could share a common sub-style: formatting operators: a little "format" somewhere on the facade color: gradient(grey, blue) simplifying operators: a little "simplify" somewhere on the facade color: gradient(grey, white) edu: so that student knows when its 'really' changing **(*)born with a name: spawn(3) => [[name: 'b', value: 3]] each ConstantNode has a SymbolNode attached to it, it can be edited with another variable name, if the new variable name is available the litexp attached to the node is written top left of the facade the litexp evolves with the operations applied to the initial mathNode [b ] [b+2 ] [ 3 ] * [+ 2] = [ 5 ] [ ] [ ] edu: at first glance, we don't notice the litexp on top because it's small but then the teacher zooms in and shows the litexp and explains what happened edu: expliquer les expressions dépendantes clone([[litexp: 'b+2', value: 5 (.id:100)]]) ==> [[litexp: 'b+2', value: 5 (.id:100)]] [[litexp: 'b+2', value: 5 (.id:101)]] [[litexp: 'b+2', value: 5 (.id:101)]] * [x 2] = [[litexp: '2b+4', value: 10 (.id:101)]] numberScroll([[litexp: 'b+2', value: 5 (.id:100)]]) ==> [[litexp: 'b+2', value: 6 (.id:100)]] [[litexp: '2b+4', value: 12 (.id:101)]] (quand on touche à l'une, on touche à toutes celles qui sont liées) **[structure]GM: mirroring litexp: challenge.banner displays node's litexp as player uses operators, banner's litexp evolves edu: to gradually move from numerical challenges to litexp challenges (for example) (it's a bit like a history log) **freeDrawing: morphoDrag/pullDrag: morphoDrag: freeDrawingObject "general" shape is conserved like picking a worm and moving it: area is unchanged pullDrag: freeDrawingObject does not move but a part is made longer like pinching pastry and pulling it: area grows **displayScroll: scroll through different representations of object shortcut: D.mouseWheel edu: rational numbers: [[frac{1}{3}]] <--> [[0.'3']] <--> [[0.3333333...]] edu: powers: 5^3 (compact) <--> 5 x 5 x 5 (unfold) <--> 125 (evaluate) <--> x^3 (born with a name) edu: arithmetic: 2 x 3 x 5 x 7 (unfold) <--> (3 x 5 x 7) x 2 (divisor:2) <--> (5 x 7) x 6 (divisor: 6) <--> (2 x 7) x 15 (divisor: 15) <--> ... **[structure]GM:challenge: bloom challenge: bloom operator only activates when arg is correct bloom type player has to displayScroll to choose the correct representation before touching operator examples: [frac{x 2}{x 2}] only operates on .bloomType = "frac" [+ 0.25] only operates on .bloomType = "decimal" [x 10^3 (sci)] only operates on .bloomType = "sci" *freeDrawing: bottom-top brush: brushWidth = f(y): bottom = big, top = small ***splitComb: control split weights via scroll split weights: a vertical slider shows the weights [[6]] * [split: weights(0.31,0.69)] = comb([[1.86]],[[4,14]]]]) split ratios: [[stroke.brushWidth:6]] * [split:(ratio(2,1))] = comb(stroke.brushWidth:4, stroke.brushWidth:2) workflow: split(2) 1. enterSplit 2. setWeights on 2-segment slider using scroll 3. leaveSplit workflow: split(n) 1. enterSplit 2. setWeights on n-segment slider using mouseDrag on slider's (n-1) cursors 3. leaveSplit edu: math: fabriquer un arbre de probabilité ultra facilement edu: math: montrer l'effet de multiplications répétées par une puissance 0 object is now mirage object this could be used to create thumbnail facades for rich areas **branch picker: copy branching pattern of existing object workflow: context: a tree has been drawn with branches, some of which having child branches etc. 0. enter drawingMode 1. select a root point and draw a tiny stub to indicate the direction in which you want to copy branch => branch pattern is extracted from branch-picked object 2. user starts drawing and brush autoCombs when curvilinear abscissa of a branching is reached branching spacing is reproduced branch apparentWidth is also reproduced => user can paint copies of existing branch but with a different "backbone path" "branch plagiarism" **bubblePop object: destroyed when touched by anything edu: rubbable instructions/explanations that students can easily get rid of: screen is clean afterwise **veilBrush: opaque from a distance, transparent when close freeDrawingObj opacity goes to 0 when close enough to freeDrawingObj.homeScale edu: easily create flash cards **font: dynamic(contextual) font decoration: decoration generator is applied to char/words as they are typed in examples: chtulu font: all typed in chars are decorated with random tentacles hot/cold font: hot words are decorated with flames and fire whereas cold words are decorated with snow and ice edu: to give enhance expressivity of words/chars in a text *easy: math::geom: intersection: auto create intersection points with other objects when spawning geometrical object edu: math: pour faire une eduDemo autour du théorème de Thalès 17 juin 2023: **[structure]edu:class challenge: class tries to get highest score in given duration workflow: 0. teachers inputs all students' names into the system 1. loop: (during 3 minutes) show question/challenge + a random student name teacher awaits designated student's answer if the designated student tells an answer: teacher inputs the answer (teacher drags GM, touches operators, and targetTouchSlot) the targetTouchSlot has a specific behavior: if isValid(input) == false: pick a new random student name if isValid(input) == true: score = score + 1 if another student tells the answer instead of designated student: teacher clicks on [unrespectful] button score = score - 1 OR score = score - 5 AND a bad photograph is displayed during 3 seconds 2. class score is displayed, high scores are displayed *freeDrawing:failing brush: brush sometimes paint, and sometimes not *freeDrawing:failing combBrush: each child brush is a failing brush "" failing combBrush = comb(arr_brush_raw.map(FailingBrush.decorate)) "" edu: expliquer la percolation (avec des brosses collées (==espacement minimal, ==rainbow comb)) **[CS]decoration.setIsDecorationActive: DecorationUtils.setIsDecorationActive__for_propName_in_decorator(obj__dec, decoratorClass, propName, isActive) if decoratorClass is found in obj__dec decoration's hierarchy, if propName is found in decoratorClass's decoration layer, then change .isActive state of prop-with-propName decoration DecorationUtils.setIsDecorationActive__for_decorator(obj__dec, decoratorClass, isActive) if decoratorClass is found in obj__dec decoration's hierarchy, change .isActive state of all decoratorClass's decorations 18 juin 2023: **easy: freeDrawing: _multiadhere along drawing_ via releasing Key² when drawingMode.leftMouseDown (==drawing) and then pressing it again on desired nth support **easy:zPuzzle is shattered image(==zPuzzle without snapSlots) workflow: 1. import image 2. slice cut in n pieces 3. move/zScroll pieces around => zPuzzle is ready it's better to use vector image because there is no sharp/blur hinting when using raster image: slightly blur big pieces so that they lose their 'sharp' look and slightly sharpen small pieces **freeDrawing: picker while drawing: simulateMouseUpDown(updateBrush(prop__picked)) **colorScroll(freeDrawingObj__compound): change color of color-contiguous area workflow: 1. pick part of freeDrawingObj__compound 2. colorScroll => all freeDrawingObj__compound's parts that are color-contiguous with picked part will change color alt-colorScroll ==> only colorScroll picked part **easy: zIndexScroll: coarse zIndexScroll: auto leap to next relevant zIndex example: context: there are 2 objects: icObj1.zindex:33 icObj1.zindex:85 when freeDrawing.coarseZIndexScroll(): brush.zIndex may leap to a value in: {32 ; avg(33,85) ; 86} 20 juin 2023: **eduDemo: sine/prime eduDemo: colorScroll on imported image (sineprime(n) has color(n)) anchor/zScroll (all sineprime start at 0) strokeWidthScroll (on imported image) (sineprime(N)'s strokeWidth must not be too big) **allow off bounds drawing allow off bounds dragging **(*)color scroll while editing icText/mathNode: 1. select part 2. alt.KeyC.mouseWheel: only selected part changes color **GM:challenge: polarCoordinates: get to the star at position(angle, distance) protractor is movable at angle when angle is set, a locked-direction segment can be pulled from protractor center to desired point (zScroll is available, segment.length is displayed) then the gm can be grabbed from here to complete challenge **(*)freeDrawing during gotopov animation: this allows freeDrawingWriting along the gotopov path (write transition text from povA to povB) 21 juin 2023: **math:bleeding color operator: [[blue 4]] * [[bleeding(red): + 2]] = [[red 6]] edu: pour rendre plus lisibles des séquences de transformations blue --> red --> green --> yellow --> black --> ... easy spawn: bleeding color == active color when spawning ***picker _while holding_ (==dipping) example: pick of object under held object and set heldObject to picked edu: assign value to [[x]] via dipping: [x ] dip([[x]], [[4]]) = [[.name:x .value:4]] (== [ 4 ]) [ ] (related: 'born with a name') ***dippingFloodFill(==chameleon floodFill): object is floodFilled using underlying captured texture *(*)eduDemo: tables workflow: 0. spawn [+ ] via numberwriting 1. spawn [[0]] 2. loop: poopSameScaleClone touch operator => the sequence of [[k x ]], from iterating the transformation same workflow for sequence of ^k (with initial: [[1]]) *game:pictionary::zoom-in approach: image is first shown from afar, and then we zoom-in slowly (gotopov) 22 juin 2023: **gotopov: go to to last edit **edu: a personal iC for every student: (persistance) when a teacher explains something to this student, teacher writes stuff in student's iC then student has access to all the explanations they were given by going on their iC *eduDemo: scale invariance (2): trees are scale invariant: workflow: 1. import picture of a tree 2. lasso-select a branch of the tree 3. clone branch 4. rotate / scale branch to overlap tree ***ultraeasy: improvised path::gotopov "parkour": use freeDrawingObj as improvised gotopov path shortcut: P.click on a freeDrawingObj if freeDrawingObj is branched: flavors: (main branch is chosen) random branch is chosen (uniform) random branch is chosen (width of branch == probability weight) edu: vivre les probabilités en suivant le toboggan plusieurs fois ***ultraeasy: improvised path::improvised-pathmade kick: use freeDrawingObj as improvised pathmade operator shortcut: Digit5 (the pathmade drawing key) flavors: same as for gotopov "parkour" edu: probabilités en automatisant le lâcher d'objets sur un toboggan arbre de probabilités dev: this means recording kicks **numberTyping::equation **statement/born with The Truth: a statement is an object with property .truthValue (true, false or unknown) a "born with The Truth"-object has .truthValue:true when spawned easy: a numberTyped equation with a new symbol name spawns with .truthValue:true this truthValue having been inferred, it is editable a numberTyped equation with a known symbol name spawns with .truthValue:unknown if all equations containing symbol name have .truthValue:unknown, user can set the .truthValue of one of them **[verif] operator: statement with .truthValue:unknown is evaluated and updated [verif] assigns .truthValue: unknown if no existing statement or computing allows to deduce truthValue true if a statement in the canvas or computing allows to deduce truthValue:true false if a statement in the canvas or computing allows to deduce truthValue:false examples: [[2 = 0]] * [verif] = [[2 = 0 __false]] {[[x == 15 __true]] already in the canvas} => [[2x+1 = 31]] * [verif] = [[2x+1 = 31 __true]] {[[x == 0 __true]] already in the canvas} => [[2x+1 = 31]] * [verif] = [[2x+1 = 31 __false]] {[[x == 15 __false]] already in the canvas} => [[2x+1 = 31]] * [verif] = [[2x+1 = 31 __false]] **color::rainbowScroll: colorScroll in rainbowSpectrum shortcut: C.X.mouseWheel C.X.Shift.mouseWheel to scroll faster through colors *edu: Mario Star effect: to insist highlight on a particular object: teacher can colorScroll in a frenzy (scrollUp-scrollDown very fast) => object seems to have all colors at the same time (how about object has total immunity(==.isTouchable:false) when we do this ? triggering move would be scrollUp-scrollDown-scrollUp-scrollDown-scrollUp-scrollDown and then object would be in an immune state for 5 seconds 23 juin 2023: **numberTyping: emoji numberTyping(":)") ==> createIcObjEmoji(":)") ==> emoji spawns in iC edu: pour ajouter des émotions par rapport à ce qui est présenté *TouchState:"recovery": if obj has changed size after being touched by touchSlot, so that it is now touched by other touchSlots, ignore those touches until object leaves their touch areas and enters back in their touch areas ***(*)[structure]challenge:GMComb: GM is objectComb: example: initial: [[ [[4]] [[5]] ]] operators: [+ 1] [- 2] [x 3] [/ 4] [+] [-] target: [[ _4_ x 3 - (_5_ + 1)/4 ]] edu: pour les priorités opératoires et les arbres de calcul **side-orthScroll: [[ [[a]] [[b]] [[c]] [[d]] ]] [[ [[a]] <<[[b]] <<[[c]] <<[[d]] ]] [[ [[a]]<<[[b]] <<[[c]] <<[[d]] ]] ***side-orthScroll reactor reduce: perform reduce by collapsing collection on reactor workflow: 0. object comb is [[ [[reactor(inital)]] [[obj1]] [[obj2]] [[obj3]] [[obj4]] ...]] 1. side-orthScroll brings objs closer to reactor 2. when reactor touches obj1: [[obj1]] * [[reactor(initial)]] = [[reactor(A)]] so we get [[ [[reactor(A)]] [[obj2]] [[obj3]] [[obj4]] ...]] 3. then we get: [[ [[reactor(B)]] [[obj3]] [[obj4]] ...]] ... edu: CS: this is how reduce works 24 juin 2023: **[test] operator: returns true or false [[50]] * [test: > 100] = [[false]] [[trololo]] * [test: contains("rolol")] = [[true]] **(*)numberTyping: regex => easily create [test] operators [[trololo]] * [test: /^a/] = [[false]] [[azerty]] * [test: /^a/] = [[true]] **[match] operator: returns result of regex match [[trololo]] * [match: /(?:.o)/] = [[ [[ro] [[lo]] [[lo]] ]] ***(*)brushPicker: not only pick the color, pick the entire brush each brushX offspring has .brush__mother:brushX => pick the mother brush with all its effects (and its decoration hierarchy) **clone_to_store() (==operator_invocation([store])): keep a copy of the object in the (global) store edu: during the class, when teacher manipulates a meaningful item, they call clone_to_store() (student don't see it happening because the store is far away) then at the end of the class, teacher moves to store to recall all the items/concepts that were important in this class **icObj.type = "bag": prevent content overload by putting stuff in invisible cloak bag the bag has a small visible part which is like a door the bag has a big hidden part, around the bag entrance, which is like the room behind the door there is button to show/hide container part (and allow/disable object pick) container part .opacity:0.5 may be set on hover, in order to get a glance of what's inside **(*)bag with capacity: if bag.propX__current + obj__candidate.propX > bag.propX__max: cannot add object to bag examples: weight: {bag.weight__current: 12, bag.weight__max: 15} => cannot add obj with obj.weight:4 area: {bag.area__current: 6, bag.area__max: 10} => cannot add obj with obj.area:5 (here: area is area wrt bag.homeScale) **noOverlap brush: if current stroke overlaps another stroke _without crossing over it_, then change both strokes' widths to ensure no overlap (and change brush.width too) 26 juin 2023: **comb: cornerCut: child brushes' offsets are set so that a 90° angle is possible example: ------ ---- | -- | | | | | *startFromEndsBrush (autoComb): 1. select freeDrawingObj 2. start drawing: comb pointers start at freeDrawingObj's end points **(*)[meta]easy: hoverScroll: no need to actually grab object, hovering is enough typical usecase: numberScroll *easy: numberComb: each comb child carries [[]] 4--------- 3--------- 2--------- 1--------- **easy: rainbowWidthNumberComb: each comb child's width is proportionnal to ********* 3********* ********* 2;;;;;;;;; ;;;;;;;;; 1///////// edu: pour montrer l'effet de la multiplication: toutes les épaisseurs doublent *sideComb: toggle side/ toggle main stroke ****pointerComb: mousePointer can be comb'd: => many consequences drag: context: pointer1 is over A, and pointer2 is over B leftMouseDown ==> now dragging A and B => dragging flavors (user can choose and change it when they want): - object comb (== 1 dragged object with child objects in it) this object can be touched by a unary operator - multiple drag: (== n dragged objects): this multiple selection can be touched by a n-ary operator each dragged object can be touched by a unary operator etc. (main object can be chosen and changed by user: main object will be the 1st arg when touching n-ary operator edu: pour parler de la commutativité independent hold/release: pointers may release and drag independtly segment drag: with 2 pointers, it is easy to indicate that we want to drag a segment 2DExtrusion: create 2D rectangle from dragging segment along the normal vector 2DContinuation: create 2D shape from dragging segment as if it were a brush select => combSelect: the pointers perform their own selection rect, lasso, wand,... 2 flavors: selections are merged selections are kept individual **(*)mixedNatureComb: comb(obj_with_type1, obj_with_type2, ...) example: comb(pointer, brush) *objectComb: swap: comb([[2]],[[3]]) * swap() = comb([[3]],[[2]]) *objectComb: invoked operator: comb([[2]],[[3]]) * invoke([+]) = [[5]] comb([[2]],[[3]]) * invoke([-]) = [[-1]] edu: pour parler de la commutativité edu: valueScroll on object comb: comb([[4]], [[x]]) * valueScroll(+1) = comb([[5]], [[x+1]]) tout le monde subit l'opération en même temps (c'est comme si c'était un animScroll 27 juin 2023: **collaborative canvas: each student controls a pointer ***brain-controlled multiple pointers: one person controls multiple pointers remark: how many hours of training to achieve that ? *network code in ic.html or lib/p2pnetwork.js: connect to 1 in the group => autoconnect to the others groupKey is a shared object set in iC ("unigebra"/__"anygebra"__ ***ultraeasy:walls: a wall of rectangular previews is displayed, zoom-in to access to content examples: movie wall: zoom-in on movie poster to play movie games wall: zoom-in on game poster to play game books wall: zoom-in on book cover to read book ***easy: broadPointer/broadScroll: broadpointer grabbing area is a disk: this allows holding m objects at once broadScroll: B.mouseWheel (same a brushWidthScroll, but while not in drawingMode) this allows pressing m buttons at once ***easy: broadPointerComb(==vesselComb): this allows holding n x m objects at once: ***synchroPress: select buttons and then press them all at the same time workflow: 1. enter synchro mode 2. click on buttons you want to press at the same time some may be big, some may be small, some may be far far away 3. leave synchro mode => each of the selected buttons will be covered by a purple veil: the synchroVeil 4. press a button with the synchro veil: all the buttons are synchroPressed flavors: single-use synchroVeil: veil is destroyed after it has been used once permanent synchroVeil: veil is not destroyed after it has been used to remove the veil, one should alt-click on the veil (triggers selection but does not trigger press), and then removeObject() 29 juin 2023: ****icObj.type = "peer" : visual p2p workflow: 1.spawn icPeer object: a p2p node with a generated id_peer 2.type the username of your choice for this icPeer object 3.type the groupName of your choice for this icPeer object 4.input target peer: flavors: -type IP of target peer -scan qrcode of target peer -type the username of target peer (requires PeerNameServer) -if target peer exists in another tab, drag'n'drop target peer on icPeer object 5.press connect button: flavors: - single peer connection: => icPeer object only connects to target peer - group connection: => icPeer object connects to target peer and to their connected peers with .groupName == icPeer.groupName => the list of connected peers and the connection status with each of them is displayed => even better: a graph of the network is displayed 6.pull source(s) from icPeer object: incoming stream from objects passed by peers pull number source: numbers passed from peers 6.5 filter, etc. (as if it were a RxSignal) there may be easy constructs: example: pull text stream banner: an endless stream of text from the peers peer's icWebcam remote stream could be retrieved (and any other remote stream) 7.create sink(s): pathmade operator end is icPeer => the objects are transmitted 8.zoom-in in icPeer collaborative rect: => see other users' pointers and created objects, LIVE! (container could become contained by using a portal 9.zoom-in in particular peer in list: -peer's shared iC area: read-only: look what's in there read-write: edit this area as if it were yours -peer's screenPov: flavors: -observe: you see peer's screenPov but can't touch anything -accompany: you can use your cursor and manipulate objects but screenPov is peer's screenPov edu: this way of collaborating seems very promising **icSource: like icWell but can be coupled with a pathmade to create an icStream icObjects spawn from icSource **icSink: pathmade + icPeer at its end *facebook returns: every user has a board on which others can write zoom-in in author's pic brings to their board, to reply 04 juillet 2023: **freeDrawing: fillBrush::radial workflow: 1. start drawing in surface to fill 2. moving mouse pointer changes fill radius **freeDrawing: fillBrush: matter workflow: 1. start drawing in surface to fill 2. moving mouse pointer changes fill matter amount => filled object's dendrites with small surface will be filled before dendrites with big surfaces edu: expliquer la pression dans les tuyau, la percolation **freeDrawing: fillBrush::flare brush: radial fill but with fill "shadows" like a light source ***icObj.type = "perception": change perception via clicking on this button ****through X's eyes/XVisionScroll: change perception via scroll perception flavors: - see colors in arr_color - see content created by arr_author - see objects with .type in arr_type ... examples: Seb'sVision Kev'sVision InvisibleInkVision colorX+colorYVision userAgentVision (see things dedicated to ip address, etc.) edu: géographie: mettre en avant différentes couches de contenu sur une carte ***(*)perception picker/builder: create your own perception workflow example: 1.enter perceptionBuilder 2.pick color1 in iC 3.pick color2 in iC 4.leave perceptionBuilder => now, user can only see color1 and color2 in iC, the rest is not perceptible ***(*)perception drawing: what you create is only visible by perception which includes drawing.perception typical usecase: write private messages to Y (those messages are only visible to Y) cosmetiker: encapsulated perception workflow: setup: 1.spawn cosmetiker button 2.press cosmetiker button => you have now entered cosmetiker drawing mode 3. draw stuff 4.press cosmetiker button => you have now left cosmetiker drawing mode => cosmetiker button is now ready to use use: press cosmetiker button to show/hide cosmetic drawn stuff => edu: pour créer des indices, des aides, des commentaires qui ne sont pas affichés directement **[CS]explain scopes using perceptions at object level if obj1 has .perception:scope1, and obj2 has .perception:scope2, ... ***frameBrush/brushFrameScroll: brush tip can be changed via frameScroll workflow: to draw an animation sequence: 1.frameScroll to brush tip #1 2.draw with brush tip #1 3.move away 1.frameScroll to brush tip #2 2.draw with brush tip #2 ... computedFrameBrush: brush tip can be changed via frameScroll but it's using context to compute next tip ***bootstrapBrush: brush tip computation bootstraps from user's drawing (AI may be used) flavors: 1-drawing feed 2-drawing feed ... workflow (1-drawing feed): context: bootstrapBrush has not been fed: brush tip is standard disk 1. user draws something => bootstrapBrush is now fed a drawing, frames are computed 2. brushFrameScroll now gives a brush tip which is a variation of user's drawing workflow (2-drawing feed): context: bootstrapBrush has not been fed: brush tip is standard disk 1. user draws something 2. user draws something else => bootstrapBrush is now fed, frames are computed using the 2 drawings: frames before drawing1, frames in between, frames after drawing2 ... **boss mode: meeting: take icWebcams of employees in their 2Dhouses and gather them in meeting room meeting room's whiteboard is used and saved every meeting so every meeting has its own whiteboard boss controls screenPovs of employees, at least at start, when gathering them in meeting room **ghost tunnel: specific tunnel things are only visible when using the tunnel ghost tunnel entrance is the only thing visible when outside the tunnel (same as for bag) **gotopov path + ghost brush when gotopov animation is on or gotopov path is locked via povScroll, drawing with this brush creates a drawing that is only visible when following gotopov anim/povScroll => ghost tunnel graffiti **autolayout: align, center, ... edu: pour travailler sur les coordonnées, quand deux rectangles de tailles différentes sont centrés verticalement par exemple... **(*)languageScroll: change selected object language via scroll => edu: language learning object splatter: there is a myriad of concepts, key concepts are "around iC origin", the others are in the periphery remark: there is a common layout of concepts/words for each "common-culture" set of languages ***wordNatureScroll: scroll through all nature variations of word get verb from adjective, etc. *edu:proportionality: create calipers via alteration: 1. use alteration on composite to measure length of 2 objects obj1's length is measured using composite's caliper1: color1 rectA and color1 rectB obj2's length is measured using composite's caliper2: color2 rectA and color2 rectB 2. zScroll the 2-caliper composite 3. another couple of objects' lengths will be proportional to the first couple if they fit in the calipers **panScroll: return of the default scroll ***(*)easy: icObj.type = "IgniterButton": this button will prepare the right mode for next mouse(/key)Press (no need to press the keyDown for mode shortcut) this allows user to apply modifiers or entering special editing modes very easily workflow: 1.click on igniterButton => target mode will activate just before next mouse(/key)Down (depending on the target mode) 2.mouse(/key)Down => user starts drawing/moving something/doing stuff in the target mode 3.mode automagically unsets when user has finished typical usecase: freeDrawing with a special brush remark: one could add will/did hooks in order to create drawing challenges ?how can user set a custom igniterButton up? long press on button to lock it in target mode *icObj.type = "freeDrawingBleedingIgniter" workflow: 1.mouseDown in freeDrawingBleedingIgniter => even though no shortcut key is down, a freeDrawing starts 2.user draws something 3.on mouseUp, freeDrawing stops and flavors: single-use: igniter is destroyed many-use: igniter use count decrements and igniter is destroyed when igniter use count has reached 0 infinite-use: nothing else happens 06 juillet 2023: edu::take picture of student's paper notebook: lien ordi <--> téléphone à la ChingView(1) **edu: tube operator: it takes some dragging to traverse operator (like a conveyor in a factory traversing a machine) there is a landing entrance for input there is a launchpad for output edu: pour insister sur l'existence d'un input et d'un output du point de vue de l'opérateur 17 juillet 2023: *semantic drawings: example: 1.user draws a character with a face 2.when user draws something which seems to hurt the character, character's face automagically updates to a face showing pain (command is now written !! *!plague! command: selected object suffers "plague": tentacles spawn from random parts of it (like chtulu font) **freedrawing:z-followable ghost brush: after it has been drawn, if looker starts looking at stroke start and if they continue following stroke (it may mean zooming/dezooming), stroke will remain visible **z-aware qrcode/bloom filter reader: screenstamped image workbench + (black) stain on any pixel of workbench that is not already colored => code is validated only if the path followed by user corresponds to the code **security cameras (layout): top view of house has each room filled with icWebcams => we can follow someone moving in the house (geom space meets topologic space) ***freeDrawing::fly brush: brush tip sattelites randomly around brush pointer => allows differentiating classic handwritten text from fly-salted handwritten text ***(*)stuck instuctions curse: stick instructions (like up(100) or down(50), etc.) to object, then push start button (first object in stuck instructions list) to start sequence edu: pouvoir produire un code impératif à la Scratch zooming in cursed object shows the sequence of instructions ***(*)stuck context curse: stick function definitions to object by touching function edu: pouvoir montrer comment l'exécution d'un code change, _alors même que la séquence d'instructions reste identique_, en modifiant la définition des fonctions appelées **icObj.type = "audio": sfx on button press => pour les histoires pour les enfants => pour donner un peu de chair à des présentations à la powerpoint **externalization operator: [x => x.methodA()]: externalize call of method in touched object **student's phone as universal school equipment: calculator software for student's phone ((made in iC)) protractor software for student's phone ((?made in iC (with icWebcam)?) ruler software for student's phone ((augmented reality)): autocalibration using A4 page format square software for student's phone ((augmented reality)): put phone on arm and draw over ar-projected square drawing compass software for student's phone ((augmented reality)): put phone on arm and draw over ar-projected circle 18 juillet 2023: **composition challenge: un chien, une poule et un crocodile: trouver le screenPov, qui contient de manière pas trop petite, tous ces éléments edu: on peut fabriquer des "zDroites", sur lesquelles sont affichées, régulièrement espacées, des zGraduations le jeu est de trouver un screenPov qui contienne "un multiple commun" de toutes ces zGraduations (on peut imaginer plusieurs zDroites poule, plusieurs zDroites chien, etc., pour que le challenge ait au moins une solution) **valueScroll(icText): valueScroll("aaa") ==> "aab" **charScroll(icText): move _activeChar selection_ on string via scroll, to be able to valueScroll selected char specifically => digitScroll(icMathNode) **icObj.type = "p2p_rendezvous_server" => dnd this object in icP2P for an easy configuration *pathmade operator: remark: pathmade operator could be used as a "super projector" to send all touched objects to path.point__end 19 juillet 2023: **[project onto] operator/ !project onto! command: build workflow: 1. enter building mode 1. select line or segment 3. leave building mode => operator spawns under cursor use workflow: (0. move operator where you want 1. touch projector edu::math: on pourrait créer des challenges GM dans lesquels il faut rejoindre l'arrivée en utilisant uniquement les projecteurs proposés edu::math: cet opérateur pourrait être utilisé, après que l'utilisateur ait rangé horizontalement des nombres sur son screenPov 2D, pour récupérer la séquence de nombres sur un segment 1D (typiquement, on projète sur une droite en bas de l'écran) **lightnessScroll: fade to black/white (HSL) shortcut: C.V.mouseWheel **easy: HSLA: F1 F2 F3 F4 **freeDrawing: radialgradientBrush: workflow: 0. pick color__start 1. pick color__end _ at point__end _ 2. start drawing: color at point is computed as mean(color__start, color__end, [distanceTo_point__start, distanceTo_point__end]) distance could be radial, or more complex with a set of light/dark paths which would be used to explain topography *freeDrawing: zIndexToLightnessBrush: When drawing over a deep object, it paints it dark. When drawing over a top object, it paints it light. **(*)zSegment: [AB] with A(x_A,y_A,homeScale_A) and B(x_B,y_B,homeScale_B) (on ne relie pas des points mais plutôt des disques) flavors: - freeDrawing zSegment: start drawing at point1,scale1 and end drawing at point2,scale2 a zSegment preview is constantly displayed as user zooms in and out - joining zSegment: select obj1 at homeScale1, select obj2 at homeScale2 and system spawns zSegment(s) joining the 2 objects => edu: une manière de faire de la perspective par essai et erreur (il faut faire correspondre les zSegments avec le quadrillage de perspective en background) => fun: labyrinthe bizarre en perspective avec des niveaux (comme si on pouvait marcher sur les murs) remarque: on pourrait étendre le concept avec des murs pas forcément en ligne droite ***zSegment from 2 "zPoints" => fun: create an array of zPoints and ask user to recreate original scene by creating the relevant zSegments or more simply: ask user to connect the numbered zDots (== "connectTheZDots") each segment could be assigned a preset color so that the final drawing colors are slowly revealed dev: how to generate such puzzles by hand ? how to generate such puzzles automatically (from a famous painting src image for example) ? **(*)zHalfLine: [AB) with A(x_A,y_A,homeScale_A) and B(x_B,y_B) (on relie le disque A au point B) ***easy: zBreak: select a part of a composite, zIndexScroll that part ==> the "following" parts are also zIndexScrolled typical usecase: "zIndex mingle" 2 objects _after they have been individually drawn_ **(**)backside website: iC as a decorator put a zoomScroll-based website (like gmaps) under an iC with transparent bg color so that when user zoomScrolls, it is forwarded to both layers => if the starting zoom is saved for both layers (==both layers are "synchronized"), one could work on decorating the bottom layer **ic::perspectiveMadness: there is a frontside "objects" layer there is a backside "perspectives" layer (in which there are areas, each with its own perspective) Wow effect #1: the resulting picture is strange because it holds multiple perspectives displayed seamlessly Wow effect #2: if you translate the objects layer, then the resulting picture changes in a very bizarre morphologic way 20 juillet 2023: **zVariants of everything that is usually 2D: point --> zPoint line --> zLine segment --> zSegment polyLine --> zPolyLine polygon --> zPolygon slider --> zSlider vibratingSegment --> vibratingZSegment curve --> zCurve **icObj.type = "zTelescope": zSegment + doing things (freeDrawing, moving objects, etc.) in zTelescope.lens__input actually happens in zTelescope.lens__output => on travaille à un autre niveau que le niveau naturel de l'objet (comme la chirurgie de précision) fun: on peut imaginer un zTelescope dans lequel lens__input est profond, et lens__output est devant ce qui est complètement bizarre *game: ic X ViewFinder: superimpose photograph to spawn new object challenge: gameplay: there are 2 kind of objects: characters and photographs each photograph has a duo represented on it. For example: {A: character1, B: character5} when you superimpose photograph.A over the character instance that is photograph.A: photograph__new spawns photograph__new.A = photograph.B, photograph__new.B = the next character to find on the iC initial context: 1 photograph a myriad of characters, each zlocated somewhere the goal is to unlock the last character: when superimposing the last photograph: this time it is the "challenge completed" character that appears (it has not been seen before) then a new challenge can start with n+1 characters (the old ones + the new one) (which may be shuffled in the world) and a new initial photograph... **icObjType = "icu": viewFinder + generator: superimpose icu on obj(==unlocker) to spawn new object(==generated/unlocked) edu: we may put unlockable object preview in icu edu: we may put icus at the start of a chapter so that students want to unlock the unlockers in order to get the icu.unlockable and play with them (the unlockable objects may be useful objects/pretty objects/funny objects... and since they are interactive objects, student cannot know what it is before having used it... surprise! 21 juillet 2023: **zSegment as a freeDrawing support: nice resize of elements on the zSegment when zSegment changes size/orientation un peu comme la décoration de font mais cette fois, c'est une décoration de trapèze *zArrow: zSegment + arrow spike(s) **(*)zSegmentComb: draw n zSegments at once **zSegment(obj1__any, obj2__any): each end of the zSegment is an icObject (not necessarily a zPoint) dev: extangents(obj1__any, obj2__any) =?= extangents(enclosing_circle(obj1__any), enclosing_circle(obj2__any)) *zGraph: nodes are zPoints and edges are zSegments(/zArrows for oriented zGraphs) special case: zStarGraph: 1 root node and (n-1) leaves edu: zStarGraph could be used to display multiple usecases of a same number/concept/formula (like a mind map) *zCube: each vertex is a zPoint, each edge is a zSegment edu: un cube avec une faible opacité pour bootstrapper des scènes en perspective on peut aussi utiliser plusieurs zCubes pour placer des volumes conteneurs pour les objets que l'on veut représenter 22 juillet 2023: *photo gallery using ic zoom on someone's head to see pics in which they appear zoom on object to see pics in which it appears (example: an ace of spades) zoom on year to see that year's pics (lasso)select 2 persons and zoom on selection handle to see pics with the 2 persons ... *zStarFind: zoom on obj --> portal --> zStarGraph: workflow: 1.user enters finder mode 2.user dives into obj they want to see occurences of (2.5.user leaves finder mode (system has now understood what is the object they want to find) 3.user dives into a portal which brings them to a zoomed-out view in which there is a zStarGraph: object appears as star graph root, and there is a zSegment for each occurrence of the obj in the canvas edu::litterature: voir la répartition d'un certain mot dans un texte (quand il apparaît, quand il est répété beaucoup de fois...) 23 juillet 2023: *zSegmentPrism: flavors: - zSegmentPrism(n) will spawn a zSegmentPrism of a regular polygon - zSegmentExtrusion of src object *crossing the rubicon: add a 3D canvas over the 2D canvas and control the rendering order of objects of the union in a single controller use a shortcut to draw in 2D canvas use a shortcut to draw in 3D canvas (actually, Blender::GreasePencil is already doing the job amazingly!) 24 juillet 2023: transformer de la 2D en 3D, ça commence par assigner des zIndex à chaque objet (2.5D) **(**)easy:autoZIndexGradient: drawn object will automagically be zIndexed (precisely, by splitting object if needed) when zIndex of each its ends is known typical workflow: 1.start freeDrawing, adhering obj1 (at zIndex1) 2.stop freeDrawing, adhering obj2 (at zIndex2) => zIndex gradient (zIndex1 --> zIndex2) will be assigned to freeDrawing smartAutoZIndexGradient mode: any update on an object of the canvas will trigger a potential recomputation of the zIndexes/zIndexGradients fun: this may create bizarre rearrangements *!recompute adherence hierarchy! workflow: 1. select all the components of an object (adhered or not) 2. !adhere!;!recompute adherence hierarchy! ==> all components are adhered and the hierarchy is satisfying (or at least non-deceiving) **(**)Proportional Editing (as in Blender): transform selected elements while also affecting the nearby unselected elements 25 juillet 2023: !!omg: threejs-fabricjs-raycast: fabricjs as texture for threejs, wow! => it means they can live together well so if we are able to put threejs in fabricjs then we can do: fabricjs --> threejs --> fabricjs --> threejs --> fabricjs --> threejs --> ... ****threejs in fabricjs: workflow: 1.draw zSegments == draw 2D representation of 3D object (zSegments must be "compatible" == they must belong to/induce the same perspective) => threejs recognizes 3D object and spawns 3D object 2.draw as texture on 3D object **(**)icObj.type = "canvas": canvas is just another object there is a keyDownToggle or a keyUpABToggle to act in parent canvas => on peut ajouter un canevas _entier_ dans un autre canevas, puisque le canevas fils est déplaçable et entièrement navigable (et on peut décider de ne jamais revenir au canevas parent (c'est presque aussi grand) *viewFinderSeamsPuzzle: (de)zoom/pan in child canvas to display a seamless junction between the 2 canvases 20-square viewFinderSeamsPuzzle: each square is a canvas, this time it's about seaming the child canvases 1. find what needs to be brought back to zero zoom level 2. look for the right piece in each square canvas (there may be multiple candidates in the same canvas) **icObj.type = "traversteller": this object lives in multiple canvases at once (actually it lives in a world which contains its host canvases (it's an upper level object)) **"exit" object: when you are in iC__child and you see this object big enough, then if you dezoom straight back, you will get to iC__mother (like a hole in the ice) **easy: childCanvas in and out: if screenPov is in iC__mother's iC__child.rect then allow zoom out to iC__mother when iC__child.homeScale__entrance is reached remarque: c'est le même principe que pour sortir d'un portail (icPortal) *2DPlane-shardedSphere(3D): workflow: 1.screenPov can 3D-rotate around center point 2.when stopping rotating, screenPov is a 2D plane crossing center point user draws something, spawns objects etc. 3.user 3D-rotates around center point => drawn planes rotate as well => this results in a bizarre plane sharded sphere *show navigation history as a collection of pages put together horizontally in the canvas dev:ça pourrait servir pour mettre coronadenames dans iC (système de portes/sas) **easy: TH::fillerWithHoles image library: image is almost full: there are holes to be filled with an almost-full image, etc. th: to proceduraly generate treasure hunts like one would shuffle a deck of cards many flavors: - squares-only fillerWithHoles library (the simplest) - circles-only fillerWithHoles library - same-format-and-same-orientation-only fillerWithHoles library (same rect size, same ellipse size) - mixed-shapes fillerWithHoles library (the more complex) images may be raster images, svgs or even infinishutes slot.borderColor: filler2 with .borderColor:color2 would nicely be slotted in filler1.slot14.borderColor:color2 (filler1 may have .borderColor:color1 but we don't care) => we would that filler2 is slotable in filler1 more complex: filler1.slot14.borderColor is a reduce of [filler1.slot1.borderColor, ..., filler1.slot13.borderColor] fun: on peut créer un type de jigsaw puzzle avec cette logique de slotable/pas slotable (les pièces contiennent des slots) (on peut créer un puzzle basé sur la logique en montrant des tuiles cause/conséquence mais dont l'emboîtement est non-linéaire exemples: un personnage pense avec une bulle de pensée mais la bulle de pensée peut contenir des tuiles mères l'heure est indiquée sur chaque tuile 26 juillet 2023: **easy: capture store: capture screenPov, put it in a frame(==clone all objects in screenPov) and add the frame to the active store => créer une BD facilement: capturer quand la vignette nous plaît => une autre façon de créer des vignettes: la "photographie BD" edu: pour les cours ça peut être sympa de capturer les états du tableau, tout en continuant à travailler dessus 27 juillet 2023: ***(*)easy: freeDrawing: define_by_drawing(brush): define brush by drawing the output you would like it to have ***object brush: brush spawns objects along trail examples: icTextStreamBrush: a word spawns every (z)curvilinear abscissa distance (=> GPT_brush) icNaturalNumbersBrush: the next natural number spawns every (z)curvabs distance 28 juillet 2023: **le club des quilters: club des gens qui s'amusent en faisant des (z)collages/montages de tableaux célèbres dans ic (related: tiles.ice.org, zoomquilt (Nikolaus Baumgarten)) (d'ailleurs avec la stable diffusion... il existe des bibliothèques pour upscale du raster de manière très propre: waifu2x ncnn Vulkan (il faudrait un upscaler en direct 30 juillet 2023: échelle: scale (écailles = taille des tuiles sous-unité) VS échelle: zSegments emboîtés qui forment une échelle *zGraduation: une façon de définir une échelle en associant un facteur d'échelle à l'intervalle entre 2 graduations **(**)GPT_brush:: iC.scale<-->text.levelOfDetail: zoom: develop on a particular aspect dezoom: get more general from this point ***mozaic blind test: mozaic of grey cells, on click: track plays, hoverscroll is colorScroll: this allows setting cell's scoring team HUD displays scores by counting cells of each color screen gradually fills with colored cells (which give an idea of who's winning) (client/server: server(==party master/DJ) sees mozaic of cells with content (in order not to play the same kind of songs in too long a row) client sees mozaic of hidden/revealed cells. By default, client only spectates. edu: mozaic quiz: same principle with: math expressions to evaluate questions to answer to ... ***(*)easy: DJing with big/small for common/uncommon(==shallow/deep): famous song of category 80's will be represented with a big square cryptic song of category 80's will be represented with a tiny tiny square (and will require some zooming to be clicked on) 31 juillet 2023: ***keyboardPan: keyboard arrows keydownTimeout: pan => ce serait un moyen de dessiner avec le stylet tout en contrôlant le screenPov avec le clavier ***easy: (z)Tongue: (z)Segment X gotopov: when touching (z)Tongue tip (==(z)Segment.zPoint__end), screenPov or object is dragged to mouth(==(z)Segment.zPoint__start) à la HalfLife::Barnacle 2 flavors: single-use everlasting *canvas1 in canvas2 in canvas1: instantiate icCanvas object in canvas2 with existing infiniteCanvas (==infiniteCanvas1) in constructor args dev: faire en sorte que ça se comporte normalement (==sans effets indésirables de résonance/echo/larsen) 01 août 2023: ***orthScroll(comb) ==> square comb / mesh comb **(*)anyComb: comb with points anywhere, of any size **KeyI as import mode: keyUp(I): import image I.V: import video I.ALT.V: import webcam I.A: import audio I.ALT.A: import microphone etc. **(**)music path: pathmade operator + [audio] touchSlots on the path this allows creating music combpathmade to create different instrument channels **easy: play only when touching: [audio] or [video]: track plays only when object is overlapping track's obj rect 2 flavors: elastic (==stateless): track then goes back to initial position plastic (==stateful): track sticks to ending position **easy: record microphone => create audio samples by mouth, and then kebab them on a pathmade **icObj.type = "json": display json as a graph in ic ***zTranslation: clone then shift object by same distance _at any homeScale_ (same effect as with comb zscroll) => this allows **icObj.type = "note": music note **frequencyScroll/pitchScroll: => to easily create notes for music path spawn A(440Hz) and then change tone via scroll edu::musique: ça monte et ça descent **(*)icObj.type="timeTrack": object.x__on_timeTrack <--> object.time it's as if the object to playback is the slider knob and the slider background is the timeTrack when pressing play button: all the objects on the timeTrack start moving to the right and play => synchronize objects => edu::musique: créer des canons facilement (on peut deviner un motif de création: puisque qu'on peut mettre le grand dans le petit, on peut mettre les objets dans leurs contrôles 02 août 2023: **QRBlindtest: blindtest X QRcode-back cards on passe la carte au dessus du téléphone pour jouer le morceau celui qui a trouvé récupère la carte celui qui a le plus de cartes à la fin a gagné (sur le verso, on peut éventuellement mettre une couleur qui correspond à la catégorie de musique **freeDrawing: insideOutBrush: brush tip's facade is drawn object: when drawing, stroke does not appear "outside", stroke appears in object in facade **easy: math: numberDipping: dip mathNode in numberLine to assign value edu: puisque l'assignation ne se fait que lorsque l'on déclenche !dip!, on peut demander juste avant aux élèves la valeur qui va être assignée **(*)easy: spatialized audio: control volume of icAudio/icVideo/icMusicPath by putting it in front/sending it to back => DJ has an automatic crossfade, simply by moving from track1's room to track2's room (via gotopov for example) => spatialized music path will sound differently if listened from a static screenPov, or if following music flow using a gotopov path **(*)spatialized audio: user-defined perspective-based metric depending on how zSegments are drawn: if zSegment.point__start has .value:1 and zSegment.point__start has .value:3, then sound from zSegment.point__start will have volume:(1/3 volume of sound from zSegment.point__end) metric can be complex by using different coexisting perspectives **icObj.speed: when object is conveyed by pathmade operator, icObj will move at speed icObj.speed icObj.speed:1 => icObj will follow conveyor normally icObj.speed:0.5 => icObj will take twice as much time to complete the path (on peut retraduire toute la musique en transformant tout en objets et en déplacements **icObj.type = "scrollingLabel": label displays text strea *karaoke: use video + scrollingLabel + microphone dnd video link in icVideo text stream may be auto generated using voice recognition AI synchronization of scrollingLabel wrt music would be easily done via (hover)scroll and this setting could then be saved for later uses ([save sync] button) voice effects may be added to microphone audio stream ***(*)freeDrawing: voiceBrush: control brush props using voice: example1: pitch <--> brushWidth volume <--> opacity example2: pitch <--> color volume <--> brushWidth => this would be a nice complement to mouseWheel **pathmade operator::active/inactive path chunks: if path.chunkA.color is red then conveyed object has .canBeTouched:false along chunkA if path.chunkB.color is green then conveyed object has .canBeTouched:true along chunkB => this is an alternative to making a detour to avoid being touched by an unwanted touchSlot ***icObj.type="laserTrack" (à la Audacity): vertical laser moves on track at constant speed easy: zScroll audio obj ==> a deep version(==small wrt laserTrack) of obj will be played fast whereas a front version of obj will be played slow this may ease synchronizing audio samples (on revisite une ui super connue en la plongeant dans l'iC 03 août 2023: *présentation des 3 fichiers(programmashute, ic et still_shute) dans iC on pourrait même mettre des exemples en mettant des icCanvas forgés à côté des points à préciser => petit côté bootstrap d'iC dans iC :) *image::removeColor(activeColor, tolerance): clear all pixels with activeColor => utile quand on importe un jpeg ou un png avec un fond non transparent **(*)icObj.type = "zBigText": text is summarized with different zoom levels zoom in to have more and more details **BigText::bgImage: text chars are clip mask of bg image when zoomed out, we see the bgImage when zoomed in, we see text with colored chars => pour faire un portrait image+texte, ou un CV par exemple variant: "Image does not exist": any image that appears in iC is actually colored text 3D::3DzScroll: exemple: faire du skateboard dans un bol sur la table puis dans le cratère de l'astéroide au Mexique (le skateur change de taille de manière continue) **(*)easy:autoZMontage: given a collection of images, system automatically determines the best montage, _zScroll taken into account_, so that it all combines well dev: trouver la fonction qu'il faudra minimiser **(**)programming::"fractal programming": program object behavior inside object itself _by using self-reference(s) inside it_ => to access inner methods or inner vars dev: lol **freeDrawing::color="negative": color at point is negative of underlying color at same point **icObj.type = "icView": display what is captured by icEye icView may often be used as a screenStamp example usecase: paced reader text is in iC icEye scans text from start to finish, at a certain pace icView displays current captured text area in screenPov 04 août 2023: **serialization::local-link: if imported file's filepath is ic/local/res/ then don't save file, only store local filepath, as for if file is not found, we may ask user its location using a file prompt examples: des cliparts communs edu:un manuel en pdf => on peut alors parler de "décoration à la iC" de tel ou tel fichier de base, qui est requis ***restricted-access using local-link key encryption: some areas of the canvas would only be displayed if user has the valid key in their local keychain (valid key == valid key name + valid key content) edu: laisser de la vie privée aux élèves **easy: freeDrawing::LoremIpsumZTextBrush: workflow: 1. draw zPath => random text is dynamically written over zPath 2. edit zText with your text **(*)freeDrawing::SpeechToZTextBrush: stt + zText: tell a story as you draw a zPath, spoken text's writing accompanies zPath's drawing freeDrawing speed must be fast enough to have room to put the words on it *fading with time: objects unused for some time are automatically deleted serialized objects might be automatically deleted just after rehydration if they are spotted as unused at this moment 05 août 2023: **easy: auto zFacade(==doubleObject(facade,nothing) => leaves display of other objects behind it): workflow: ((comme d'habitude, c'est le workflow "humain", le workflow des enfants)) 1. draw obj1 ԐԐ"oh no", I wanted to write stuff inside/behind it33 2. zoom in obj1 so that screenPov is mainly inside obj1 3. press shortcut (IntlBackslash.F) => obj1 is no longer visible in screenPov 4. draw obj2 => dezoom, rezoom: obj1 is now zFacade of obj2 **local res: automatically spawn 1000 garbage objects on NewFile **(*)flatVideo: import video and display it like a book: a sequence of n images *flatAudio: import audio and display it like a book: a sequence of n 1-second-long samples **music::write on music sheet via freedraw **(*)photo album (biography): a life in pictures ***(*)3D (z)Teleport via 2D map transition: you are in a 3D room there is a 2D map on the wall (an iC) screenPov displays your current location: "YOU ARE HERE" you zScroll and pan so that screenPov displays locationB at homeScaleB you get out of 2D map and you are in 3D in locationB at homeScaleB (==your location and your "size" has changed) **[structure]ic X 3D: examples: - two iCs are facing each other in a 3D room: user has to find a laser beam source in iC1 and a laser beam sink in iC2 so that the door opens - escape game: you have to find clues and room key in an iC on the wall *tScale(==zScale for time): everything around you goes fast/slow whether you are at a big tScale or a small tScale 11 août 2023: ***edu::math: icObj.type= "zNumber__storeyed": example: 534.2: 5 is written at scale level "10^2" 3 is written at scale level "10^1" 4 is written at scale level "10^0" 2 is written at scale level "10^(-1)" 318 + 514: they are zParallelized: apparent distance between 3 and 5 is same as apparent distance between 8 and 4 0.02 * 0.02: multiplication as a scale transform **edu::math: scaleNumber: number is [[1.0.1.0]] at scale level 0, number is [[ [[1.1.0.0]].[[0.1.0.0]].[[1.0.0.1]].[[0.0.0.0]] ]] at deeper scale level, => any base you want: base may change at each scale level 3.17 + 6.986: zParallelize([[3.17]], [[6.986]]) in order to do: 0.000 + 0.006 then 0.07 + 0.08 etc. edu::math: additionner VS ajouter: additionner creates a new object, which usually initially has .value:0, to be used as recipient ajouter uses lhs as recipient **edu::math: decimal number additive decomp using zCells 3 4 5 2 1 6 9 8 7 central 1 is either full or containing carry **edu::math: fractions representation and operations using zDuo: 1 / 4 would be represented as flavor1: "out" [ ] [ [*] [ ][ ] ] [ [ ][ ] ] [ ] flavor2: "in" [ ] [ [*][ ] ] [ [ ][ ] ] [ ] ***celebrify: [[obj (scaleful)]] * [celebrify] = [[obj (scaleless)]] ***[structure]celebrityDiscovery: when scaleful icObject is nicely contained in screenPov, icObject becomes scaleless (==a celeb) edu::math:GeomDiscovery: PointDiscovery/SegmentDiscovery... when icSpotPoint is nicely contained in screenPov, icSpotPoint becomes icPoint (==the scaleless, geometric, point) **(*)"petite mort": [[obj (scaleless)]] * [tinyKill] = [[obj (scaleful)]] (c'est fini la célébrité example: [[icPoint]] * [tinyKill] = [[icSpotPoint]] **[structure]celebrityOblivion: when scaleless icObject is nicely contained in its capturing iC area, icObject becomes scaleful and captured in this area (==a nobody) ***absolute size tag/autoZScroll: change absolute size by adhering size tag to obj: it automatically zScrolls to satisfying homeScale screenPov follows zScroll animation **3D_in_2D::sphere: sphere can be rotated to draw on the other side **3D_in_2D::treadmill: treadmill can be dragged to draw on the other side => edu::math: symmetry: if treadmill is not opaque, we can see the flip side of something drawn on the front side **ProjectiveBrush VS NormalBrush: NormalBrush respects 3D model (==normal-wize) **zRoadTrack: bizarre no-loop/loop race track (à la Outrun), by following zPath track **(*)icObj.type = "dome": if icObj.dome = dome1 then icObj cannot outgrow dome1. Its living area is the insides of dome1. **easy: video decoration: video as canvas bg + VideoSmartMoveEngine: when video "moves left/right", then canvas pans left/right when video zooms in/out, then canvas zooms in/out ***easy: zPack: pack objects nicely workflow: 1. select objs 2. enter zPack mode 3. zoom deeper => system ensures objects are fitting in screenPov (system only changes position of objects) (4. you may zoom deeper till system can pack no more 5. leave zPack mode (6. zscroll the pack to desired location **ic::zText: non-linear tree of zText le livre arbre dont vous êtes le héro ***(*)3DRoom: 3DRoomViewfinderPortalIc: (=="infinitePortal"): iC is a container for portals leading to other 3D worlds workflow: 1. user chooses viewfinder photo by covering screenPov with it => user can then enter this portal(in 3D) (and other users may lock the previous one inside (à la Cube) by changing the screenPov in iC) ConfigurableHyperionHouse: (HyperionHouse == house composed by interconnected doors-are-portals rooms) portals are configured with your mood: HyperionHouse in chill mode (kitchen leads to living room which leads to house entrance) HyperionHouse in work mode (kitchen leads to workplace desk which leads to city center's restaurant) ***(*)3DRoom: iC as object provider: 2D pick: when in your room, pick the object from the wall 3D pick: when entered in a room in the wall, pick object and bring it back to your room (physics: ic::scaleForce: the interaction between 2 objects is determined by their relative scale only 1 force which has a different expression at each scale (continuous change) **(*)easy: p2p via qrcode scan by companion phone linked to iC: workflow: 1. scan your own iC phone-link qrcode => phone is linked to your iC 2. scan other canvas' qrcode => a connection to this canvas is now available in your iC ***(*)3DRoom::3DBrush: not a paint gun, but rather a brush painting in thin air => the 2 main scrolls can operate simultaneously: KeyUpToggle to enter/leave freeDrawingMode KeyDownToggle freeDrawingZScroll: moves to front/to back KeyDownToggle brushWidthScroll: changes brush width comme des pédales que l'on peut activer indépendamment l'une de l'autre KeyR to 3DRotate around brushTip in order to draw a tree in 3D, the 2 scrolls should often be used simultaneously ***freeDrawing::freeDrawingRotate: KeyR to rotate around brushTip 12 août 2023: **3DRoom::semi-Transparent canvas edu: pour dessiner/repasser sur le plan 2D ce que l'on voit en 3D derrière ***(*)3DRoom::3DAdherence: grow 3D object from iC "flat stain" when zooming out of iC, 3DAdherence object gets smaller it feels a bit like a pop-up book it would be better to use this feature on a _floor iC_ (children story environment grows bigger as it's told) (? leaf is tree seen from top ? (#self-similar)) 13 août 2023: **3D-->2D: different types of drawing modes: from very 3D to very 2D - projective - raycast with PointerLockControls - raycast with viewLock (la vue est bloquée mais en gardant le fov au moment de la capture par iC (=> la plupart du temps de biais) - orthogonal viewLock (on reste dans le monde 3D) - capture camera to face 2D canvas and change perspective to orthogonal (on sort un instant du monde 3D pour entrer en full 2D) **3DRoom::Chevalet: Paint on canvas(maybe transparent) what you see in the 3D world (which may still be in fov while painting) In a virtual 3D world, draw a representation of a 3D model on a 2D surface with a drawing tutorial ebook opened at your virtual side ***(*):Spawn iC in 3D world like a standard 3D object ***(*):Spawn 3DRoom in 3DRoom (à la "iC in iC") (resize using 3DZscroll) ***(*)2D3DMap: if a 2D palm tree is drawn on the 2D("floor") surface, a 3D palm tree spawns out from this location when seen in a 3D world *?*HybridPolyhedron: some vertices are in iC and some are in 3DRoom ****easy:3DRoom::backsideAdhered3DFreeDrawnRoom: create a backing 3DRoom for a 2D door drawn on iC wall workflow: 1. freeDraw a door in iC 2. move to canvas' back and 3DAdhere-freeDraw a room from that door => when door is nicely visible in iC's screenPov, associated 3DRoom is reachable and human-sized 14 août 2023: **InstantaneousNode/EquipmentOperator: node instantaneous value is [[node.raw_value]] * [operator1] * [operator2] ... (operators touching instantaneous node) when node no longer touches operators, node gets back to its raw value EquipmentOperator: node.value = node.raw_value * [equipmentOperator] (equipmentOperator does not affect node.raw_value) InstantaneousNode: all operators touching it are bridged as EquipmentOperators (a std operator touching Instantaneous will work as if it were an EquipmentOperator) example: a big mathNode with a lot of (commutative) operators inside 15 août 2023: **(**)edu:3DMathWorld: a big room with no ceiling and iC-covered walls for each particular math concept one wall for addition, one wall for multiplication,... each wall contains the lesson, videos, interactive math challenges, chew-on-this riddles, ... iC can contain a infinite number of related content => students may memorize concepts more easily edu:learningWorld: all discipline worlds are connected and create a vast learning environment ***(*)[structure]3D::scrollAcceleration: change move speed via scroll: locationA speed:10 -->-- speed:20 -->-- speed:40 -->-- speed:80 -->-- speed:40 -->-- speed:20 -->-- speed:10 locationB => may be useful to move from one place to another in big flat world **AOE-ZScroll(=="zHighlight"): zscroll current selection while keeping it zParallel with its surroundings (the whole object/area may spread for zoomed part to have room) example: bring an important part of a text to zFront (this may be equivalent to creating a bump in the usually-flat 2D surface) 18 août 2023: ***icObj.type = "crossing_portal": temporary portal extension: draw cPortalB.R immediate right-side surroundings '+etc.' when crossing cPortalB.L while pathmadeDrawing/freeDrawing/dragging object => 3DRoom:facingCportals: cPortalA.L in wall1.iC and cPortalB.R in wall2.iC this could mean ic1 --cPortalA.L->-cPortalB.R--> ic2 --cPortalC.L->-cPortalD.R--> ic3 --cPortalE.L->-cPortalF.R--> ic4 this could mean ic1 --cPortalA.L->-cPortalB.R--> ic2 --cPortalC.L->-cPortalD.R--> ic3 --cPortalE.L->-cPortalF.R--> ic2 this could mean ic1 --cPortalA.L->-cPortalB.R--> ic1 --cPortalB.L->-cPortalC.R--> ic1 this could mean ic1 --cPortalA.L->-cPortalB.R--> ic1 --cPortalB.L->-cPortalA.R--> ic1 (cPortal loop) hovering a pathmade that uses crossing portals previews the actual path (path is appearing continuous in screenPov) =>edu::CS: pretty pathmade loop exit: draw a loop and (auto)spawn a _conditional cPortalA.L_(==loop exit) in it *trace vs information: (==somewhere/anywhere for read/write in iC) write: une trace d'échelle n peut être uniquement réalisée par un scriteur ayant l'échelle n dans son intervalle d'échelles une trace d'échelle n ne peut pas être réalisée par un "petit" scriteur car il n'a pas accès au grand monde un scriteur ayant l'échelle n dans son intervalle d'échelles peut promouvoir une trace d'échelle petite read: le scriteur qui promeut doit bien sûr pouvoir voir suffisament petit il est naturel de ne pas laisser une vue globale au petit scriteur les traces sont les réalisations des informations *(***)"droits d'échelle": read/write rights read(==zoom level can only be in scale interval) on peut étendre les droits à des réunions d'intervalles en floutant certaines échelles write(==can only create objects in scale interval) collab: collab::crane promotion: a higher scale user may zScroll screenPov of lower scale user to bring them to a scale they were not allowed to in the first place collab::crane demotion: ...bring them down... collab::crane descent: a lower scale user may zScroll screenPov of a higher scale user so that they see low-level stuff and get their hands dirty **[structure]projectiveFunctionalContext(==modules)(go there using the associated crossing portal): object is used/transformed in the projective space: f(obj)=f(p(obj)) example: raiseVolume(obj) = raiseVolume(audioCtx(obj)) => du code plus propre car on associe une bgColor(ou une bgImage) à chaque contexte (math en blanc cassé, audio en violet clair, text en vert clair, etc.) les fonctions de chaque module sont rassemblées dans un cadre fini **[layout]book displayed as pixelart mosaic of bgColored pages when zoomed out 19 août 2023: ****easy: alice injection(traverse screen frontier by filming iC(using cam or phone)): workflow: 0. zoom/pan to desired screenPov 1. enter alice injection mode a qrcode + an image calibration pattern may be temporarily displayed in screenPov 2. put what you want to inject to iC over screen surface 3. trigger !alice_inject! system checks the differences between physical apparent layer(==iC on phone screen) and virtual displayed layer(==iC on laptop screen) => system then injects objects(say images) to virtual layer so that no difference remains some differences may be ignored (hand of user, body of user...) 4. leave alice injection mode edu: passer du matériel facilement du monde physique au monde virtuel edu: tableau numérique interactif généralisé fun: big magic stuff with theater-size screen 20 août 2023: ***3DRoom::alice injection: simulate "real world" alice injection in 3DRoom environment ***3DRoom::alice passthrough: room's 3D object is now iC's 2D object ****3DRoom:infiniteRoom:iC's concepts in 3DRoom (zScroll, freeDrawingZScroll, ...) collab: players may have very different sizes collab: high scale users, low-level low scale users (le costard et le cambouis) any-scale "gods" collab: les travailleurs de la 3D, les travailleurs de la 2D (les manuels et les intellectuels, hahaha) some users may be bound to a particular room or a particular iC any-dim "gods" 21 août 2023: *edu:math:challenge: puzzle: translation by dragging: while dragging, 'src-->dst' arrow becomes green when same vector as required (jsify: save any content as .js (so that we may import it easily using ) ***freeDraw:strokeMatrix: constrained line drawing using predrawn paths: stroke can only evolve in brush tip's nearest predrawn path in strokeMatrix (==snapping for strokes) example: strokeMatrix is grid (=> draw pixel art) edu:math: pour travailler les symétries en utilisant des dessins sur grille strokeMatrix is cartoon drawing => edu:dessin:la matrice de traits est comme un papier calque, qui peut être utilisé en partie, pour saisir un élément particulier on récupère la tête d'un personnage sur matrice1, le corps sur matrice2, etc. commande: !strokeMatrixify!: transform object to strokeMatrix ***[structure]cybernet::priorityMap: a double map(real world map + ideas map) with your todo stuff displayed in it priority: color:red for urgent stuff color:green for non-urgent stuff business: boss can see priority map of employees, manager can see priority map of teammates social: friends can see priority map of friends life is reduced to fulfilling existing items and filling map with new items *infiniteRoom::sound shift: sound is different when you are small ***freeDrawing::split-on-support-change freeDrawing: when stepping to a new support, a new freeDrawing begins freeDrawing__supportA.end and freeDrawing__supportB.start must be clipped for a satisfying display => this allows drawing over multiple tiles which, when moved, will keep their individual part of the freeDrawing => ultraeasy zJigsaw puzzle creation *punchHole capture/lasso capture: capture as img (2D, no-depth) capture as iC (2D with depth) capture as iR (3D with depth (and with 2D with depth)) 22 août 2023: *IF/iC:dungeon_of_text: each (square)room has a text in it (*stable diffusion in punch-holed image **[meta]follower/meta_engineType = "followerEngine": creates a follower obj for target obj follower obj is destroyed when followerEngine stops follower obj is constantly updating follower obj has icObj.isFollower:true and is not managed by standard layout loop (zScroll,etc.) its layout is relative to its target obj and is computed after target obj has updated **intersectionEngine: creates a follower composite which displays targetObj's intersection with other objects follower composite parts may be (if possible): - boundingBox union (==bg) - masks of intersecting objects (not necessarily displayed to user) - pixelwise intersection *game: make target intersection: pan until you find the displayed intersection (must pause for a while to prevent brainless rubbing) *math:burden operators: create composite with operands and operators: tree leaves are the only valid targets [[15]] * [burden: + 2] = [[ [[15]] [[+]] [[2]] ]] (== composite([[15]],[[+]],[[2]])) [[ [[15]]here [[+]] [[2]] ]] * [burden: x 3] = [[ [[ [[15]] [[x]] [[3]] ]] [[+]] [[2]] ]] [[ [[15]] [[+]] [[2]]here ]] * [burden: x 3] = [[ [[15]] [[+]] [[ [[2]] [[x]] [[3]] ]] ]] [[ [[15]] [[+]] [[2]] ]] * [()] = [[ ([[15]] [[+]] [[2]]) ]] [[ ([[15]] [[+]] [[2]]) ]] * [burden: x 3] = [[ ([[15]] [[+]] [[2]]) [[x]] [[3]] ]] **adhere::adhere extension: adhere on an object with a intersectionEngine should auto extend intersectionEngine to new object **floodFillErase 25 août 2023: **[structure]easy kart: draw circuit on 2D wall: it automatically appears in 3D zone and then go ride (and then, go out from kart and 3D-edit walls like a god) **stamp::bridging clones: when stamping object over multiple supports, clone object then clip clones to keep the "one-object illusion" (though it's actually a multi-clone bridge) **3DRoom::photoRooms(~~povStar in 3D): grid of square rooms, each wall in each room displays a photo. User can walk through walls. room1.wall__EAST displays crossfade_mean(room1.wall__EAST.img, room1.room__EAST.wall__EAST.img, distance_to_wall) room1.wall__EAST will display: at far distance: room1.wall__EAST.img 100% room1.room__EAST.wall__EAST.img 0% at mid distance: room1.wall__EAST.img 50% room1.room__EAST.wall__EAST.img 50% at close distance: room1.wall__EAST.img 0% room1.room__EAST.wall__EAST.img 100% variant: labeledRooms: wall displays next room's name, no crossfade, rooms are not empty. **edu::math:labyrinthLine-table: easy pseudo-randomization of exercises setup: 1. draw a square 11 x 11 table ([0 ... 10](vert) [0 ... 10](horiz)) 2. pick a random start square A 3. draw a labyrinthLine starting from square A use: student must fill the squares with square.value = operator(square.x,square.y) 26 août 2023: **3DZscroll:demo: plane ride: 3rd person view of plane which travels from A to B by zScrolling (takeoff, zScroll, landing) **3DRoom::different angle, different content: when looking at wall when 3Dmoving, wall radiated content changes with view angle when wall captures mouse for iC editing, it creates a new iC corresponding to the view angle ***3DRoom:3DFootnote: Mary * is dead: main text is written in 2D iC, footnote is written orthogonally, in 3Dworld who was his wife user can only read footnote when leaving orthographic 2D pov fun: escape game: wall1"the murder is" "Horace"wall2: player is given 3 hints: 1. state of wall1's iC (offset and scale) 2. state of wall2's iC (offset and scale) 3. a particular pov in the 3DRoom (position and lookat) so that when player moves to pov, player sees the 3DFootnotes aligned and can read the secret message **composite alteration::rest alteration(book): rest-alteration of page n alters [page n, ..., page last] **composite alteration::AtoB alteration: workflow: 1. select pageA and pageB 2. altere pageA => [pageA, ..., pageB] are altered 27 août 2023: **[real world]diaphragm-based freeDrawingZScroll pen with wheel in non-drawing hand **[touch]: control freeDrawingZScroll by moving phone near/away from user face (as if finger was in 3D space) **(*)edu::math: euclideanDivisionScroll: transform to (bq + r) with numberScroll(b) this operator/command is polymorphic: [[23]] * [euclideanDivision(4)] = [[4 x 5 + 3]] [[ [][][][][][][] ]] * [euclideanDivision(2)] = [[ [][] [][] [][] [] ]] usecases: [[bq+r]] * [x 10] = ? numberScroll([[bq+r]], +1) = [[bq + (r+1)]] or [[b(q+1)]] this can be used to find all the divisors of a number (==all bs where r==0) **gm:challenge:math: euclidean form: find q and r initial: [[b]] operators: bottom: a list of [x ], top: a list of [+ ] target: [[a]] gm is left in the form [[bq + r]] as in challenge::internal::mult_tables **zProportionalXCalipers: a tool like an X but with one part with ends at scale1 and the other with ends at scale2 **3DRoom: edu: simulate classroom in 3D: understand what student sees (fov) neighboring classmates are 'big' whiteboard is small when student is at the back whiteboard reflects solar light coming from windows understand what student hears (spatialized sound) this allows doing lesson study in virtual classroom **(*)iC as layer: spawn iC over iC as if it were a layer in paint.net edu::dessin: créer un bg layer avec des esquisses et des traits de perspective puis dessiner le 'vrai' dessin sur le front layer ***scaleWave: scale change is no longer linear: when user scrolls mouseWheel, scale may change greatly or poorly (scale__next = f(scale__current)) examples: parabolic scale change (there is a scale floor level) random scale change (screment after mouseWheel is random) (fun: AI: blind test avec gradient de paroles de chanson: (100,0) --> (0,100)) blind test avec gradient total (musique, paroles, tempo, ...): (100,0) --> (0,100)) 29 août 2023: **maths/ic: "f avec largeur" en tant qu'objet mathématique 2D, "fonction large" ? est-ce qu'on peut fabriquer un objet "dérivée", etc. ? **(*)[structure]game:"scale suit": character scale adaptation: when character is in a zPath corridor, its scale adapts to keep a constant height__character/height__floorToCeiling ratio 31 août 2023: **oldScroll(==vertScroll/horizScroll): keyDown: Shift.wheel, Shift.space.wheel => freeDraw::"snakeDraw": oldScroll while drawing *[structure]pyramidBook: from heavily summarized(1 page)(top) to full detail(all pages)(bottom) edu: one way to learn something would be to loop-read the different levels, starting from top level dev: generatePyramidBook(book__src) 02 septembre 2023: **[structure]newOldPencil: make a {pen and paper}-based document become a writable flat pdf examples: cahiers sesamath mots croisés, etc. *math: decimal trail as zPath Pi comme chemin de zoom apériodique: pour aller à la prochaine décimale, on zoome soit plus à gauche, soit plus à droite, etc. l'écriture décimale de Pi est transformée en une fonction continue est-ce que cette vision peut apporter quelque chose ? 1/3 comme chemin de zoom périodique : on va toujours sur le 3 03 septembre 2023: *zPerspectiveGrid: onePoint-zPerspectiveGrid: same behavior as zSegment, there is a front plane and a back plane 07 septembre 2023: **gm:challenge:math:mental math: different operation sets are used to create targetExpr and 'growingExpr' system ensures target expr value can be reached using usable operators 09 septembre 2023: **[structure]eduDemo: explain formula: when hovering a particular item of the formula in lhs, the corresponding terms are highlighted in rhs example: when hovering Σ in lhs, all the + signs in rhs are highlighted **gm::challenge:math: timescale operators: [+ 2 years ; + 20%], [+ 1 year; x 1,05] **(*)gm::challenge:math: sequences: [n <- (n + 1)] operator VS [curse: + k], [curse: x q],... GM can only have one curse at any time when GM touching new curse: new curse overwrites old curse sequence name changes and index is set to 0 [[i]]: [[u_0: ]] ops: [n <- (n + 1)] [n <- (n + 2)] [n <- (n + 5)] [n <- (n + 10)] [curse: + 2] [curse: + 3] [curse: x (1,5)] [curse: x 3] variants: [curse: + 20%] **gm::challenge:math: litexp: introduce symbols with emoji first use smileys as symbols and then shift to using x and y **gm::challenge: math: permutation operators **[structure]GM::previewTouchSlot: every touchSlot has a previewTouchSlot next to it while GM is touching previewTouchSlot, displayed obj is [[obj]] * [previewTouchSlot] when untouching previewTouchSlot, displayed obj is [[obj]] (obj has not been ) **icObj.type = "exposer"/icObj.isable: while obj is touching [exposer: ], it has .isable:true (it is now exposed) example: untouchable object will be touchable while touching [exposer: touch] => untouchable object can be operated on using [operator] _over_ [exposer: touch] remark: operators can also be exposed: [exposer] is a lift for argument to be a valid argument for [operator] 10 septembre 2023: **math: Simplifier.simplify_withPattern(expr, pattern) example: Simplifier.simplify_withPattern(3e^(i(2*Pi)/3) * 5e^(i(2*Pi)/5), "e(iPi)") **[structure]GM::curse: curse priority/curse X op.apply(): resolution sequence: early curse, op.apply(), late curse ***(*)ic's Leitner box: Anki in iC: every day, a custom memory-homework path is there for student to follow all the rememoration calendar boilerplate is handled by the system dev: using timestamps and flags, this shouldn't be too hard to set up the gotopov animation to go to the next challenge could be a way for student to dive back into context (animation may go from shallow to deep) 2 flavors: automatic: when student has completed the challenge, it is brought to next challenge manual: [goToNextRememory]: when student presses this button, it is brought to next challenge 11 septembre 2023: **(*)GM::game:math: mathematical flappy bird: at step == barrier.n, GM.value must be inside interval:[barrier.min, barrier.max] there is a countdown on the barrier to indicate when it should be validated all other operators are disabled in the validation step if GM.value does not match interval restriction during the validation step, the game is over touching operator counts as a step validating target counts as a step when barrier is passed: GM value is kept as is some operators change a new barrier spawns => flappy X curse: [[value(n+1)]] = [[value(n)]] * [GM.curse] player must change curse in order for value to go up / go down, scale up/scale down layout: ops: top: standard ops: pre_curse{ [+ 7] [- 8]} post_curse{[x 2] [/ 6]} bottom: curse ops: [curse: + 1] [curse: - 5] [curse: x 5] [curse: / 10] difficulty: easy: many operation paths can be used to pass barrier (from barrier spawn to barrier pass) hard: 1 or 2 operation paths can be used to pass barrier variant: blind mode: GM is not simplified after each step (so when player feels that GM.value is inside barrier, player may choose to validate) 13 septembre 2023: **(*)game:math: mathematical flappy bird::2D plane edition: target is a portion of 2D plane this game may be a GM game: GM.point must be inside portion at step == barrier.n this game may be a no-GM game: [[current]] is not reset when unheld 2 flavors: vectors complex numbers portion of 2D plane could be: a finite portion of 2D plane (examples: a square, a circle, a potato-shaped surface, ...) an infinite portion of 2D plane (examples: half-plane, angular-sector of 2D plane, ...) a set of points ... variant: formal barrier: barrier is not drawn in 2D plane, barrier is displayed with mathematical formulas variant: formal barrier + manual validation(==no countdown): when player feels that GM.value is inside barrier, player may choose to validate variant: formal barrier + manual validation(==no countdown) + pointDrag: point is freely moved by user until validation 2D plane may or may not be graduated examples: when barrier is {x > 0 ; y > 0}, we don't need graduations, only axes and their arrows when barrier is {10,5 < x < 11 ; 10,5 < y < 11}, we don't need fine graduations, unit graduations can be enough **icObj.type = "coordSystem": coordinate system with its own geometric objects let's call pointSystem a coordSystem containing a few points pointSystem can be mutated using specific operators [[pointSystem {A(1,0), B(4,7)}]] * [points.A: {x: x + 1}] = [[pointSystem {A(2,0), B(4,7)}]] [[pointSystem {A(1,0), B(4,7)}]] * [points.all: {x: x + 1}] = [[pointSystem {A(2,0), B(5,7)}]] "painting" a new point in the coordSystem makes the coordSystem its parent "painting" a segment in the coordSystem makes the coordSystem its parent etc. ***(*)inner ic can be mutated the same way as a coordSystem obj: imagine ic1 is the canvas of a student and the main canvas is teacher's then: teacher can mutate ic1 "the usual way"(hold/move/touch): [[ic1]] * [set povRect: lesson2.povRect] = [[ic1 (with povRect now moved to lesson2)]] [[ic1]] * [unlock math.chapter3.challenges] = [[ic1 (with math.chapter3.challenges now unlocked)]] [[ic1]] * [spawn operator [sqrt]] = [[ic1 (with [sqrt] in it)]] [[ic1]] * [clean litter] = [[ic1 (without garbage)]] many specific operators can be imagined for [[iC]] if ic2 is the canvas of another student, [[ [[ic1]] [[ic2]] ]] * [work together] = [[ic1 with a p2p link to ic2]] and [[ic2 with a p2p link to ic1]] true cybernetic power: worlds in your hands 14 septembre 2023: ***icObj.type = "scope": this object holds named vars (==a pair {name, object}) global scope is {all named objects in iC} an operator applied to an input scope will try to resolve wrt this scope fallback: operator will try to resolve wrt global scope example1: global scope: empty scope1: [[{x: 4, z: 100, myStr:"hello"}]] scope2: [[{x: 4, b: 39, myStr:"world"}]] [[{x: 4, z: 100, myStr:"hello"}]] * [x <- 12] = [[{x: 12, z: 100, myStr:"hello"}]] [[{x: 4, z: 100, myStr:"hello"}]] * [x <- y + 10] = [[{x: 4, z: 100, myStr:"hello"}]] , [[error: y is not defined]] example2: global scope: [[x: 4]], [[y: 4]], [[z: 4]] [[{x: 4, z: 100, myStr:"hello"}]] * [x <- y + 10] = [[{x: 14, z: 100, myStr:"hello"}]] ([[y]] has been found in global scope) **[structure]GM::challenge:target is "obj so that f(...args) == (f definition is shown to user) and args=[...obj.contents, ...globalScope.contents]" to complete challenge: - f must execute without errors - f(...args) must return valid output example: f(...args) { x = y + 1; z = 10; return (x+z);} global scope: empty [[{x: 4, z: 100, myStr:"hello"}]] * [f] = [[{x: 4, z: 100, myStr:"hello"}]] , [[error: y is not defined]] 15 septembre 2023: **icObj.type = "objectRelation": represent the simplest relation between icObj1 and icObj2 typical usecase: coordSystem1 <-oRel-> coordSystem2 ==> point-to-point relation edu: show a function and its derivative edu: show a triangle and its symmetrical image *edu:math: grid modulo: (x,y) is kept in a finite grid **edu:math: coordSystem family: how many meters is 94 centimeters ? when zScrolling a coordSystem of the coordSystem family, all other family members are zScrolled too example: coordSystem "centimeters" is at scale 10 coordSystem "meters" is at scale 1000 when zScrolling "meters", "centimeters" are zScrolled too coordSystem "meters" can be put over coordSystem "centimeters" to visualize conversion *edu:math: zPuzzle with coordSystems: coordSystem__piece has a non-zero origin, player has to find where to put it on a big background mother coordSystem coordSystem__piece may bave points on it so that, when zPuzzle is complete, player may create segments with the points, and get a hint to solve another riddle ***[structure]GM::challenge:math: initial and target are sequence graphs: each time an operator is used, point is added to graph and step is incremented: u_n becomes u_(n+1) initial: graph(u_0:4) ops: [+ 100] [- 1] [x 2] [/ 6] target: graph(u_0:4, u_1:8, u_2:16, u_3:15, u_4:30, u_5:5) variant: variation operators: [(u_n+1 - u_n) <- 4] [(u_n+1 / u_n) <- 3] ***[structure]GM::challenge:math: initial and target are func graphs: func drawing is animated between 2 graduations, then obj waits for next step operators: [slope <- (+4)] [slope <- (-4)] [continue as is (== move to next graduation with same func definition)] **[structure]GM is big object: GM may have 2+ touchable areas example: tA == touchable area [op5] [op6] [op7] [op8] [[tA]] [[ ]] [[GM well]] [[ GM ]][[tA]] [[target display]] [target touchSlot] [[ ]] [[tA]] [op1] [op2] [op3] [op4] ***[structure]GM is a program: GM is a sequence of instructions, operators add instructions, there is an [execute] operator next to [[target]] challenge: robot labyrinth, target is "robot is in target cell" add-instruction operators: [move left] [move right] ... [repeat] then [[3]] then [move left]: (the [repeat] instruction is incomplete and must be completed by touching a number and an instruction) challenge: calculation program add-instruction operators: [+ 2] [x 4] [^ 2]... [clone]: when [clone] instruction is added to calculation program, many things happen: names are given: first is named c1, second is named c2 all instruction operators are cloned and named [+ 2] [x 4] [^ 2] becomes: [c1: + 2] [c1: x 4] [c1: ^ 2] [c2: + 2] [c2: x 4] [c2: ^ 2] (([c1: clone] [c2: clone])) but we'd better allow use of only 1 [clone] [create c2:]: names are given: existing is named c1, second is named c2 all instruction operators are cloned and named [+][-][x][/] ("collapse" instructions): these instructions will respectively do c1 + c2, c1 - c2, c1 x c2, c1 / c2, and get back to "single value mode" so that we may use [clone], [create c2: 0], [create c2: 1], [create c2: x] again after that "collapse" 16 septembre 2023: **adhere::clippingAdhere: use object as clipPath for support: output object is the same type as support ***adhere::patternAdhere: use support as texture for adhering object: output object is the same type as adhering object example: you textureAdhere icText "ar" over an image, then if add something to the text so it becomes "artist", the new letters will also be painted with the support (if it overflows, you may use mosaic of support for example) **easy: freeDrawing adhere on pattern-backed obj (=="rubDrawing") freeDrawing adhered stroke is automatically and instantaneously pattern-backed too example: draw flame strokes over a flame image draw war scene strokes over a peaceful image **easy: freeDrawing autocolor: rubDrawing on a dynamic pattern which colors itself to match what the strokes are drawing this may be frustrating because the system may get a wrong interpretation what strokes are drawing 17 septembre 2023: ***[structure]challenge: forge a valid image: targetTouchSlot is a black image mask, there is a description of the image to make (using an external software (say paint.net) is recommended) a source image to be transformed may be given examples: short sword / long sword: [[initial]]: short sword image [[target]]: long sword image short sword / long sword (edu: create a mathematical symbol for slope: an almost-closed angle with an arrow on the side of the slope, the other angle side being the reference and a subscript R (R being the coordSystem used to compute the slope) so if there is another coordSystem named R', another slope may be written with R' as subscript 20 septembre 2023: **gm:challenge:math: limits: a pre-validation operator like [lim(y->Infinity)] is put next to targetTouchSlot a pre-pre-validation operator may ensure expression contains the symbol which is limit'd example: i: [[1 / y]] ops: [+ y] [+ 1] [× (-1)] [inverse] pre-validation: [lim(y->Infinity)] target: [[4]] **gm:challenge:math: swap(x,y) operators: [inverse: swap: num<->den] [commute: swap: operand__left<->operand__right] examples: [[4 + 5]] * [commute] = [[5 + 4]] [[4 - 5]] * [commute] = [[5 - 4]] [[4 ^ 5]] * [commute] = [[5 ^ 4]] [[3 = 2+1]] * [commute] = [[2+1 = 3]] ***(*)easy:ic CRM:"ic.web" needs a CMS à la WordPress/gutenberg (iC would be a webpage layout engine) => user has a personal content library which they can use to populate their own areas user would create their webpage easily (by DND etc.), and they may control their content in a dedicated webpage(or a dedicated ic area) personal content library may contain "content streams", i.e. dynamic folders with a dynamic number of stereotyped elements this may also be a way for offline users to control the content they use in iC like the "algebra" part of geogebra, this time it will be a complete "contentgebra" dev: check https://github.com/front/gutenberg-js https://github.com/youknowriad/standalone-gutenberg 21 septembre 2023: **ic: mini python interpreter: python as a DSL not all python would be included, but the essential for students to learn => gm:challenge:python example: i: [[def f():]] ops: [indent] [newline] [x = 4] [x = x + 10] ... ((pre-validation: [f()] target: [[14]] 22 septembre 2023: **easy: freeDrawing::CreateCompositeBrush: 2 flavors: all parts: everything that is covered by stroke will be in composite.parts composite.content is null content+parts: if stroke.begin starts covering an object, this object will be composite.content, the other covered objects will be composite.parts 23 septembre 2023: **as python scripts will be iC objects, a workaround for "f***ing stupid hanger server destroys input()" will be assignment of placeholders: example: def myFunc(): a = b = a + 10 return b [[myFunc()]] * [assign: 333] = [[myFunc() with a = 333]] then [[myFunc()]] * [eval] = [[343]] OR maybe even better: [[myFunc()]] * [eval] ==> a popover spawns near a, waiting for an input when user has set value, [[myFunc()]] * [eval] starts remark: this is close to Parsons' puzzles: https://github.com/js-parsons/js-parsons remark: [a = 4] is not the same as [\t a = 4] which is not the same as [\t\t a = 4]... **eduDemo: function and derivative: function is an object and an operator Say f is x |-> 3x²: [[4]] * [f] = [[48]] [f] * [derivative] = [f'] [f'] * [show formula] = [x |-> 6x] [f'] * [extract expr] = [[6x]] [[4]] * [f'] = 24 [f'] * [derivative] = [f''] [f''] * [show formula] = [x |-> 6] [f''] * [extract expr] = [[6]] 26 septembre 2023: **ultra easy: W.mouseWheel: numberScroll if numberTyping input is empty: consider it was 0 **(*)GM:cashier: given price and incoming money, give correct amount back to customer layout: initial: [[0]] ops: [+ 1] [+ 0.1] [+ 0.01] [+ 5] [+ 0.5] [+ 0.05] etc. ("pick money" ops) central area: [[price]] [[incoming_money]] target: [[?]] ***[structure]obj contains multiple operands: _while held_, user selects active operand with WASD or arrows [[ 4 [10] 5 ]] * [x 3] = [[ 4 [30] 5 ]] command(arrow_right, [[ 4 [10] 5 ]]) = [[ 4 10 [5] ]] [[ 4 10 [5] ]] * [- 3] = [[ 4 10 [2] ]] 27 septembre 2023: **gm:challenge:math: relative numbers: duo: [ [ 4 ] ] [ [ 0 ] ] [ - ] * [normalize] = [ - ] [ [ 12 ] ] [ [ 8 ] ] [ [ 98] ] [ [ 80 ] ] [ - ] * [normalize] = [ - ] [ [ 18 ] ] [ [ 0 ] ] **ic:freeDrawing: enclosed brush fill(==spill fill): fill happens radially from brush tip but not too far, only locally => this gives the feeling of coloring books, but with super powers ***[structure]gm:challenge: verbalize first: operator becomes enabled only after student has verbalized the operation, _with the correct result_ 2 flavors: speech-to-text based check human-based check: in a class context, teacher enables the operator when the student has spoken right **ic: sym command: L/R: reverse screen horizontally T/B: reverse screen vertically wrt segment or line: (any orientation) ***[structure]ic: "current state": a way of showing objects: say object is a list of 8 faces and current state is face #3 what we'll display is: face #3 _BIG_, and, inside face #3, _with an "almost invisible" tinier scale_, the whole list of faces with a selection indicator on face #3 0 create lib/written_operator.js [+ 1000] --> "ajouter 1000" (op only) [+ 1000] --> "ajouter mille" (op + operand) **GM:sqsqrtpow: explicit/shuffle: [2 x 2 x 2] * [x 2] = [2 x 2 x 2 x 2] [2 x 3 x 2] * [x 2] = [2 x 2 x 2 x 3] **[structure]gm/internalisation: vocalize: TTS at each step: (Sandrine Cacheton) example with mult tables: [[1]] * [x 6] = [[6]] vocalize: "six" [[6]] * [x 7] = [[6 x 7]] vocalize: "times seven" [[6 x 7]] * [validation: 42] = [[Completed!!]] vocalize: "forty-two" OR "is forty-two" (we don't say equals because it's too long (prosody is important)) => student hears "six times seven is forty-two" we can also vocalize on hold: hold([[x]]) vocalize: "x" [[x]] * [+ x] = [[x + x]] vocalize: "plus x" [[x + x]] * [validation: 2x] vocalize: "2x" OR "is 2x" **[structure]gm/paced internalisation: tic tic toc pause tic tic toc pause tic tic toc pause ... layout: [[maybe target]] [[maybe target]] [[initial]] [op] [[maybe target]] [[maybe target]] [[maybe target]] example: [[12]] [[20]] [[6]] [x 6] [[32]] [[36]] [[45]] player has to complete a series of ten steps by following the pace suggested by sfx and gfx tic tic tock pause hold([[6]]) [[6]] * [x 6] [[6x 6]] * [validation: 36] load next step edu: tic tic tock pause vocalize: "six" vocalize: "times six" vocalize: "is thirty-six" **(*)[structure]gm/rockClimbing: player must find a way, using single-use operators, to validate, in order, each element of target _sequence_ (default: 3 values) there may be multiples ways to complete challenge layout: initial ops: 10 ops(or maybe more) (need to build some to get an idea of optimal number of ops) target: [target #1][target #2][target #3] 28 septembre 2023: ****(*)ic: varSlot: GMWell + dropping object on it results in assignment (this mimics how variables work) + "GM dying on top of varSlot" results in GM.value is assigned to varSlot flavors: untyped varSlot: you can drop any object on it typed varSlot: dropping an object with the wrong type on it does nothing, or throws an error a small error obj pops near typed varSlot a [printError] operator allows showing the error description on screen constSlot == GMWell (dropping an object on it does nothing) shortcut: varSlot: V.{type something} (like numberTyping) V while holding object: create varSlot with object (like clone) constSlot: V.C.{type something} (like numberTyping) ****edu: compute-it++: this time with iC objects layout: left area: iC right area: instructions a b c [6] [ ] [ ] these are var slots ops: assignment: [<- 4] [<- "lol"] unary ops: [+ 4] binary ops: [+] [-] (infix may be a good start) advanced: functions are first class objects operators can be assigned in varSlots operators can transform operators **ultra easy: edu: coloring book puzzle: scroll is colorScroll, click is floodFill => from pen and paper to mouse and computer example: color = f(log(expr)) colorize cell in yellow if evaluation of expression in cell is between 1 000 and 10 000 colorize cell in red if evaluation of expression in cell is between 10 000 and 100 000 etc. **curse: traceMouse: on hold, obj leaves a copy of itself in place on release, trace may be erased if object was solely moved, and had not been touched by any operator edu: pour montrer facilement des séquences de transformations [f] [g] [[a]] [[f(a)]] [[g(f(a))]] ... first movement second movement 30 septembre 2023: **curse: traceSplit: on hold, collection leaves one of its element in place traceSplit/first: on hold, collection leaves its first element in place traceSplit/random: on hold, collection leaves a random element in place edu: use traceSplit curse as a kick shortcut: [ **(*)ultraeasy: numberTyping::collection: W("1 2 3 4 5 6 7 8 9") Space is the separator ***icObj.type = "warpingOperator": result is position: transformation result is a warp so that obj.position mimics obj.value. This also happens _while obj is held_. "position" = x,y + scale (if object is transformed to something bigger / smaller) shortcut: KeyE examples: [[x: 2 ; y: 3]] * [+ (dx: 10 ; dy: 10) /warp] = [[x: 12 ; y: 13]] and [[x: 12 ; y: 13]] is now centered at position(x:12,y:13) [[2 + 3i]] * [+ (10 + 10i) /warp] = [[12 + 13i]] and [[12 + 13i]] is now centered at position(x:12,y:13) warp(collection): warp([[ [[1]] [[2]] [[3]] [[4]] [[5]] [[6]] ]]) = [[1]] is at position (1;0), [[2]] is at position (2;0),... warp([[ [[i]] [[2i]] [[3i]] [[4i]] [[5i]] [[6i]] ]]) = [[i]] is at position (0;1), [[2i]] is at position (0;2),... pointWarp: pointWarp([[2 + 3i]]) = [[2 + 3i]] is now a point at position (2;3) mixedScalePointWarp: mixedScalePointWarp([[2 + 3i]]) = [[2 + 3i]] is now a mixedScale point at position (2;3) (when zooming out, point is locked at scale 1, so point gets smaller) warp(text): semanticWarp: bring close to semantic cluster i.e. if text is the description of an image, bring text close to described image warp(anyObj): typeWarp: bring close to type cluster image next to images, mathNode next to mathNodes, operator next to operators componentWarp: bring close to other sibling components (to recompose a challenge for example) variant: valueAlign: warp wrt only 1 axis valueAlign__horiz valueAlign__vert variant: offsetWarp: offset is accumulated in a part of obj and offsetWarp() translates object by offset game: the_collector: use typeWarp to create collections of objects game:(math) top-down platformer: use offsetWarp to jump from one island to another and reach targetTouchSlot without falling/drowning there are many [dx: +1] [dy: +1] etc. [dx: +100] operators on each island to accumulate enough offset this could be a nice game since zoomIn/zoomOut would allow a clear view of possible paths **clone::mixedScalePointClone: create a mixedScalePoint from object with scale_max: current scale 04 octobre 2023: ***(*)easy: astro-operatorize: momentaneously turn neighboring objects into operators, use scroll to change operator example: context: screenPov contains [[4]], [[5 + i]] user holds [[4]] then invokes command !astro-operatorize!, so that [[5 + i]] is now [+ [[5 + i]] ] user scrolls so that [+ [[5 + i]] ] becomes [- [[5 + i]] ], [x [[5 + i]] ], [/ [[5 + i]] ], etc. (while [[4]] is still held) then [[4]] * [- [[5 + i]] ] = [[-1 - i]] and [- [[5 + i]] ] goes back to its original object form: [[5 + i]] ***structure: [again] meta operator/ !again! command: repeat last "real" operation edu: to show the repeated application of [x ()]: [[4]] * [x (1 + i) /warp] = [[ 4 + 4i]] at position (x: 4, y:4) [[4 + 4i]] * [again] = [[ 8i]] at position (x: 0, y:8) !again!([[4 + 4i]]) = [[-8 + 8i]] at position (x: -8, y:8) **(*)[structure]gm:challenge:math: warp(challenge): each time gm is transformed, challenge area is warped using gm.value, targetTouchSlot is far away and must be reached by successive warps gm cannot go outside challenge area either there is a safetyZone for gm or gm is not a gm (i.e. does not die on release) and there is a [die] operator layout: target: far away challenge area: gm and ops remarque: on se rapproche vraiment du golf **(*)easy: createAxis(mathNode1, mathNode2) use mathNode1.position and mathNode2.position to draw line, use mathNode1.value and mathNode2.value to draw graduations **axisBind: bind obj to axis so that its expr/value changes when moving eduDemo: functions: workflow: 0. create function f (for example: f(x) = (x - 3)² + 10 ) 1. create coords obj: [[(x,f(x))]] 2. axisBind [[(x,f(x))]] to axis x => when moving [[(x,f(x))]], the display is now [[(2,f(2))]], [[(2.1,f(2.1))]], etc. 3. repeat: 3.1. clone [[(x_a,f(x_a))]] at a particular abscissa x_a 3.2 ask students what is the value of f(x_a) 3.3. warp([[(x_a,f(x_a))]]) and compare with their saying => function graph appears after some iterations eduDemo: show circles, ellipses, and all that is defined by f(x,y) = 0 workflow: 0. create function f (for example: f(x,y) = (x - 5)² + (y - 2)² - 100 ) 1. create obj [[f(x,y)]] 2. axisBind [[f(x,y)]] to axis x 3. axisBind [[f(x,y)]] to axis y 4. change display mode of [[f(x,y)]] to display current value 5. move object around and clone object when its value is 0 => curve graph appears after some iterations 06 octobre 2023: **monoCollection: collection in which all (el1,el2) pairs satisfy isEqual(el1,el2)==true => we can define monoCollection operators: [[ [[a]] [[a]] [[a]] ]] * [+ 3] = [[ [[a]] [[a]] [[a]] [[a]] [[a]] [[a]] ]] **sumCollection: collection in which all elements of any subset can be summed => we can define sumCollection operators: [[ [[1]] [[10]] [[10]] ]] * [+ 3] = [[ [[1]] [[10]] [[10]] [[1]] [[1]] [[1]] ]] 07 octobre 2023: **[structure]scale suit: another consequence: jump as big and, in the air, shrink gradually, keeping most of inertia (weak air brake), to reach tiny high cavern as small player controls scale of character with LT,RT being big allows jumping high being small allows entering narrow spaces **(**)res link/ma petite page locale: dnd file explorer's ./res folder video to iC: only link to video is copied to iC. when playing link-backed icVideo, video content is accessed in ./res folder **collectionVessel: as vessel grabs objects, they are added to the cargo collection **collection::[transpose]/!transpose! (horiz layout, vert layout) ***historyEngine: all past states of object can be accessed via scrolling example: installEngine([[5]], historyEngine(".value")) [[5]] * [f] = [[13]] !historyScroll!([[13]]) = [[5;13]] edu: so we can then !warp!([[5;13]]) etc. to plot the function eduDemo: functionGraph: 1. create collection [[ [[0]] [[1]] [[2]] [[3]] [[4]] [[5]] [[6]] ]] 2. apply function operator [[ [[0]] [[1]] [[2]] [[3]] [[4]] [[5]] [[6]] ]] * [f] = [[ [[10]] [[2]] [[9]] [[7]] [[7]] [[7]] [[6]] ]] 3. apply !historyScroll! !historyScroll!([[ [[10]] [[2]] [[9]] [[7]] [[7]] [[7]] [[6]] ]]) = [[ [[0;10]] [[1;2]] [[2;9]] [[3;7]] [[4;7]] [[5;7]] [[6;6]] ]] 4. apply !warp! ***object-wise undo: operator and command [[5]] * [f] = [[13]] !owundo!([[13]]) = [[5]] [[5]] * [g] = [[0]] [[0]] * [owundo] = [[5]] remark: object-wise undo allows creation of GM transformation sequences with some "exploration" chunks i.e. you don't release GM but you go back to a previous state a GM transformation log(which would reset at GM death) would show which states have been reached so far **(**)eduDemo: auto function graph: loop(warp): pathmade + [f] + [warp] + [owundo] [pathmade] -->-- [if obj.value > 15: [die]] -->-- [f] -->-- [change display: history(1)] -->-- [cloneWarp] --v ^---- [+ 1] --<-- [owundo] --<----<----<----<----<----<----<----<----<----<----<----<----<----<---<---<--| remark: [change display: history(1)] could have been written [bloomScroll: history(1)] remark: cloneWarp == clone then warp the created clone -->--[cloneWarp]-->-- may be replaced by -->--[clone]-->--[split]-->--[warp] (ici on voit bien le "print" qui "sort" du programme) --<--| remark:use "atomify" operators for owundo to go back well -->--[begin atomic]-->--[+ 2]-->--[x 5]-->--[[leave atomic]]-->--[owundo]-->-- **numberTyping::locked mode: Shift.W: enterNumberTyping (locked) Enter: leaveNumberTyping example: Shift.W, "x|->3x+2", Enter ==> [x↦3x+2] is created [[10]] * [x↦3x+2] = [[32]] 08 octobre 2023: **icObj.type = "index": assign current value to touched and increment self [[346159]] * [index: 4] = [[4]] and [index: 5] [[4]] * [index: 5] = [[5]] and [index: 6] dev: can be made using 2 behaviors: ~assign on touch~, ~increment on touch~ **freeDrawing::winding number arithmetic: [[e]] is [[+1]]: a curve with winding_number:1 is treated as [[+1]] ↺ + ↻ = 0 ↺↺ + ↻ = ↺ ↺↺(x) = ↺(x)↺(x) ... carrier winding_number:1 curve could be treated as [+] sign operator carrier winding_number:-1 curve could be treated as [-] sign operator main object is not curve, main object is curving(i.e. the act of drawing a curve) so when we compose operations: ↺(↺) == drawing a wn:+1 curve (carried) while drawing a wn:+1 curve (carrier) ↺(↻) == drawing a wn:-1 curve (carried) while drawing a wn:+1 curve (carrier) edu: les nombres relatifs avec des boucles fléchées **[splitByRemoving()],!splitByRemoving()! [[1015]] * [splitByRemoving(105)] = [[ [[910]] [[105]] ]] [[ [[910]] [[105]] ]] * [splitByRemoving(210)] = [[ [[700]] [[210]] [[105]] ]] edu: 1015 / 7 == 100 + 30 + 15 == 145 **(*)gm:challenge:math: "big number" divisions: 1015 / 7: __target is rewritable__ idea: allow player to split [[target]] into a collection of smaller numbers via number typing while [[1015]] is held, enterNumberTyping, type("115"), leaveNumberTyping !splitByRemoving(105)!([[1015]]) = [[910]](held) and [[105]](left in place) etc. in the end, as [[1015]] == [[ [[700]] [[210]] [[105]] ]] player can deduce 1015 / 7 == 100 + 30 + 15 == 145 12 octobre 2023: ***icObj.type = "morphoContainer": container of 4-element collection is a big [[4]] with 4 slots on it container of 12-element collection is a big [[12]] with 12 slots on it remark: this is like a collection-specific core, displaying, at "first scale", its number of elements **gm:challenge:math: create affine func: f_a,b_ = (x↦ax+b), f_2,b_ = (x↦2x+b), f_2,7_ = (x↦2x+7) layout: initial: [[x↦ax+b]] operators: [a←0] [a←5] [a←7] [a←15] [b←0] [b←1] [b←8] [b←39] pre-validation: [* [[10]] ] target: [[50]] remark: [[f_a,b_]] * [a←5] = [[f_5,b_]], maybe we could find another operator symbol to say: [set parameter "a" to: 5] ((for example: [a⤶5])) **gm:challenge:math: create 2nd-order polynomial func: f_a,b,c_ = (x↦ax²+bx+c), f_2,b,c_ = (x↦2x²+bx+c), f_2,7,c_ = (x↦2x²+7x+c), f_2,7,3_ = (x↦2x²+7x+3) **(**)icObj.type = "error": [[-2]] * [sqrt] = [[✴]] error ignores looping, error bubbles up [[✴]] * [loop] = [[✴]] ignoring loop and continuing pathmade error may leave a trace from where it appeared to where it is finally caught [[✴]] * [catch]: error is processed by catch function **[parse] operator, !parse! command: [["3x+2"]] * [parse] = [[3x+2]] ***scope katamari: [[scope {}]] grows with statements, some functions consume statements, some leave them as is [[scope {}]] * [a←4] = [[scope {a:4}]] [[scope {a:4}]] * [b←5] = [[scope {a:4, b:5}]] [[scope {a:4, b:5}]] * [c←a+b] = [[scope {a:4, b:5, c:9}]] [[scope {a:4, b:5}]] * [c←a+b (consume)] = [[scope {c:9}]] subscopes: [[scope {}]] * [a←scope({a:10})] = [[scope {a: scope{a:10} }]] [[scope {a: scope{a:10} }]] * [b←scope({d:100})] = [[scope {a: scope{a:10}, b: scope{d:100} }]] [[scope {a: scope{a:10}, b: scope{d:100} }]] * [k←a.a+b.d, consume] = [[scope {k: 110}]] 15 octobre 2023: *definition operator: [:], [[f]] * [: x↦10x+4] = [[f]] (f is now a function and f(x)=10x+4) **gm:challenge:internal:function evaluation: layout: context: f: x↦10x+4 g: x↦-3x+4 h: x↦x+9 u: x↦-2x+6 ops: number forging operators: [+ 1] [+ 5] [+ 10] [+ 100] [x (-1)] initial: [[0]] (or any number) target: [[f(g(5))]] (or [[u(g(-1))]]), etc.) edu: for student to grasp the difference between f and f(x): context: f: u↦10u+4, g: v↦-3v+4 initial: [[a]], [[b]] (or any symbol) target: [[f(g(a))]] (or [[u(g(b))]]), etc.) **?[extractor]: [[x↦10x+4]] * [extractor: a in ax+b] = [[10]] [extractor: a in ax+b] could be written as [(x↦ax+b) ↦ a] (easy to read but bizarre "reverse func" scripting) [[ [[x↦10x+4]] [[x↦ax+b]] [[a]] ]] * [extractor] = [[10]] (ternary op) we could also write it [(x↦ax+b)↦a] **gm:challenge:internal:equation solving: linear equation this is the boss level of equations chapter **gm:challenge:internal:equation solving: any equation **InPlace challenges: center area contains a collection of objects, which can be mutated using operators, and put back in place. target is reached when collection of objects reflects what is shown on top area Releasing a mutated object prematurely (i.e. away from its snapSlot), puts it back in place, with its original value (as for a GM) example with English class: layout: top area: [image container: past] [image container: present] [image container: future] A man is lying quietly empty placeholder empty placeholder on a sepia photo. sentence: [[He]] [[is]] [[fine]] operators: [past] [plural] [swap: gender] target(not shown): [[He]] [[was]] [[fine]] [[is]] * [past] = [[was]] edu: once again, the nature of the objects is the way they are transformed on. ***(*)[structure]gm:challenge: "gm(x,y)": gm value varies with its position, target has a fixed position example: if gm is [[3x+2]], then if gm is at position {x: 5, y: 2}, its displayed value will be [[17]] if gm is [[x-y]], then if gm is at position {x: 10, y: 10}, its displayed value will be [[0]] so the challenge is to find the correct f(x,y) for gm so that f(target.x, target.y) = target.value ***(*)[structure]gm:challenge: "gm(t)": gm value varies with its lifetime 2 flavors: discrete: lifetime every second if gm is [[3t+2]], then, depending on its lifetime in seconds, gm value would be [[2]], [[5]], [[8]], etc. continuous: lifetime is refreshed as often as possible if gm is [[3t+2]], then gm value would be [[2]], [[2.000000003]], [[2.000000006]], etc. (evolving really fast) edu: discrete lifetime seems promising teaching-wise, continuous would require specific setups 17 octobre 2023: **gm:challenge:functions: [[initial]] is already forged in the form "[[f([[pre_initial]])]]" so that player needs to "f^(-1)(initial)" to be able to reach target example: pre_initial: [[10]] initial: [[sqrt(10)]] ops: [²] [+ 5] [x 10] [- 4] target: [[15]] ***unsure operator: operation result may be overwritten by reapplying unsure operator: [unsure: + 1] may be written: [?+ 1?] [[1]] * [unsure] = [[1 ??]] [[1 ??]] * [+ 5] = [[1 ?+ 5?]] [[1 ?+5?]] * [x 4] = [[1 ?x 4?]] (?+ 5? has been overwritten) [[1 ?x 4?]] * [assure] = [[1 x 4]] (?x 4? has been assured: it is now x 4) [[6]] * [?+ 1?] = [[6 ?+ 1?]] [[6 ?+ 1?]] * [?+ 9?] = [[6 ?+ 9?]] (?+ 1? has been overwritten) [[6 ?+ 9?]] * [!+ 4!] = [[6 + 9 + 4]] (?+ 9? has been assured by !+ 4!: it is now + 9) [!+ 4!] is equivalent to [ [assure] then [+ 4] ] remark: [unsure]/[assure] may give a little air to GM edu: random polling: [[6]] * [?+ random(1,6)?] = [[6 ?+ 2?]] [[6 ?+ 2?]] * [?+ random(1,6)?] = [[6 ?+ 5?]] (?+ 2? has been overwritten) [[6 ?+ 5?]] * [+ 10] = [[6 + 5 + 10]] (?+ 5? has been assured: it is now + 5) edu: unsure kick: "weak unsure": only next operator is considered unsure **apply operator: [*] 2 flavors: consume: [[ [[2]] [+ 6] ]] * [*] = [[8]] retain: [[ [[2]] [+ 6] ]] * [*] = [[ [[8]] [+ 6] ]] [[ [[8]] [+ 6] ]] * [*] = [[ [[14]] [+ 6] ]] remark: [[ [[2]] [+ 6] [*] ]] * [*] = [[ [[8]] [+ 6] ]] [[ [[2]] [+ 6] [*] [*] ]] * [*] = [[ [[8]] [+ 6] ]] ... ***gm:challenge:functions: bound vars / free vars : x ↦ x + 2 VS x ↦ a + 5 [[2]] * [x ↦ a + 5] = [[a + 5]] [[2]] * [x ↦ x + 5] = [[7]] [[2]] * [x ↦ ax + 5] = [[2a + 5]] 19 octobre 2023: (**?[define] operator: [[f]](symbol) * [: (x ↦ a + 5)] = [[f]](function), and now [[3]] * [[f]] = [[8]] define operator symbol is ":" 0 create challenges for every complicated word of mathematics **gm grid: a grid of GMs, others are disabled while one of them is held (or some of them are held) edu: function evaluation: pick the correct function in the gm grid and touch pre_validation [f↦f(5)] operator so that it's the same value as target **[structure]gm:challenge:propor: put everything on the plate (target area is a platform) a little lame but necessary, the idea is to make the player multiply every component quantity by propor factor it's repetitive but _it's made to be repetitive_ layout: label: " human symbol(s): * obj_A, * obj_B, * obj_C, * obj_D" initial: gm grid with [[A]], [[B]], [[C]], [[D]] ops: [x 2], [x 3], [x 4], [x 5] label__target: " human symbol(s)" target: platform operator harder: proportionnality with m < n (chercheur en choses simples, reparcoureur VS chercheur de pointe visiter la mine et passer du temps sur les galeries, faire en sorte de les élargir pour qu'elles puissent accueillir davantage de monde parce que les galeries "de passage" sont très vides pour l'instant **icObj.type = "probTree": non-pathmade branched conveyor operator _--->[ ] /p [ ]< \(1-p) ---->[ ] arrows are drawn from left-side ("source") targetTouchSlot 20 octobre 2023: **gm:challenge:lisp: write code using lisp operators example: [[(list 1 2 3 4)]] * [rest] = [[(list 2 3 4)]] **gm:challenge:APL: write code using APL operators (APL keyboard keys) **gm:challenge:num_expr/lit_expr via str__expr layout: initial: [[3]] ops: [append "+ 5"] [append "+ 7"] [append "x 2"] [append "x 4"] pre_validation: [morpher: str to math] target: [[13]] 04 novembre 2023: **(**)operator parametrization: how to achieve 2 3 ⍴ 1 2 3 4 in iC: late function definition: 1. ⍵_kick([[5 6 7 8]]) = [[5 6 7 8 (⍵_kicked)]] (OR: [[5 6 7 8]] * [⍵] = [[5 6 7 8 (⍵_kicked)]]) 2. [[5 6 7 8 (⍵_kicked)]] * [⍴] = [ [[5 6 7 8]] [⍴] ] 3. [ [[5 6 7 8]] [⍴] ] * [[2 3]] = [[ 5 6 7 ]] (late function definition: we know a function will be applied to [[5 6 7 8]], but the function ("2 3 ⍴") is only known at the end) [[ 8 5 6 ]] remark: we need ⍵_kick because ⍴ can be monadic or dyadic (OR ("reactor" way: ( ⍺_kick([[2 3]]) = [[2 3 (⍺_kicked)]] (OR: [[2 3]] * [⍺] = [[2 3 (⍺_kicked)]]) ( [[2 3 (⍺_kicked)]] * [⍴] = [ [[2 3]] [⍴] ] ( [ [[2 3]] [⍴] ] * [[5 6 7 8]] = [[ 5 6 7 ]] ("2 3 ⍴" is defined first and then applied to [[5 6 7 8]] the reactor's way) ( [[ 8 5 6 ]] **(**)monadic version of operator applies _on untouch_ and when can drop [[⍺]] on operator to make it dyadic dropping object on operator is possible because monadic version applies _on untouch_ 1. drop [[2 3]] on [⍴] ==> [ [[2 3 ]] over [⍴] ] 2. [[5 6 7 8]] * [ [[2 3 ]] over [⍴] ] = [[ 5 6 7 ]] [[ 8 5 6 ]] operator application could be forced monadic _on touch_ by dropping unconsumable [[None]] object on it **half-life, illustrated: create loop with [[particle]] and [random] operators which may lead to particle decay **ic::autosolver: automatically compute solution path (path-relinking) ***gm:challenge: group theory: [[a]] * [[b]] <=> a b ou alors afficher a et b de couleur noire et l'opérateur de couleur pâle [[a]] * [group.op b] = [[ab]] Group graph is gradually built as operations are made Groupe via présentation G = {S,R} **gm:challenge: abelian groups **gm:challenge: permutations **gm:challenge: involutions **gm:challenge: convolutions **gm:challenge: tft **gm:challenge: knots ***ic:autograph: any non-marked transformation 'a->b' is automatically marked on side graph ***ic:universal solution: [[universal solution]] * [testX] = [[True]] this object is a valid input for any test **[structure]gm::challenge:math: dual mental maths: challenge is time-based: the quicker, the better the goal is to find the result of a sequence of operations The challenge is dual: there is a way of manually applying the operations to the initial object, thus revealing the value which should be built but this value cannot be used to complete the challenge and of course, this is totally optional the true challenge is to create the result using the "build result" operators *(***)La nouvelle forme: exercices d'imagination Exemples: imagine un carré devant toi et fais le tourner imagine un triangle devant toi, fais en sorte que sa base devienne de plus en plus grande etc. Some of the challenges may be ic-backed: after a time of imagining, a solution may pop on the screen and then vanish after a little time The goal is to make student enhance their ability to mentally visualize situations 05 novembre 2023: **[structure]gm:challenge:math: gm is array example: initial: [[1 2 3]] ops: [+ 1] [x 2] (component-wise) target: [[3 5 7]] 06 novembre 2023: **un système d'équations peut être réécrit sous la forme "[eq1.lhs eq2.lhs eq3.lhs] = [eq1.rhs eq2.rhs eq3.rhs]" en utilisant des tableaux à la APL de chaque côté edu: peut-être que, l'équation étant présentée sous cette forme, les transformations magiques seront plus naturelles [2x 4x 6x] = [1 2 3] <=> [x 2x 3x] = [1/2 2/2 3/2] edu: les tableaux (à la APL) sont intéressants pédagogiquement parlant car ils introduisent une répétition (source d'apprentissage) dans l'objet d'étude on passe de la répétition de cas de figure à 1 cas de figure possédant de la répétition **gm:challenge: modular arithmetic and circular permutations: context: mod 5 [[0 1 2 3 4]] * [+ 1 (mod 5)] = [[1 2 3 4 0]] [[1 2 3 4 0]] * [+ 1 (mod 5)] = [[2 3 4 0 1]] **gm:challenge:functor: create func and then use it using functor cancels gm's curse [[6]] * [x ↦ (y ↦ xy + 5)] = [y ↦ 6y + 5] which can be released and used afterwise [[5]] * [y ↦ 6y + 5] = [[35]] [y ↦ 6y + 5] * [destroy_op] = ' ' operator can be destroyed to have so room layout: initial: [[0]] ops: [+ 1] [+ 5] [x (-1)] [x ↦ (y ↦ xy + 5)] [destroy_op] target: [[35]] **gm:challenge:ultramix: make player shift from one mathset (number set mixed with mindset) to another (==lift/unlift) counting: initial: [[2]] ops: [⍳] [⍴] [append()] [x ↦ 7x + 2] target: [[51]] edu: to achieve "* [+ 1]" user must do "* [⍳] * [append()] * [⍴]" 07 novembre 2023: **[structure]gm:challenge: bloomScroll required: solving challenge requires bloomScroll on gm or on operators variant: bloom-specific operators: bloomScrolling gm automatically bloomScrolls operators example: [["ten"]] [plus four] become [[10]] [+ 4] after bloomScroll([["ten"]]) edu: "registres de représentation sémiotiques" **[round] operator: [≈] monadic version: [[1.587]] * [≈ (0.1)] = [[1.6]] dyadic version: [[1.587]] * [ [[(0.1)]] over [≈] ] = [[1.6]] variant: keep precision [[1.587]] * [≈ (0.1)] = [[1.6 ± 0.1]] **ic:Singapore set: "bars" objects and operators set main object is a bar [ ] with an optional label/symbol/number on it [[ ]] * [assign value: 14] = [[ 14 ]] [[ ]] * [assign symbol: x] = [[ x ]] [[ ]] * [assign label: chicken] = [[ chicken ]] directional concat: [concat [ 3 ]] ←← [[ 2 ]] = [[ 3 ][ 2 ]] [[ 2 ]] →→ [concat [ 3 ]] = [[ 2 ][ 3 ]] same with up and down [[ 14 ][ 3 ][ x ]] ↓ = [[ 14 ][ 3 ][ x ]] [all: [ ]] [[ ]] [shift] operator may be used to shift between different ways of filling: [[ 14 ][ 3 ][ x ]] [[ 14 ][ 3 ][ x ]] [[ ]] * [shift] = [[ ]] [[ 14 ][ 3 ][ x ]] [[ 14 ][ 3 ][ x ]] [[ ]] * [shift] = [[ ]] etc. from stacks to flat: [ 4 ] [ 3 ] [ 5 ] * [normalize] = [ 4 ][ 3 ][ 3 ][ 3 ][ 5 ] [ 3 ] [ 3 ] [ 4 ][ 3 ][ 3 ][ 3 ][ 5 ] * [div: 3] = [ 3 ][1][ 3 ][ 3 ][ 3 ][ 3 ][ 2 ] [ 3 ][1][ 3 ][ 3 ][ 3 ][ 3 ][ 2 ] * [sort] = [1][ 2 ][ 3 ][ 3 ][ 3 ][ 3 ][ 3 ] [1][ 2 ][ 3 ][ 3 ][ 3 ][ 3 ][ 3 ] * [make 3s] = [ 3 ][ 3 ][ 3 ][ 3 ][ 3 ][ 3 ] gm:challenge:build correct bar representation gm:challenge:say if given representation is ok or not, and if not try to fix it ***(*)[structure]gm:challenge: operator pools: challenge area is composed of inner operator pools, which are accessed via zoomScroll or via gotopov zoomScroll deactivates gm: gm is no longer affected by any operator, except [reactivate] the main challenge area and each mini pool contain a [reactivate] operator (*****)AUI: A user interface (god form of ic): ic as a visual host for any language (i.e. "data" and operators) (*****)MN: Mathematical Nomenclatura: relational encyclopedia linking problems, operators, hints so that we could request a problem based on subject, "depth" (is it general maths or deep, sophisticated maths ?) **[structure]gm:challenge:pattern-based: target is implicit: it is the next of given sequence player must find pattern and continue sequence 3 flavors: target is next element target is complete sequence target is sequence of next elements **gm:challenge: drawing grid segments (horizontal and vertical) (smart drawing (==snapped drawing)), given constraints example: - must contain - must be of perimeter 20 - must be of perimeter 5x+10 **gm:challenge: target is area: user must draw surface area is displayed dynamically target area must be kept 3 seconds **easy: stacked solver: stacking operators on a [check condition()] creates a stacked solver if a sequence exists so that [[obj]] * [operator sequence of stacked operators] * [check condition()] = [[True]], then it occurs this is a mythical operator 09 novembre 2023: **gm:challenge:dict as rect layout: [ A[ 5 ] ] [ A[ 5 ] ] [ ] [ ] [ B[ A[ 2 ] ] ] * [dict[B][A] ← 10] = [ B[ A[ 10 ] ] ] [ [ B[ 4 ] ] ] [ [ B[ 4 ] ] ] [ [ C[ 8 ] ] ] [ [ C[ 8 ] ] ] OR dict * [focus(B)] * [focus(A)] * [← 10] [unfocus] (== move to upper level) target may be dict or value: use accessors to unlift dict to primitive types example: initial: [[ A[ 5 ] B[ A[ 2 ] B[ 4 ] C[ 8 ] ]] ops: [x 2] [dict[B][C]] [dict[B][C] + [dict[A]] [dict[B][A] ← 10] target: [[16]] [[dict]] * [dict[B][C]] = [[8]] (or: [dict↦dict[B][C]]) [[8]] * [x 2] = [[16]] edu: then player may try challenges with more textual representation of dict **gm:challenge:lisp: dict with 2 keys: "first" and "rest" **gm:challenge:complex numbers: more operators: [| |] [arg] [z ↦ Re(z) + 3i] ("opérateur d'alignement", projecteur) [z ↦ 8 + Im(z)] [as: alg] [as: trig] [as: exp] 13 novembre 2023: *ic::graphics: copie d'élève comme support **(*)ic:gm:challenge: Euclidea: challenge is to build target geometric object the workhorse for this is the _focus select_: freeDraw over what you want to focus on example: in a triangle named ABC, user may focus_select([BA] and [AC]) in a single freeDraw so that [BA] and [AC] are focused on [[triangle (focus: [BA] and [AC])]] * [bisect] = [[triangle with angle(BAC) now bisected (focus: bisector)]] **!focus_select!(anything): !focus_select([[5231]], 2)! ==> [[5(2)31]] [[5(2)31]] * [+ 4] = [[5(6)31]] ***(*)[simplify] as a HUD operator: this operator would then always be accessible (show HUD, make object be touched by [simplify], hide HUD) [[5 + 3i]] * [| |] = [[sqrt(5²+3²)]] ((!show HUD!)) [[sqrt(5²+3²)]] * [simplify] = [[sqrt(34)]] ((!hide HUD!)) 14 novembre 2023: **get100::crazy operators: (à la Calculator:The Game) [sum]: sum digits [reverse]: [[1234]] * [reverse] = [[4321]] [[1200]] * [reverse] = [[21]] (?[[4.2]] * [reverse] = [2.4]?) [inv10]: [[5021]] * [inv10] = [[5089]] [1]: concat with number [[8]] * [1] = [[81]] [insert 1]: [[46]] * [insert 1 (on slot 2)] = [[416]] [slot_add 4]: [[46]] * [slot_add 4 (on slot 2)] = [[86]] edu: this adds logic to the original get100 operator set ***(*)!herd!:contactless accumulation: while in herding mode, pointer can move to candidate object, then when leaving herding mode (and if candidate is herdable), it will belong to active group the active group would then be used on binary(or (2+)nary) operators there may be colors or even indexes to inform user what is arg#1, arg#2 etc. shortcut: Space (because it may be a very used feature) workflow: user is holding [[objA]] (mouse pointer is over [[objA]]) enter herding mode mouse pointer is moved to [[objB]] leave herding mode user is now holding {[[objA]],[[objB]]} (and mouse pointer is over [[objB]])) enter herding mode mouse pointer is moved to [[objC]] leave herding mode user is now holding {[[objA]],[[objB]],[[objC]]} (and mouse pointer is over [[objC]])) ... usecase: {[[5]],[[7]]} * [+] = [[12]] edu: on peut recréer le jeu "Le compte est bon" avec cette interface utilisateur ***[structure]gm:challenge: build initial (via longpress): player may build initial to suit their needs example with complex numbers: a longpress on the [[initial]] object spawns a coordinate system, in which, by moving mouse, user can easily point to the desired complex number they want to use, and then release lmb to assign this value to [[initial]] [[initial]] can then be used on challenge operators to finally reach target a [reset] button may clear [[initial]] and allow user to reassign a value 15 novembre 2023: *APL's ⍨ "Selfie" [commute] "trueOperator"(==acting on functions) may be useful: [[1]] * [⍨] * [ [[8]] over -] = [[7]] 16 novembre 2023: ***[structure]gm:challenge: "path to abstraction" challenges 0. [[target]] is hidden (target touchSlot is still displayed) but _a label with the requirements of the transformation is displayed_ example: "target is twice the initial" 1. user solves challenge with a given initial 2. at that moment, solving path is saved and replayed on other (initial, target) tuples (say 5 tuples) (initial, target) = (initial, f(initial)) example: "target is twice the initial" will yield (initial, 2*(initial)) replay speed can be set by user with a slider if _solving path_ manages to complete challenge with the given various tuples, then challenge is complete **edu:ic:program by drawing::a function is like a gm challenge with a solving path the gm layout: initial, operators and target is very close to the function layout: input, operators, output so we students are used to solving challenges, they can shift to building functions ***ic:program by drawing::recursion: a recursive function has one of its defining path branches moving outside-in one of the inner operations of recursive function f is to touch f's touchSlot, i.e. zoom out, touch, and get back in edu: debugging will be visual as, when following inner variable, we will see it zScroll out of f area, touching [f], and zScroll back in f area(and probably do that many times, until reaching output) **easy: create mini projector: [ [[from]] → [[to]] ] example: [["cat"]] * [ [["a"]] → [["u"]] ] = [["cut"]] workflow: 1.create [[from]] 2.create [[to]] 3.draw a vector from [[from]] to [[to]] enrich mini projector: 1.create [[from2]] 2.draw a vector from [[from2]] to [[to]] example: [["cat"]] * [ {[["a"]],[["c]]} → [["u"]] ] = [["uut"]] **value constellation: link elements so that, after a warp, it creates a broken line edu: from values to function graph: [[1--2--3--4--5--6--7--8--9]] * [x ↦ (x-3)(x-5)] = [[8--3--0--(-1)--0--3--8--12]] warp([[8--3--0--(-1)--0--3--8--12]]) ==> something like the graph of x ↦ (x-3)(x-5) **easy:fractal creation: wokflow: 1.select container 2."clone drag" container in one of container's cell ==> a fractal is made using this construct remark: adhere on fractal obj will update container and all of its replica "shallow draw" on fractal obj part(whatever the zoom level) will not mutate fractal obj **ic::execute(image) (in a textual language, one may do execute("code string"), but in a 2D "language" ?...) 17 novembre 2023: ***rebox: transform {pathmade operator + assets} into touchSlot operator workflow: 0.zoom out 1.enter rebox mode 2.rectangleDraw around the pathmade operator {pathmade operator + assets} 3.leave rebox mode ==> a rectangle touchSlot operator has been created user may zoom in touchSlot to see the contents of the function ****slotted rebox(==template rebox): use [placeholder] operators along pathmade which would appear as sideSlots next to rebox'd user would then put an operator in sideSlot, in order to have a realized operator an incomplete(==unrealized) operator will appear as "disabled" and a little square may be displayed near it to indicate that it's because there are still unfilled sideSlots this would allow programming by drawing by allowing composition of user-made operators each [placeholder] may have a tag that would appear in sideSlot, for ease of use (same as a named argument) remark 1: user may want placeholder to bubble high in the function hierarchy(i.e. create placeholder container) this is easily done by not filling the sideSlots, so that a function can use this rebox'd as a placeholder container _outer rebox'd will inherit inner rebox'd unfilled sideSlots_ remark 2: there may be optional placeholders: [optional placeholder] to avoid too much bubbling up from optional placeholders, one may use [nop] operators to fill the unneeded slots ***wiring rebox (rebox the rebox'd): wire 2+ sideSlots and rebox, so that, only one sideSlot now appears in wrapper **[fill sideSlot] operator: allow dynamic programming by building function via pathmade this may be a kick [myOp] * [kick: fill sideSlot] * [sideSlot: empty] ==> [sideSlot: [myOp] ] **[structure]gm::automX: given a set of operators (which may be a union of usually "distant" operators), check what challenges emerge a majority might be dull, but some may be interesting **[structure]edu:[edu::save]: bookmark challenge as "edu worth" edu: for teacher, this would be a way to build a collection of cherry-picked challenges edu: for student, this would be a way to signal that this challenge was "particular" 19 novembre 2023: ***(*)edu: vers une écriture plus concise des challenges 0 écriture plus concise des opérateurs 0 écriture plus concise de l'aléatoire 0 opérateurs obligatoires 0 ordre plus ou moins imposé pour l'utilisation des opérateurs 0 forme plus ou moins imposée pour la valeur cible 0 écriture plus concise de l'affichage (le format) exemples: afficher \sqrt(expr) au lieu de (expr)^(1/2) afficher uniquement des valeurs exactes VS autoriser des valeurs approchées afficher \frac{\pi}{2} au lieu de \frac{1}{2} * \pi 0 écriture plus concise des simplifications Il faut bien définir ce que l'élève est susceptible de voir, à chaque étape On arriverait à une sorte de formalisme pour définir précisément un challenge ou une famille de challenge 20 novembre 2023: **edu: vers une écriture plus concise des parcours de golf *create a bullet-proof parser in order to apply unregistered functions to math values mathNode__output = math.parse(Algebrite.run("arg(" + mathNode__output.toString() + ")")); //here unregistered function is Algebrite::arg a bullet-proof parser will "understand" what was meant in the input expr string 23 novembre 2023: ***(*)!apply!: appliable operators: These operators are not touchSlot-based. For operation to occur, !apply! has to be called when obj and operator are overlapping obviously, appliable operators have a specific display, to warn user that they're not good old touchSlot operators let's represent them with parentheses instead of brackets. Examples: (+ 2), (x>10?+ 6:- 5), (sqrt) !apply!([[obj (held)]] over (op) ) = [[obj]] * (op) Shortcut: (while object is held) rightMouseClick conversely, with any operator (touchSlot-based, snapSlot-based, appliable, ...): !apply!([op (held)] over [[obj]]) = [[obj]] * [op] Shortcut: (while operator is held) rightMouseClick (this is the same shortcut) fun: with !apply!, riddler may disseminate invisible operators, and have user finding them using coordinates, or sound hints, ... then player can use the operator, _even though it's not visible_, by using !apply!, when they feel that obj and operator are overlapping warning: a frequent use of this way of performing operations (instead of using touchSlots), may lead to 2 different "visions" of iC easy: numberForging (an alternative to numberTyping): a grid of appliable operators allow to create number (-)(7)(8)(9) (4)(5)(6) (1)(2)(3) (0) !apply!([[ 5]] over (2)]) = [[ 52]] !apply!([[ 52]] over (9)]) = [[ 529]] !apply!([[529]] over (-)]) = [[-529]] bubble or not bubble: if output is an operator, !apply! may operate again no bubbling: !apply (bubbling: no)!( (↦ (↦2)) ) = (↦2) bubbling: !apply (bubbling: yes)!( (↦ (↦2)) ) = [[2]] by default, !apply! is !apply (bubbling: no)! ***extended pathmade operator: a pathmade operator which also records !apply!-has-been-used events => conditional extended pathmade operator: each conditional branch of the pathmade operator has its own !apply! events ***temporary appliable operator forge: workflow: user spawns temporary forge user performs operations via appliable operators in forge user despawns temporary forge examples: numberForging forge math::algebra::forge math::geometry::forge textForging forge (kind of visual keyboard) *universal 'unboxer': [unfunc] [[f(g(x))]] * [unfunc] = [[g(x)]] gm:challenge: initial: [[x]] target: [[f(g(e(s(s(x)))))]] ops: [[s ∘ t]] [[a ∘ b ∘ c]] [f] [g] [h] [e] [unfunc] 25 novembre 2023: *La relation opérateur<->objet implique qu'ils soient de tailles compatibles Par conséquent, l'application de l'opérateur est parfois impossible, même si l'objet est sur l'opérateur. Un opérateur applicable: - quelque soit la taille de l'objet est appelé opérateur galactique (que l'objet soit bien plus gros que l'opérateur, ou l'inverse, l'application reste possible) - du moment que l'objet est plus petit que lui est appelé opérateur de champ **ic::behind the scenes: image of challenge creator face with opacity:0 is covering challenge bg challenge creator face's opacity can be brought back to 1.0 anytime **easy:operator creation: create("[+ 2]") ==> touchSlotOperator, create("(+ 2)") ==> applySlotOperator *(!)apply(!) event: apply event may be initiated by user, but it may also be initiated from elsewhere applySlotEngine may thus listen to any source capable of sending (!)apply(!) event **easy: operator-based eventSource: put operator over eventSource to make it send (!)(!) events typical usecase: paced eventSource: every seconds, it sends an event **screenPov-restricted eventSource: if eventSource is in screenPov, its events are only affecting objects in screenPov. Otherwise, they are ignored. edu: a slow-paced (!)simplify(!) eventSource will allow to show expressions gradually simplifying over time ***operator stack: (see: 18 juin 2021), 2023 update with applicableOperators [[3]] * [ [+ 2] /_ [x 5] ] = [[25]] !apply!([[10]] over ( (+ 2) /_ (x 3) ) ) = [[36]] **(*)freeDrawing X applicableOperators: examples: !apply!([[freeDrawingObj (held)]] over (insert 5 loops) ) !apply!([[freeDrawingObj (held)]] over (cellShade) ) 29 novembre 2023: *easy: constellation: via freeDraw: freeDraw a stroke over [[1 2 3 4 5]] to create [[1-2-3-4-5]] constellation ***var.homePosition: a variable with a homePosition goes back to it when released (as if it were a green mouse) this can be used to identify anonymous variables ***(*)[structure]object change: stepping from one instruction to another, _in a contiguous sequence_, is performed by changing of 'subject' this is the same effect as ";" in javascript or apl::diamond example: 1. user holds [[3]] 2. [[3]] * [+ 2] = [[5]] 3. while [[5]] is held, user enters 'object change' mode and moves mouse pointer to [[y]] => the object held is now [[y]]. [[5]] may go back to its homePosition (the position where [[3]] was picked from) 4. [[y]] + [- 3] = [[y - 3]] 5. user releases [[y - 3]] this sequence is not far from being equivalent to the block: { 3 + 2; y = y - 3; } {object change + home position} allows writing sophisticated pathmade functions **ic:opérateurs de réécriture spécifique: (see 11 mai 2022) (distinguer le calcul (arithmétique) de la réécriture) sans parenthèses: [sqrt(a) × sqrt(a) → a] [a → a^1] [a^1 × a^1 × a^1 → a^3] [a × b → eval(a × b)] [a × b × c → eval(a × b) × c] => énigmes de logique sur fond d'arithmétique exemple: initial: [[1]] ops: [× 2] [× 3] [× 4] [× 5] [× 6] [a × b × c → eval(a × b) × c] [a × b × c → a × eval(b × c)] target: [[10 × 18]] avec parenthèses: [a → (a)] (comme une sorte de marquage bricolé en détournant "()" qui permet de spécifier l'opérande du réécriveur) [(a × b) → eval(a × b)] [(a × b) × c → a × (b × c)] (réécriture associative gauche→droite) [a × (b × c) → (a × b) × c] (réécriture associative droite→gauche) [(a) × b → prime_decomp(a) × b] (prime decomp "sous" l'opération "× b") *remark: order of operations is readable if result is boxed after each operation example: [[box( 2 × box(box(4) × 5))]] we see that the operation sequence was [[4]] * [y ↦ y × 5] * [y ↦ 2 × y] ***iotaScroll: [[1]]<->[[1 2]]<->[[1 2 3]]<->[[1 2 3 4]]<->... iotaScroll([[5]], "up") ==> [[5 2]] ==> [[5 2 3]] ==> [[5 2 3 4]] iotaScroll([[7 4 6]], "down") ==> [[7 4]] ==> [[7]] ==> [[*]](==empty object) ***treeScroll: [] [] [] [] <-> [] <-> [] <-> [][] <-> ... [] [] 0 child 1 child 2 children 3 children treeScroll + focusScroll + treeScroll + focusScroll + ... allow building complex tree structs **(*)reroute assignment to inner part by putting getter over assignment operator: indexed assignment [[a b c d e f]] * [atIndex: 4] = [[e]] [[a b c d e f]] * [ [atIndex: 4] over [← 2] ] = [[a b c d 2 f]] keyed assignment: [[{"lol": 130, "kik": 741}]] * [atKey: "lol"] = [[130]] [[{"lol": 130, "kik": 741}]] * [ [atKey: "lol"] over [← 2] ] = [[{"lol": 2, "kik": 741}]] challenge: "get or set?" challenges: player must find if the operator should be used as a getter or combined to create an inner setter ***edu: visual assignement operators: indexed assignment (in array) [[0 0 0 0 5]] * [ ▢▢▣▢▢▢ ← 2] = [[0 0 2 0 5]] [[7 8 9]] * [ ▢▢▣▢▢▢ ← 2] = [[7 8 2]] [[4 4]] * [ ▢▢▣▢▢▢ ← 2] = ERROR edu: faire des challenges de mutation de tableaux et de dictionnaires sans parler de l'"index origin" (les indices de tableau commencent généralement à 0 en informatique) node assignment (in tree) edu: faire des challenges de mutation d'arbre, c'est à mi-chemin entre les tableaux et les dictionnaires (il y a une hierarchie non-linéaire) keyed-assignment (dict) edu: on utilise des dictionnaires "simplistes" avec la structure se déployant en interne (plus c'est profond, plus c'est petit) pour l'initiation dict1: [A[] B[]] dict2: [tl[] tc[] tr[]] [C[] D[]] [bl[] bc[] br[]] [A[] B[]] * [ ▢ ▢ ← 2] = [A[ ] B[]] [C[] D[]] [ C▣ ▢ ] [C[2] D[]] edu: de cette manière, on fait apparaître tout doucement dict["C"] ← 2 poly-assign: atomic operation of multiple assignment [ ▢▢▣▢▣▢ ← 2 ] or [ ▢ B▣ ← 2] [ C▣ ▢ ] or [ [▢▢▣▢▢▢ ← 2] [▢▢▢▢▣▢ ← 3] ] or [ ▢ B▣← 2] [ C▣← 3 ▢ ] ***edu: visual focus operators: [c] ▣ ▣ [2] [b] * ▢ * ▢ * [← 2] = [b] [a] [a] ***edu: other visual operators: [ ▢▢X▢▢▢ ] (delete at index:2) [[7 8 9]] * [ ▢▢X▢▢▢ ] = [[7 8]] **assign self: [c] [c] ▣ [a] [a] * ▢ * [← self] = [a] [b] [b] [b] (there may be a nice way to visually replace the word "self" 30 novembre 2023: **conditional operators using array pattern: [ [_,_,2,2,_]?"yes":"no" ] ***edu: 50/50 func(and the like): function definition is [x↦(rand()>0.5?f_A(x):f_B(x))] edu: pour faire faire des calculs mentaux aux élèves, et, parce qu'ils ont bien calculé, leur faire refaire le tirage jusqu'à tomber sur la sortie qu'ils ont choisi d'avoir et en passant, faire un peu de probas... easy: numberTyping("x|->x+2:3x+7") will yield a 50/50 func or numberTyping("x|-?->f_A(x):f_B(x)") ⊢?→ easy: numberTyping("x|->x+2:3x+7:4x:154") will yield a 25/25/25/25 func easy: numberTyping("x|->x+2:x+2:4x:154") will yield a 50/25/25 func **gm:challenge:math: 50/50 funcs some functions may be written so that, if input is prepared well, randomness is completely avoided f_A(c) == f_B(c) == d => [[c]] * [x⊢?→f_A(x),f_B(x)] = [[d]] **applicable generator: (↦2) (niladic: it's not a function, it does not transform anything (apart from the iC, because it mutates it by adding a new element to it) !apply!( (↦2) ) = [[2]] random variable is '⊢?→'-based generator example: dice: (⊢?→1:2:3:4:5:6) !apply!( (⊢?→1:2:3:4:5:6) ) = 5 !apply!( (⊢?→1:2:3:4:5:6) ) = 2 etc. 01 décembre 2023: **[structure]gm:challenge:'random' challenge family: challenges using 50/50 funcs: [x ⊢?→ x+2 : 3x] [a,b ⊢?→ a+b : a×b] 50/50 rewriters: [3a -?→ a+2a : 2a+a : a+a+a] 50/50 assigners: [x ←?- 2 : 3] [(x,y) ←?- (2,y) : (3,x)] the 'solving graph' of theses challenges will be different since random operators will have 2+ outgoing arrows **random pick operator: [?]: as a function: [[1 2 3 4]] * [?] = [[3]] [[1 2 3 4]] * [?] = [[1]] ... as an operator component: [ [←] over [?] over [[3 2]] ] is same as [←?-2:3] ***(*)!apply!::"multi-apply": perform !apply! on every operator of selection, atomically !apply!( (⊢?→1:2) , (⊢?→3:4) ) would spawn [[1]] and [[4]] for example ***eduDemo: 2+ random variables analysis by using multi-apply workflow: 1. some random variables(== applicable generators) have been created they are called (X) and (Y) 2. repeat: !apply!( (X) (Y) ) move a bit to avoid overlapping with previous values 3. qualitative and quantitative analysis can then be performed on the resulting tuples **gm:challenge:statistics: target is conditions on array: example: initial: [[]] ops: [1] [2] [3] [4] [5] [6] [7] ... target: [[{conditions: mean(array) == 12 ; extent(array) == 5}]] *ux: swing_rub: create array/dict/core from selection of disparate objects swing_rub([[1]] and [[2]]) = [[1 2]] (array) swing_rub([[a: 1]] and [[b: 2]]) = [[{a: 1, b: 2}]] (dict) swing_rub([[a: 1]] and [move_left]) = [[{a: 1, [move_left]}]] (core) *(*)quantum picks: (↦a,↦b) is not possible, only (↦a,↦b+!apply!( (X_b) )) or (↦a+!apply!( (X_a) ),↦b) (X_a) and (X_b) are random variables ((dance dialogue language: 3 main 'dialogue' reserved keywords (and their equivalent dance moves): ! (=='impose'), ☁ (=='expose') and > (== 'reply') (! may be split into !_start and !_end (> may be split into >_start and >_end dancer1 writes a dancing sentence / performs dance moves: with these 2 little twists: every move enclosed in an 'impose block' would have to be performed again by dancer2 the complete sentence must contain as many 'expose' as 'impose blocks' 'expose' can be put inside an 'impose block' dancer2 can then write / dance its response: dancer2 replaces every 'expose' with dance moves of their choice (including 'impose block' and 'expose') dancer2 replies to each 'impose block', in a 'reply block' (==performs the imposed dance moves and their own exposed moves) etc. before starting, dancers agree of a dance move for ! (or !_start and !_end), for ☁ and for > (or >_start and >_end) each pair 'impose block' and 'expose' is clearly identified: !1 is related to ☁1, !2 is related to ☁2 dancer may for example use their fingers to indicate the index !1_start !1_end !2_start !2_end ☁2 ☁1 is a valid sequence hardcore variant: if dancer does not succeed in replying to an 'imposed block', the corresponding 'expose' is nullified (==considered equivalent to nothing) a referee might be helpful to validate reply **freeDrawing: distribution => create random variable with a distribution 03 décembre 2023: ***(*)[structure]gm:challenge:equivalence: from initial to target and then from target to initial (with inverse operators (if they exist)) (operators may shift to their inverse version when player holds target instead of initial) **notation: "forked implies" A ⇒ B or C B ⇗ A =╣ ⇘ C **comboBox operator/(pre)applyScroll: before untouch, user selects operation/output via scroll example: [[4]] * [comboBox: + <1 2 3 4 5 6>] * !user selects + 3 via scroll! = [[7]] !apply!(comboBox: <1 2 3 4 5 6>) * !user selects 5 via scroll! => [[5]] is spawned **[structure]gm:challenge: challenge genealogy: when my grandpa initial met my grandma challenge initial1 and challenge1 are parents of initial2 or challenge2 etc. **(*)book of challenges: printable version of gm challenges when the user is familiar with gm challenges, they can _mentally_ solve non-interactive versions of them. Each page may hold 2 (occasionally 3) challenges, so as to leave room to draw paths and write notes. 04 décembre 2023: *another shortcut layer: double tap shortcuts in order to increase the number of shortcuts, and to distinguish features: double_tap(KeyI): spawn iota operator double_tap(KeyT): spawn text constructor etc. **defined-by-examples operators: operator facade contains samples of its application, the explicit form is not written the last line of the operator facade is "..." example: [2 ↦ 3] [[x]] * [5 ↦ 6] = [[x + 1]] [ ... ] **gm:challenge:proportionality: proportionality-specific operators initial is array target is array operators: defined-by-examples: [2 ↦ 4] [[x]] * [5 ↦ 10] = [[2x]] [ ... ] couple-based: [($4,x)↦(12,_)]: first element _must be 4_ for operator to apply [(x,$10)↦(_,5)]: second element _must be 10_ for operator to apply edu: un peu de calcul mental et de sublimation dans la lecture des tableaux de proportionalité ***mirroring pure func: input_arg is not replaced by output_arg, output_arg moves by mirroring input_arg move edu: pour fabriquer facilement un ensemble de départ (à gauche) et un ensemble d'arrivée (à droite), avec la fonction au milieu mirror would generally be on x-axis but it could be on y-axis (input on top and output at bottom, for example) *fun: chatGPT::navigation: produce sentences by rubbing desired mindset for each new word layout: output textField: this is were text grows control area: top: [frightened] [joyful] [despaired] [angry] center: [*] : empty object only used for rubbing bottom: [hungry] [in_love] [sadistic] [masochistic] so this is like navigating because if the boat goes too much on the left, you may stir it to the right, etc. 05 décembre 2023: ***continuous random variable: (⊢[?]→[1;2]) default distribution is uniform distribution (⊢[?]→[1;2[U[5;6[) (freeDrawn distribution may be used there is another way to simulate the effect of a distribution: by stacking intervals (==disjoint union) (⊢[?]→[1;2]+[1;3]) will yield twice as much elements in [1;2] than in [2;3] we could also write it (⊢[?]→2[1;2]+[2;3]) 2D: ( ⊢[?]→([1;2],[0,1]) ) ***weighted discrete random variable: (⊢?→2{4}:5{9}:3{10}) (⊢?→2{4}:5{9}:3{10}) will yield: [[ 4]], 2 times out of 10 [[ 9]], 5 times out of 10 [[10]], 3 times out of 10 **edu: (⊢[?]→[1;3]+50{2}) ==> ??? **paced random source = paced apply + random variable [ (⊢?→0:1) over [* (paced: 1 second)] ] is a random source of 0 and 1, every 1 second 06 décembre 2023: ***eager operator (for 2+ary operators): if input is incomplete (==if there are not enough input args), result is reactor which awaits to encounter missing args they may be expressed using .., ▣ and ">>" [ >>] is an eager operator [[ >>]] is a reactor (it is actually the correct symbolization of a reactor (previous symbolizations of reactor in still_shute are obsolete)) example: [[5]] * [▣ + .. >>] = [[5 + ▣ >>]] [[5 + ▣ >>]] * [[6]] = [[11]] they may be expressed using n-ary anonymous funcs and then currying occurs: example: [[5 (held)]] * [🅇,y,z↦(x+3y)/z >>] = [[🅈,z↦(5 + 3y)/z >>]] [[🅈,z↦(5 + 3y)/z >>]] * [[10]] = [[🅉↦(5 + 3 × 10)/z >>]] [[🅉↦(5 + 3 × 10)/z >>]] * [[4]] = [[(5 + 3 × 10) / 4]] another example of currying: [[5 + .. / ▣ >>]] * [x,y,z↦(x+3y)/z] = [[🅇,y,z↦ 5 + .. / ((x+3y)/z) >>]] operator may then be used as input arg: with eager operator: [▣ + ..] * [▣ × .. >>] = [(▣ + ..) × .. >>] with reactor: [[5 + ▣ >>]] * [▣ / ..] = [[5 + ▣ / .. >>]] (== [[5 + (▣ / ..) >>]] /!\) using a previously defined func: [[5 + .. / ▣ >>]] * [f(▣,3,..)] = [[5 + .. / f(▣,3,..) >>]] ***reactor::focusScroll: choose where next input will land: [[5 + ▣ / .. >>]] (arg1 is chosen by default) => !focusScroll!([[5 + ▣ / .. >>]]) * arg2 is chosen = [[5 + .. / ▣ >>]] [[🅇,y,z↦(x+3y)/z >>]] (arg1 is chosen by default) => !focusScroll!([[🅇,y,z↦(x+3y)/z >>]]) * arg2 is chosen = [[x,🅈,z↦(x+3y)/z >>]] ***easy: eager operator:: recall input args (in order to be able to reuse one of them) example: [[5]] * [▣ + .. >>] * ==> [[5 + ▣ >>]] reactor AND a clone of [[5]] is now under [▣ + .. >>] so that [[5 + >>]] * [[5 (clone under [▣ + .. >>])]] = [[10]] deep clone or shallow clone ? as of now, I don't know. **gm:challenge:P(E)MDAS, via eager operators: create an expression which is equivalent to target top label says: m: x,y ↦ x × y d: x,y ↦ x / y a: x,y ↦ x + y s: x,y ↦ x - y initial: [[3]] ops: eager operators: [m >>] [d >>] [a >>] [s >>] value wells: _[[2]]_ _[[3]]_ _[[4]]_ _[[5]]_ (let's represent wells this way: _[[ ]]_ ) [[3 over m >>]] * _[[2]]_ = [[5]] and _[[2]]_ is still here target: [[(2 + 3 x 2) / 5]] but user has to build [[d(a(2,m(3,2)),5)]] edu: this will be a hard challenge for a middle-school student, but once expression parsing is understood, ... (*gm:challenge:Mathador via eager operators 07 décembre 2023: **stop-and-go (for conveyed object): if conveyed object is conveyed by pathmadeOp1 and pathmadeOp2 starts somewhere in pathmadeOp1.path, then conveyed object stops, waits for pathmadeOp2 to complete, and then goes back to its original "being conveyed by pathmadeOp1" typical usecase: conveyed object by pathmadeOp1 is (⊢?→1:2:3) and pathmadeOp2 has [*] at start of it, so that random_variable is evaluated pathmadeOp2 then conveys evaluation and does something with it and then, when done, gives control back to pathmadeOp1 **"slacking" operator family: operator ignores some of the input args harmless slacking: unused input args are kept as is [x,y,...↦x+y,...] harmful slacking: unused input args are lost [x,y,...↦x,x,y,y,x] **"minifold" operator family: harmless slacking operator with arity_of_output < arity_of_input perfect minifolds: arity_of_output = arity_of_input - 1 examples: minifoldlll: [[1 2 3 4 5 6]] * [x,y,...↦x+y,...] = [[3 3 4 5 6]] minifoldrrr: [[1 2 3 4 5 6]] * [...,x,y↦...,x+y] = [[1 2 3 4 11]] fold = loop + perfect minifold (remark: this is the good old fold, not the reduce of J language) other examples: minifoldlrl: [[1 2 3 4 5 6]] * [x,...,y↦x+y,...] = [[7 2 3 4 5]] minifoldlrr: [[1 2 3 4 5 6]] * [x,...,y↦...,x+y] = [[2 3 4 5 7]] mesofolds: arity_of_output < arity_of_input - 1 example: [x,y,z,...↦x+y-z,...] **"expand" operator family: harmless slacking operator with arity_of_output > arity_of_input examples: [[1 1 1 1 1]] * [...↦...,2] = [[1 1 1 1 1 2]] ([...↦...,2] may simply be written [,2]) [[1 1 1 1 1]] * [...↦2,...] = [[2 1 1 1 1 1]] ([...↦2,...] may simply be written [2,]) [[1 1 1 1 1]] * [...↦2,...,3] = [[2 1 1 1 1 1 3]] ([...↦2,...,3] may simply be written [2,...,3]) **gm:challenge:minifolds, expands and other arity-transforming functions [A,B,C,D↦A+C,B+D] **easy: "[+ random variable]": put (⊢?→1:2:3) over [+] [ (↦1:2:3) over [+] ] will yield same output as [+ !(⊢?→1:2:3)!] **easy: random variable as platform applicable operator (platform: ⊢[?]→) !apply!( ([[ [1;2] ]] over (platform: ⊢[?]→) ) ) = random number in interval [1;2] 08 décembre 2023: **purifier/terminator/eraser: generator's inverse family purifier: (==the inverse of filter, == you precise what you want to get rid of) mono purifier: remove at most 1 [[3 3 7 3]] * [3↦] = [[3 7 3]] [[3 7 3]] * [3↦] = [[7 3]] [[1 2 3 4 5 6]] * [2:3:4↦] = [[1 3 4 5 6]] OR [[1 2 4 5 6]] OR [[1 2 3 5 6]] discrete-set purifier: remove all belonging to set [[3 3 7 3]] * [{3}↦] = [[7]] [[1 2 3 4 5 6]] * [{2,3,4}↦] = [[1 5 6]] interval-based purifier: [ [4;6]↦ ] (polymorphic) [[1.5 2.5 3.5 4.1 4.3 4.9 5.9 5.99 6.4 6.5]] * [ [4;6]↦ ] = [[1.5 2.5 3.5 6.4 6.5]] [[ [1;2] U [3;7] ]] * [ [4;6]↦ ] = [[ [1;2] U [3;4[ U ]6;7] ]] [[ [4;6] [4;6] [5;6] [4;10] ]] * [ [4;6]↦ ] = [[ [5;6] [4;10] ]] conditional purifier: [(x>3)↦] (polymorphic) [[1 2 3 4 5 6]] * [(x>3)↦] = [[1 2 3]] [[ [[1;10] ]] * [(x>3)↦] = [[ [1;3] ]] terminator: we say an operator is a terminator when its output is [[None]] [[3]] * [3↦] = [[None]] => this may terminate current pathmadeOperator and give control to a higher-level pathmadeOperator universal terminator: [...↦] eraser: mono eraser: apply (3↦) on [[3]] to destroy it !apply!( (2:3:4↦) over [[1 2 3 4 5 6]] ) = [[1 3 4 5 6]] OR [[1 2 4 5 6]] OR [[1 2 3 5 6]] discrete-set eraser: !apply!( ({2,3}↦) over [[2 2 3 3 7 3]] ) = [[7]] interval-based eraser: ([4;6]↦) !apply!( ([4;6]↦) over [[1.5 2.5 3.5 4.1 4.3 4.9 5.9 5.99 6.4 6.5]] ) = [[1.5 2.5 3.5 6.4 6.5]] conditional eraser: !apply!( ((x>3)↦) over [[1 2 3 4 5 6]] ) = [[1 2 3]] universal eraser: (...↦) **gm:challenge:purifier-based challenges: edu: manipuler les nombres décimaux (filtrer demande une représentation mentale (même partielle) de la droite numérique) en manipulant des ensembles discrets de nombres en manipulant des intervalles edu: manipuler les multiples et les fractions en manipulant des ensembles discrets de nombres en manipulant des ensembles définis par compréhension **terminator/purifier/eraser X clones: kill all objects related by bloodlink **random terminator/random purifier/random eraser: random generator's inverse family random purifier: [[1 2 3 4]] * [2:3⊢?→] = [[1 3 4]] OR [[1 2 4]] [[1 2 3 3 3 4]] * [2:3⊢?→] = [[1 3 3 3 4]] OR [[1 2 4]] edu: ce qui est bien avec ça, c'est qu'on est passé à un opérateur "à l'ancienne" _ is the 'impossible match': [[1 2 3 4]] * [2:3:_⊢?→] = [[1 3 4]] OR [[1 2 4]] OR [[1 2 3 4]] random terminator: [[2]] * [2:_⊢?→] = [[None]] OR [[2]] (we may call it unreliable terminator) random eraser: (2:3⊢?→) (2:_⊢?→) (unreliable eraser) **unreliable random generator: (⊢?→2:_): yields [[2]] or nothing (or [[None]] depending on usecase) **weighted random terminator/weighted random purifier/weighted random eraser: weighted random generator's inverse family weighted random purifier: [[1 2 3 4]] * [2{4}:5{9}:3{10}⊢?→] = [[1 2 3]] (2 times ouf of 10) OR [[1 2 3 4]] (8 times ouf of 10) weighted random terminator: [[2]] * [2{2}:1{_}⊢?→] = [[None]] (2 times out of 3) OR [[2]] (1 time out of 3) weighted random eraser: (5{2}:12{3}⊢?→) fun: this eraser may be used for painting, to create special effects on a surface **operator-grade random variable, by composition: since [[3]] * [3 ↦] * [⊢?→4:5:6] = [[4]] OR [[5]] OR [[6]] we can create [3⊢?→4:5:6] (which operates like [3 ↦] * [⊢?→4:5:6]) thus: [[3]] * [3⊢?→4:5:6] = [[4]] OR [[5]] OR [[6]] and [[7]] * [3⊢?→4:5:6] ==> nothing happens, [[7]] is left unchanged and untouched ***random discarder: random args are discarded ("[..,..,..⊢?→..,..]") we may write it [d?scard()] or [🔥] [🔥🔥] [🔥🔥🔥] ... [[1 2 3 4 5 6]] * [🔥] = [[1 2 3 4 6]] (for example) [[1 2 3 4 6]] * [🔥] = [[2 3 4 6]] (for example) remark: to select 1 random element in a list of 6 elements is the same as to discard 5 times 1 element (duality of choice) **random permutation: args are shuffled [[1 2 3 4]] * [🔀] = [[4 2 1 3]] (for example) *eduDemo: montrer que la pente change: [[2 3 4]] * [x↦x²] = [[4 9 16]] puis !warp! entre 2 et 3, la pente de la corde est (9 - 4)/(3 - 2) = 5 et entre 3 et 4, la pente de la corde est (16 - 9)/(4 - 3) = 7 **random pick:: multiple pick: [? ? ?] [[1 2 3 4 5 6]] * [? ? ? ?] = [[3 3 1 2]] (for example) **random pick:: multiple distinct pick: [?! ?! ?!] [[1 2 3 4 5 6]] * [?! ?! ?! ?!] = [[2 6 1 5]] (for example) but never [[2 2 3 3]] **weighted random pick [[A B C]] * [..⊢?→2{..1}:3{..2}:4{..3}] = [[A]] (2 times out of 9), etc. **weighted random multiple pick [[A B C]] * [..⊢?→2{..1}:3{..2}:4{..3}, 5{..1}:2{..2}:1{..3}, 3{..1}:8{..2}] = [[A,A,A]] OR [[A,A,B]] but never [[A,A,C]], etc. => multiple pick may be written: [?(2/3/4) ?(5/2/1) ?(3/8/0)] weighted distinct pick may be written: [?!(2/3/4) ?!(5/2/1) ?!(3/8/0)] but be aware that only the weights of the first pick will accurately be used 09 décembre 2023: **easy: random point generator via freeDrawing: draw surface from which you want random point to be picked from workflow: 1. enter random point generator freeDrawing mode => a dedicated coord system spawns 2. draw surface in newly spawn coord system 3. leave mode **double randomness: rand in input, rand in output mono: [[2 3]] * [2:3⊢?-?→4:5] = [[4 3]] OR [[5 3]] OR [[2 4]] OR [[2 5]] any mapping (set-wise): [[2 2 3 3]] * [{2}:{3}⊢?-?→4:5] = [[4 4 4 4]] OR [[4 4 5 5]] OR [[5 5 4 4]] OR [[5 5 5 5]] distinct mapping (set-wise): [[2 2 3 3]] * [{2}:{3}⊢?-?!→4:5] = [[4 4 5 5]] OR [[5 5 4 4]]⌈ any mapping (element-wise): [[2 2 3 3]] * [{2}:{3}⊢?!-?→4:5] = [[4 4 4 4]] OR [[4 5 4 4]] OR [[5 4 4 4]] OR [[5 5 4 4]] OR ... **gm:challenge:build random variable(== random generator) so that it produces target samples target is composed of n samples gm is applied at most 100 times **conditional random generator: rhs is a condition some mathematical conventions are used to simplify notation ( ⊢?→(x>3) ) will yield real values greater than 3 ( ⊢?→(n>3) ) will yield integer values greater than 3 dev: yielded values must be 'good' values for example: not too big, not too small **edu: !xy-warp!(point(a,b)) not only warps point to its canonical position, it also creates ghosts: [[a]] on x-axis [[b]] on y-axis and maybe thin segments: one joining [[a]] and [[(a,b)]] one joining [[b]] and [[(a,b)]] eduDemo: proportionnality: point(a1,b1) is "proportionnal" to point(a2,b2) if they are aligned with point(0,0) *random strangeness: random + bound/free [a⊢?→a+10:b] [a:b⊢?-?→a+10:b+5] gm:challenge:random + bound/free **(*)[structure]gm:challenge: use the right expression of initial while held, gm rewrites itself into a new -yet equivalent- form use [freeze] operator to end gm's rewriting curse and then use operators to complete challenge the operators are rigid (they only apply when input is in a valid format, that's why user has to select the right initial expression) ***easy: !enroll!: create/extend array from held object + hovered object: shortcut: same as !apply! workflow: hold [[4]] ==> [[4]] is held !enroll!([[4]] over [[11]]) = [[4 11]] !enroll!([[4 11]] over [[8]]) = [[4 11 8]] **easy: !pop!: !pop!: drop first value of held array shortcut: same as !enroll! but there must be no object under !deroll!([[4 11 8]]) = [[4]] (dropped), [[11 8]] (held) !deroll!([[4]]) = [[4]] (dropped), [[None]] (held) !pop_last!: drop last value of held array shortcut: SHIFT.!deroll! !pop_self!: pop selected value and continue with the rest array shortcut: alt.!deroll! !pop_random!: shortcut: rndm.!deroll! (a keyboard key must be found to aura "random", the same as alt auras alteration) 10 décembre 2023: **!enroll! over generator: !enroll!( [[1 3]] over (↦4) ) = [[1 3 4]] !enroll!( [[1 3 4]] over (↦4) ) = [[1 3 4 4]] ***distinct generator: will not yield value already contained in input array !enroll!( [[1 3 6]] over (⊢?!→1:2:3:4:5:6) ) = [[1 3 6 2]] OR [[1 3 6 4]] OR [[1 3 6 5]] edu: créer facilement un arrangement de [[1 2 3 4 5 6]] **/!\ /!\ single point generator is not the same as 2-values generator /!\ /!\ !enroll!( [[1 3]] over (↦ (4,10) ) ) = [[1 3 (4,10) ]] (we enroll a point) !enroll!( [[1 3]] over (↦ 4,10 ) ) = [[1 3 4 10]] (we enroll 2 values) **/!\ /!\ single array input is not the same as multiple arg input /!\ /!\ [(x,y)↦x+y] (single input) [[(1,2)]] * [(x,y)↦x+y] = [[3]] (input was point(1,2) ) [[1 2]] * [(x,y)↦x+y] ==> nothing happens [x,y↦x+y] (multi input) [[(1,2)]] * [x,y↦x+y] ==> nothing happens [[1 2]] * [x,y↦x+y] = [[3]] **(**)!compile!(selection): transform visual program in iC into javascript code maybe, this way, user may easily write programs which would otherwise be harder to write edu: et pour faire le lien de la programmation visuelle ("tangible") vers la programmation textuelle ("abstraite") **regexp-based rewriting operators: use capturing groups to specify input and output [/(.*)(2,)(.*)(3,)(.*)/→$1,$3,$5,6] (if a 2 and a 3 are found in lhs, then rewrite the rest and append 6) (il faut peut-être trouver une notation plus simple 11 décembre 2023: **!apply! reactor over generator: !apply!( [[45 + >>]] over (↦6) ) = [[51]] **a terminator on top of a source is called a cap: source output is destroyed as soon as it is spawned [1↦] over [ (↦1) over [* (paced: 1 second)] ] ==> nothing comes out [{0,1}↦] over [ (⊢?→0:1) over [* (paced: 1 second)] ] ==> nothing comes out **eduWarmups(==activités de début d'heure, en classe): slow and easy (operation sequence) layout: [[initial]] -->-- [op1] -->-- [op2] -->-- [op3] -->-- [op4] -->-- pathmade goes slowly enough so that is leaves time for students to compute mentally the terminal value answer is revealed gradually as object passes through the operators a CS variant could be made with branching conditional operators: [ x>3 ? [move up] : [move down] ] **icObj.type = "array" specs: max capacity white-list of types (==limited set of allowed types) black-list of types (==unallowed types) type-specific capacity !warp! on icArray may cause array to decompose 12 décembre 2023: **baby serialization: serialize into simple json, deserialize simple json no positions, no sizes, no types: only structure and content are specified when loaded, object is adjusted to fill screenPov edu: CS: pour découvrir en douceur les dictionnaires conventions: A,B,C, and D are the 4 sub-rects of the container TL, TC, TR, BL, BC, BR are the 6 sub-rects of the container example: { A: "banana", B: { TL: "car", TC: { A: "dog", B: "star", C: "square", D: "triangle", }, TR: "chicken", BL: "dog", BC: "circle", BR: "sun", }, C: "moon", D: "square", } remarks: an editor must be created to easily create such objects in iC (via drag and drop) there may be: structure objects content objects some standard objects of iC may be baby-serializable **any input/any output (AI): system reads the input file and understands what was meant / systems writes a file with the specs given by user => input and output may be text files with "natural language" as soon as its hydratable,enlivenable **"touch for near and apply for far": the XSlotness of an operator depends on the current active object a gm will see the operators of its mother challenge as touchSlots and the operators outside of its mother challenge as applySlots conversely, a "wandering" mathNode will see the operators of a gm challenge as applySlots **blink unlock: {[[lock]], [button_toggle_lock]} couple:: blink edition: operator is unlocked only for a blink (==infinitesimal moment) => [button_blink_unlock] this time frame is just enough for operator to apply (if it can) ***remote !apply! via {[[↧]], [↥]} [↥] sends a message to [[↧]] [[↧]] applies what's below when it receives the message edu: pour appliquer des transformations au moment souhaité workflow: 0. numberTyping("remote") => [[↧]] and [↥] are spawned (they have the same color which is how we identify the couple) put [[↧]] over (+ 10) [[↧]] fades a bit so that we see the most important: (+ 10) move [↥] in top left corner of screenPov so that it does not interfere with reading 1. put [[13]] over (+ 10 (with [[↧]])) => nothing happens 2. click on [↥] => [[13]] over (+ 10 (with [[↧]]!!)) = [[13]] * (+ 10) = [[23]] edu: on peut faire un synchroveil sur plusieurs [↥] différents pour appliquer plusieurs transformations simultanément **remote !! via {[[↧]], [↥]} couple numberTyping("remote ") to spawn couple example: !click!([↥warp]) ==> [[warp↧]]!! over [[12]] ==> [[12 (warped)]] **(*)remote::key event: {[[↧ Key()]], [↥ Key()]} numberTyping("remote k ") keyPress(Key()) ==> [[↧ Key()]] applies what's below **(*)remote::mouse event: {[[↧ Mouse()]], [↥ Mouse()]} numberTyping("remote m 0") for mouse.button0 mousePress(mouse.button0) ==> [[↧ mouse.button0]] applies what's below ***numberTyping:: conditional pathmade operator: spawn a ready-to-use (yet editable) conditional pathmade operator numberTyping(""?) for if{} numberTyping(""?:) for if{} else{} numberTyping(""?:""?) for if{} elseif{} numberTyping(""?:""?:) for if{} elseif{} else{} each branching path of the spawned pathmade operator has a dummy at the end of it the dummy can be used to edit the branching path (make it shorter, make it longer, redraw it, etc.) each dummy has a particular color which is also the background or the border color of the expression it refers to example: /---- [[dummy for >3]] (color: red) [>3?:==3?:] ------<----- [[dummy for ==3]] (color: blue) red blue black \---- [[dummy for else]] (color: black) 13 décembre 2023: **loop can easily be made from conditional pathmade operator: make top branch loop back to operator entry point **stochastic process: random variable + condtional pathmade operator with this little twist: condtional pathmade op evaluates random variable at entry point but random variable is not replaced by this temporary evaluation, it continues its way, to be evaluated again later, etc. **dish well/dish generator: latest value produced by well is on top of well, waiting to be used, like a dish dish well: dish well has 2 parts: [yield] button dish slot (dish slot is symbolized: \[[ ]]/) when pressing [yield] button, the new value replaces last dish dish generator: dish generator has 2 parts: random variable dish slot example: dish generator: ((↦[0;1]) \[[ ]]/) !apply!( ((↦[0;1]) \[[ ]]/) ) ==> ((↦[0;1]) \[[0.287]]/) !apply!( ((↦[0;1]) \[[0.287]]/) ) ==> ((↦[0;1]) \[[0.554]]/) edu: pour se rapprocher de l'ux du dé **"captain" variable: in a big object, this variable will be the one passing the tests on the conveyors => this variable is the troop leader "captain" oligarchy: a small number of captain variables pass the tests on the conveyors ***pathmade::discontinuous path: pathmade is a sequence of path parts when object is at pathmade.part1.end, it respawns at pathmade.part2.start => use this to write stuff ("the path is the message" bueh bueh bueh) for example: one could write a pathmade which will look, from afar, like "x>3" **pointillism pathmade: pathmade is a sequence of points value may stay 1 second at pathmade.part1, then 1.49 seconds at pathmade.part2 antiedu: c'est moins lisible mais c'est plus rapide **!enroll!::!enroll_assign!: when used on a container, assign held to container slot and select container shortcut: Alt.!enroll! examples: !enroll_assign!([[rect (blue)]] over [[▢ ▢ ▢ ▢]]) = [[ [[rect (blue)]] ▢ ▢ ▢]] ([[rect (blue)]] was over first ▢) [[▢ ▢ ▢ ▢]] is a 4-slot container !enroll_assign!([[4]] over [[▢ + ▢]]) = [[▢ + 4]] ([[4]] was over second ▢) [[▢ + ▢]] is a structure expression !enroll_assign!([[4]] over [[a]]) = [[name: a value: 4]] (named variable, ==icVar) symetrical enroll_assign: !enroll_assign!([[▢ + 4]] over [[8]]) = [[8 + 4]] (▢ was over [[8]]) !enroll_assign!([[a]] over [[4]]) = [[name: a value: 4]] **!enroll!::!enroll_adhere!: when used on a support (img1 over img2, for example) !enroll_adhere!([[img1]] over [[img2]]) = [[ [[img1]](top) [[img2]](support) ]] 14 décembre 2023: **[structure]meta-conditional operators: test is not only based on input value but also on extra state examples: color operator: blue operator only applies to blue input vector-filter touchSlot operator: operator only applies if input momentum is a particular vector these operators will perform nicely over a pathmade.path gm:challenge: tangent operators: put operators on pathmade.path in order to transform [[initial]] into [[target]] ****edu:transformation is egocentric and encounter is humble: flavors of 3 + 2 transformation: [[3]] * [+ 2] this is the egocentric point of view in maths: If I'm 3, I don't consider 2 as a member of my family. I don't even see 2. I only feel that I'm changing. This transformation could have any name, the important is I. As 3, I become 5. encounter: [[3]] * [+ >>] * [[2]] this is the humble point of view in maths: If I'm 3, I know that 2 and me are of the same essence, yet 2 is something other. I'm ready to meet 2, under a particular encounter frame. I and 2 encounter and recombine into 5. remark: [[3 2]] * [+] is egocentric (I am [[3 2]], and I will transform) [[+ >>]] * [[3]] * [[2]] is "ultimate"-humble (there is no I), or conversely, god-like **gm:challenge:"opérations sur moi" / "l'Autre, c'est moi": gm well is also a value well typical usecase: 4 / 4 + 4 x 4 = 17 layout: initial: _[[]]_ ops: [+] [-] [x] [/] target: [[a number between 1 and 100]] **[structure]th::bootstrap self-referential self-rewriting treasure hunt ("le sens du voyage", "lost in translation") as player progresses through treasure hunt, they meet rewriters which affect previous encounters' sayings ux: les "nouveaux" éléments(==accessibles grâce à la réinterprétation) sont "débloqués" quand on passe devant les points de passage associés (dans le bon ordre). flavors: niveaux de vérité: ce que disent les chevaliers (vérité niveau 1) et tout les niveaux en dessous est écrasé par ce que disent les mages en cas de conflit (vérité niveau 2) susceptible d'être réécrit par ce que disent les mages (vérité niveau 2) etc. we may use simple chess symbols for truth hierarchy: ♙<♘<♗<♖<♕<♔ fun: truth spiral la "montée en vérité" modifie l'interprétation des instructions initiales => on spirale vers des vérités plus hautes exemple1: ♙#1: "va à droite" ♙#2 (à droite de ♙#1):"va en bas" ♘#1 (en bas de ♙#2): "'va à droite' veut dire 'va en haut', va voir ♙#1" exemple2: avec un petit "héros" à déplacer au début, après avoir rencontré ♙#1: "le feu ça brûle" le héros se brûlera en touchant le feu ensuite, un peu plus tard, après avoir rencontré ♘#1: "le feu ça ne brûle pas" le héros ne se brûlera pas en touchant le feu ce qui peut l'amener à accéder à de nouvelles zones... mais attention, quand le héros va rencontrer ♗#15: "le feu ça brûle" il ne pourra peut-être plus revenir d'où il était venu... vérité fragile(==girouette crédule, ==le dernier à raison): l'interprétation du nouvel élément affecte tout le contexte de vérité précédemment bâti => ce qui est vrai lundi, est faux mardi, est vrai mercredi et jeudi, est faux vendredi, ... fun: "quand tu allais, on revenait" ****easy: routing pathmade/condition star(==switch): build star pathmade by freeDrawing with values or with conditions routing pathmade: if value is X, follow pathX. there is a default path for unmatching values. workflow: initialization: draw a pathmade []------> loop: 1. pick an object, say [[4]] 2.a. freeDraw::pathmade with this object, starting at pathmade entry point: => it creates a routing pathmade: example: []------> becomes [4:*]-----*-----> \-----4--> becomes /-----7--> [4:7:*]-----*-----> \-----4--> etc. OR 1. pick an object, say [[4]] 2.b. if you want your value to take the same path as an existing one: ux1: zoom in pathmade entry point, so that the desired existing one has focus and !enroll_assign! your value into it example: /-----7--> /-----7--> !enroll_assign!( [[6]] over [4:7:*]-----*-----> ) = [{4;6}:7:*]-----*-----> ([[6]] was over [[4]]) \-----4--> \-----{4;6}--> ux2: freeDraw::pathmade with this object, starting at pathmade entry point, _and follow desired existing branch_ OR 1. pick an array, say [[4 7 9]] (or an interval) 2.a. edu: pour montrer les tables de routage sur un petit réseau jouet et la circulation de l'information c'est une eduDemo qu'il serait intéressant de réaliser on peut aussi créer une activité "puzzle", dans laquelle les étoiles doivent être replacées au bon endroit pour récréer le réseau complet edu: pour créer le "coeur" d'un automate fini assez facilement condition star: same as routing pathmade but with conditions /----->3--> [>3?:>1?:]-----*-----> \---->1--> *[[1 2 3 4]]freeDraw::pathmade ==> [{1;2;3;4}]-----> whereas <-1--\ /--2-> [[1 2 3 4]]freeDraw::pathmade + !comb! ==> [1:2:3:4]--3-> <-4--/ <-1--\ /--2-> <-1--\ /--2-> *easy: freeDraw::pathmade over [1:2:3:4]--3-> ==> [1:2:3:4:5:*]--> (routing pathmade with default branch) <-4--/ <-4--/ \--*-> *easy: "operator pathmade": [+ 2]freeDraw::pathmade ==> [+ 2]----> (operator with a conveyor) **easy: color meta-condition star: use [[rect (blue)]]freeDraw::pathmade, [[rect (red)]]freeDraw::pathmade, ... and also [[ [[rect (blue)]] [[rect (red)]] ]]freeDraw::pathmade edu: la logique en douceur edu: le contrôle de flux en douceur so that [[img (mainly blue)]] * [blue:red]---blue--> = [blue:red]---blue-->[[img (mainly blue)]] \----red--> \----red--> => fun: realistic jigsaw-puzzle experience: the initial "group by color" you take 1000 pieces and you create color groups using a color star, then you start building areas with each group it would be nice to do it in coop, with spatialized sound iCWebcams or iCSpeakers same thing with shape same thing with static object / everchanging object same thing with [[variable]] / [operator] etc. **[discovery] freeDraw::pathmade imaginer ce que donnerait le dessin de chemin à partir d'autres types d'objets 15 décembre 2023: *_[[5]]_.freeDraw::pathmade ==> delayed-refill value well (delay is given by pathmade duration: the time for the fresh value to go at pathmade tip) **pov.freeDraw::pathmade ==> meta-conditional gotopov : when screenPov is correctly set, user will have to click on [gotopov] to be conveyed on one of the povpath branches many flavors: ic-content-seen-by-pov meta-conditional pov path: if iC's object X is visible on screenPov, then gotopovX content-carried-by-screenCanvas meta-conditional pov path: if X is carried by user in its screenCanvas, then gotopovX edu: pour envoyer le joueur à la prochaine aventure **(*)object-oriented ui: object most important properties and methods appear big(==with a big homeScale), the rest being displayed with a small homeScale un peu comme si on pouvait appliquer des styles à la Word à des instances de classe **dish loop: this loop picks one object and brings it to "dish" location, loop stalls until dish is conveyed by other pathmade, and then picks another object etc. workflow: 1. start drawing a pathmade operator 2. at some point, rightMouseClick to indicate this is the dish location 3. finish drawing the loop by drawing back to the start **easy: !intervalScroll!: create interval from value !intervalScroll!([[4]], "up") = [[ [4;5] ]] !intervalScroll!([[4]], "up"(gently) ) = [[ [4;4.1] ]] edu:math:statistiques: pour facilement créer des histogrammes avec une foreach-loop, une cond star et des stores à compteur, ... **spatialized sound::icSpeaker: same as icWebcam but for voice/sound when icSpeaker in at big homeScale, it increases its volume (but there is a limit (so as to avoid breaking the ears of the other users)) it increases its broadcasting area (this is the main interest) when hovering icSpeaker, we see a visual representation of the broadcast (color gradient or isolines for volume, as in cartography) *fun: jeu de "zCache-Cache" 3D => extended zCache-Cache: les joueurs peuvent se zCacher dans l'espace 3D mais aussi dans les différents tableaux 2D (aiguilles et bottes de foin virtuelles) ***easy: cloning pathmade: value will follow n paths simultaneously flavors: value-specific: workflow: pick an object, say [[4]] [[4]].freeDraw::pathmade [[4]].freeDraw::pathmade, starting at pathmade entry point [[4]].freeDraw::pathmade, starting at pathmade entry point ... ==> /-----4---> [4]-----4---> \-----4---> condition-based: same thing with condition any-value: workflow: pathmade drawn over pathmade, etc. ==> /-------> []-------> \-------> => binary operate on self: example: /-----\ [] ----> [+]----> \-----/ 16 décembre 2023: ***generator::sequence generator: 2 flavors: (==looping) sequence generator: (⊢>>→{1;2;3;4;5;6}) this will yield 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 ... consuming sequence generator: ( (pop) over [[1 2 3 4 5 6]] ) !apply! ( ( (pop) over [[1 2 3 4 5 6]] ) ) = [[1]] , ( (pop) over [[2 3 4 5 6]] ) *pistol generator: (↦3)-----> *pistol generator::automatic (using a loopback): operator version: [↦3]-----> / \ \->-/ after it has been pressed once, it will spawn values with pace == loopback duration generator version: ( [apply] over (↦3) )----> ^\---------/ variant: alternator/n-alternator: 2+ loopbacks, of different lenghts ⟳ ( (⊢>>→{1;2;3;4;5;6}) ) ⟲ ***sower: (pop).freeDraw::pathmade + pathmade::apply ("le petit poucet", le début de l'easy:layout) worflow: initialization: 1. pick (pop) 2. freeDraw::pathmade while drawing path, invoke !apply! as desired popping locations => this is a layout operator, since it assigns positions of elements of input array there is of course the applySlot version and the touchSlot version example: [[1 2 3 4 5 6]] * [ [pop]--!*!-----!*!---\] = [[1]] [[2]] <----|*|----|*|-----/ [[5 6]] [[4]] [[3]] easy: value well: [[4]].freeDraw::pathmade(loopback) [[4]] / \ ==> _[[4]]_ \->-/ /!\ il y a des pathmade qui sont reproduits exactement, d'autres qui servent juste à exprimer ce que l'on veut créer (comme par exemple ici) on pourrait appeler ces derniers des "creation gestures" (ou des miracles comme dans Black and White) *(n)op stub: [↦] numberWriting("op") or even more easily: draw a pathmade which does not move, a pathmade "point" from this stub, complex operators can be created gm:challenge:draw me an operator: op stub is the only enabled operator, which user has to enrich via freeDrawing, so that [[initial]] * [op__drawn] = [[target]] ***[discovery]array op stub/multi arg op stub: [ [1] [2] [3] ] ([1] [2] and [3] are parameter slots, which are then used to build operator using [1].pathmade(), [2].pathmade(), ...⌈) array op stub: numberWriting("op 3") ==> [ [1] [2] [3] ] multi arg op stub: 1. draw op stub ==> [op] 2. draw a pathmade from outside to [op] ==> []------>[ [1] ] draw a pathmade from outside to []------>[ [1] ] ==> []------>[ [1] [2] ] []-------------/^ remark: 3. select multi arg conveyors entry points and delete them => now you have an array op stub : [ [1] [2] ] ***easy: array operator drawing "[1](of [ [1] [2] [3] ]).pathmade() ==> [ [1] [2] [3] ]------[1]-----> etc. this way we can draw sophisticated operators remark: those operators may "return" many different outputs at many different places (multi-input and multi-output) edu: construire des opérateurs correspondant à des programmes de calcul [ [1] ] est un stub intéressant car il permet de réutiliser l'argument exemple: [ [1] ]-->-[1]-->-[+ 2]-->-[×]---> est équivalent à [y↦(y+2)×y] \--->---[1]------>------/^ ***dict op stub(==getter op)/named args op stub: [ [name] [age] ] dict op stub(==getter op): numberWriting("get name age") ==> [ [name] [age] ] example: [[{name: "Barbara" city:"Singapore" age:58}]] * [ [name] [age] ] = [["Barbara" 58]] named args op stub: 1. draw op stub ==> [op] 2. [[name]].pathmade() from outside to [op] ==> []------>[ [name] ] [[age]].pathmade() from outside to []------>[ [name] ] ==> []------>[ [name] [age] ] []-----------------/^ remark: 3. select multi arg conveyors entry points and delete them => now you have a dict op stub : [ [name] [age] ] ***easy: named args operator drawing: comme avec le tableau mais en plus chic ***easy: [apply] [double apply] [triple apply] ... draw a pathmade which does not move, a pathmade "point", but invoke 1+ !apply! in it *flat loop: object goes back and forth [↦4]---<>--<>--<>--<> workflow: 1. pick [↦4]-->-->->-->, _entirely_ 2. valueScroll([↦4]-->-->->-->) ==> [↦4]---<>--<>--<>--<> easy:value-gradient path: [↦4]-->-->->---[[6]] workflow1: with 2 mathNodes 0.put [[6]] somewhere 1.pathmade() => [op] 2.pick [[4]] 3.[[4]].pathmade() starting over [op] ending over [[6]] workflow2: with 1 mathNode 1.pathmade() => [op] 2.pick [[4]] 3.[[4]].pathmade() starting over [op] valueScroll([[4]] -> [[6]]) release [[6]] variant: value-gradient loop: [↦4]---<>--<>--<>---[[6]] valueScroll([↦4]--->-->-->---[[6]]) ==> [↦4]---<>--<>--<>---[[6]] to see more intermediate values: move path ends OR zoom in edu: pour travailler sur les intervalles gm:challenge: the correct pick: user has reactors and must find the correct location on the gradient loop to fill its needs *firework generator: as soon as spawned, each value will follow its own path <----\ /---> (↦4)---> <---/ \---> variant: horse race generator: comb from generator /-------> (↦4)-------> \-------> * [apply].pathmade(): powder trails *decaying-value generator (linear decay): (↦1↘0) real-values linear decay numberTyping("|->1 to 0") (↦10{↘}0) integer-values linear decay *neuron: /-------------> [ [+] over [>4]-----------> ][↦1↘0(2s)]-------> \-------------> *touchSlot.pathmade(): clone output [[8]] * [+ 2]-----> = [[10]] \-------> [[10]] **rewrite star: yield different rewrited expressions /--------------------------> [[-b+a]] [[a - b]] * [a-b→-b+a:a-b→a+(-1)×b:a-b→2a-(a+b)]---------> [[a+(-1)×b]] \--------------------------> [[2a-(a+b)]] edu: insister sur le fait qu'une expression peut toujours être réécrite ****[discovery]freeDrawing::vDraw(): create a handwritten representation of object [[4]].vDraw(): from value to handwriting (not OCR but rather OCS: Optical character Specification) [[13]].pathmade(): draw a "13" (via pathmade::discontinuous path) then you can handwrite "4" in many different ways: you handwrite "4" you handwrite "||||" (4 sticks) you handwrite a rectangle of width 4 (Singapore method) you handwrite "IV" you handwrite a bizarre symbol (for brain teasers) etc. then you can do [[4 display:"||||"]] * [+ >>] * [[2 display:"||"]] = [[6]] [[5 display:"V"]] * [+ >>] * [[2 display:"II"]] = [[7]] edu: gros potentiel: on fait le lien entre la valeur abstraite et ses différentes représentations visuelles remarque: on peut aussi tracer des arcs et faire des challenges basés sur la traversée des arcs [+ 2].vDraw(): for it's an operator, a border (==touchSlot) will be added around handwritten "+ 2" examples: [ [+ 2] display:[· ||] ] [ [+ 2] display:[· ||] ] [ [+ 2] display:[ajouter 2] ] [["a"]].vDraw(): font specification: from character to handwriting (not OCR but rather OCS: Optical character Specification) same principle as for [[4]].vDraw(), this time with textual characters **easy: font object: spawn "abstract" character grid, and let user handwrite each character via [["a"]].vDraw(), [["b"]].vDraw(), etc. **easy: !apply! font: !apply!(font over text) ==> every character has now new font **edu: equations: use vDraw to have another approach on equations [[4 display:⍟]] * [+ 2] = [[6]] teacher: so what was ⍟ ? [[ [[4 display:⍟]] - 3] * [× 2] = [[2]] teacher: so what was ⍟ - 3 ? so what was ⍟ ? what was the last operation we did ? ... ***easy:throughDraw: define operator by drawing path A-->--[op]-->--B 2 flavors: via expressions: [[x]]-->--[op]-->--[[3x+2]] ==> [x↦3x+2] via samples: 1-->--[op]-->--2 2-->--[op]-->--4 5-->--[op]-->--10 ==> mapping operator [ 1↦2 ] [ 2↦4 ] [ 5↦10 ] edu: bien faire comprendre le domaine de définition d'une fonction (teacher: comment passer du mapping à une fonction continue ?) edu: bien faire comprendre la différence entre f et f(x) on peut définir des mappings par morceaux: [-9;-3[-->--[op]-->--50 [-3;+5[-->--[op]-->--20 [+5;+100[-->--[op]-->--30 on peut créer des fonctions variadiques/polymorphes avec ce système: exemple: [[x]]-->--[op]-->--[[2x]] [[x y]]-->--[op]-->--[[x+y]] [[x y z]]-->--[op]-->--[[2/3*(x+y+z)]] valueScroll may be used to specify output value **easy: named op stub: numberWriting("f: op") OR double click on [op] and write "f" *easy:throughDraw: differential equation: <--\ /---<-----<------<-----\ [[x]]-->--[f]-->--[derivative]-->--/ ([[x]]-->--[f] results in display " f(x) = " under cursor) \------/ equation is built gradually⌈ ***easy:throughDraw: group theory: define named operators using themselves say you have [f] and [g]: you can throughDraw: [f]-->--[f]-->--[g] (f(f) = g, or more simply: ff = g) [g]-->--[f]-->--[g] (f(g) = f, or more simply: fg = f) [f]-->--[g]-->--[f] (g(f) = f, or more simply: gf = f) [g]-->--[g]-->--[f] (g(g) = g, or more simply: gg = g) /!\ the more transformations are specified, the less valid throughDraws will be possible here it's ok because ffg == f(fg) == (ff)g == g => system must disable impossible outputs **state machine/bunnyDraw: state machine is an operator with a graph inside of it workflow: 1. add the different states to the machine: while zoomed in state machine area, !enroll_assign!([[value]]) to add a state !enroll_assign!([[peaceful]]), !enroll_assign!([[worried]]), !enroll_assign!([[angry]]) 2. if you want [[1]] to make machine transition from [[peaceful]] to [[worried]], bunnyDraw([[1]] from [[peaceful]] to [[worried]]) => it will create [[peaceful]]-->--1-->--[[worried]] etc. then you can try it: [[1]] * [state_machine (current: peaceful)] ==> [state_machine (current: worried)] **stateful operator: operator output depends on its inner state stateful operator = state machine + every transition has an associated function 18 décembre 2023: ***value-gradient path::static version: [[4--------6]], its value depends on where it's being operated on the path is not necessarily a segment all operators may have a little pick to indicate where the path is picked [[4]].pathmade() + release when over [[6]] [[4]].pathmade() + valueScroll (release on 6) examples: [[4-'------6]] * [+ 2] = [[6.3]] [[4------'--6]] * [+ 2] = [[7.5]] to be increase precision, static value-gradient path has a scaleless width edu: intuition des nombres réels edu: abscisse curviligne (par exemple avec des arcs de cercle) edu: parler des instruments à corde *game: static value-gradient X flappy bird: player must put static value-gradient so that it passes through interval test doors test door destroys static value-gradient if incoming interval is not contained in [door.min;door.max] **[structure]challenge:gm: labyrinth: must pass through door to get to target example: static value-gradient gm labyrinth: layout: initial: [[3--------10]] ops: doors: [2;3] [9.5;10] ... some doors are horizontal, some doors are vertical [rotate] to transform gm from horizontal to vertical ***zero-origin static value-gradient path: [[0--------5]] [[0---------5]] ***value-gradient path::split(): [[3--'------10]] * [split] = [[3--4.7]] [[4.7--------10]] ***value-gradient path::marker()/prepare(): marker will put a marker on the value-gradient path user may use this marker to aim prepare will also put a marker on the value-gradient path but this value will be used the next time it's operated on (to be simple: prepare = aimlock) example1: [[0---------10]] * [prepare: 25%] = [[0--2.5-------10]] [[0--2.5-------10]] * [+ 10] = [[12.5]] example2: [[3---------10]] * [prepare: 25%] = [[3--4.75-------10]] [[3--4.75-------10]] * [+ 10] = [[14.75]] **easy: icArray numberWriting("1 2 3 4 5") ==> [[1 2 3 4 5]] 20 décembre 2023: **[structure]gm:challenge: "sans la formule"(==uniquement le sens) des opérateurs destinés aux "petits", sans de précautions particulières autour de la notation [[2 4]] * [milieu] = [[3]] [[3 10]] * [au hasard à l'intérieur] = [[9]] ou [[4]] ou [[7.5]], etc. **eduDemo/eduAtelier: CS::routing: local node editors: user sees the full graph and some nodes have a frame around them so that the frame only contains the node, its input arrows and its output arrows full graph cannot be edited but, for each of the framed nodes, an editable frame is displayed below the graph it is the equivalent of a routing table, because the point of view is not global, but local variant: coop: each student has a node **gm:challenge:complex numbers::"reach Point T" to say it simply: "0 + starting point + vector (eventually rotated) + vector (eventually rotated) + ... = T" focus is always on rightmost operand layout: initial: [[0]] operators: s1. starting point affix operators: [+ a] [+ b] [+ c] [+ d] s2. affix translation operators: [+ (b-a)] [+ (b-c)] [+ (d-a)] [+ (b-a)/2] s3. affix rotation operators: [× exp(i Pi/2)] [× (-i)] [× exp(i theta)] (with theta an angle shown on the coords system) central area: coord system with O(origin) and T(target) and all the points whose affixes are appearing in the operators, and circles, and angles, and lines ... convention: Point A has affix a, Point B has affix b, ... workflow: 1. select a s1 operator 2. loop: select a s2 operator optional: loop: select a s3 operator the sequence of operation is enforced by: once an s1 operator has been used, all s1 operators become disabled focus is always on rightmost operand (so it eases applying multiple rotations to a "pathpiece" vector) *coordSystem is a member of the "iC in iC"-family so when you zScroll coordSystem, the two scale-systems (the one of the mother iC, and the one of the coordSystem) "slide" on each other **(*)"primitivification"(==type downgrade): delete(handle) will remove "most sophisticated composite engine" example: you have an icArray delete(icArray.handle) (==disarray) ==> now you have icComposite, delete(icComposite.handle) (==decompose) ==> now you have multiple objects **easy: enroll::create_array: create nested array !enroll!( [[1 '2']](2 has focus) over [[3]]) = [[1 [[2 3]] ]] *icArray's bizarre inner operations: (I against I) !alterate!([[1 2 3 4]], pick [[2]]) and !enroll! on 3 ==> [[1 [[3 2]] 4]] 23 décembre 2023: **(*)easy: enroll::create_array: operators ==> platform operator !enroll!([x 2] over [+ 3]) = [platform: [x 2] [+ 3] ] [[10]] * [platform: [x 2] [+ 3] ] = [[23]] create nested platform operator: !enroll!([platform: '[x 2]' [+] [x 5] ] over [- 4]) = **c++ operators into iC: say we have an array arr:[[z y x w v]] opérateur d'indirection: c++: *a iC: [[ arr[3] ]] * [valueOf] = [[w]] opérateur d'adresse: c++: &a iC: [[w]] * [address] = [[ arr[3] ]] opérateur de création d'instance: c++: new A iC: [[A(class)]] * [new] = [[a (instance of A)]] noexcept: c++: noexcept iC: noexcept curse on an object: [[icObj1]] * [curse: noexcept] == [[icObj1 (which will never become [[Exception]]) ]] noexcept behavior on an operator: [[icObj1]] * [behavior: noexcept] == [[icObj1 (which will never transform input into [[Exception]]) ]] **[variate](==[~→])/hardness: mutate into something that "is kinda like" hardness is used to specify how much variation can be applied on a member example: if "+" is infinitely hard in [[3x + 2]] then [[3x + 2]] * [~→] = [[7x + 3]] [[3x + 2]] * [~→] = [[9y + 2]] but it will never return [[9x - 4]] ***sample-based generator: generator will yield objects that "are kinda like" sample hardness of each member of sample is taken into account workflow: promote [[(2+3)x(10-4)]] to (⊢~→ [[(2+3)x(10-4)]] ) (⊢~→ [[...]]) is equivalent to (↦ !apply!([~→] over [[...]]) ) examples: !apply!( (⊢~→ (2+3)x(10-4) ) ) = [[(5+1)x(1-6)]] !apply!( (⊢~→ (2+3)x(10-4) ) ) = [[(7+7)x(8-1)]] **operator behavior: stylist: some mutated part is style rewritten stylist operator can be detected because its style is visible in its facade some stylist operators are "focused" (==they affect all significative members of input) example: [[21]] * [+ 5(stylist: vDrawn "fat 5")] = [[26 (with "fat 6")]] (the 2 is left unchanged) some stylist operators are "quasi-universal" (==they affect all significative members of input) example: [[523]] * [x 2(stylist: "thin 2")] = [[1046 (_all digits_ are stylized "thin")]] for the object, it's like a marker which divulges its having been transformed **(*)[structure]gm:challenge:target is style hybrid: target is composed of many styles, which are hints for transforming initial into target edu: c'est une façon de montrer l'empilage de couches résultant de la succession des opérations **bizarre: quasi-universal and focused versions of known operators quasi-universal addition: (carry is ignored, 0 is floor, 9 is ceiling) [[235.11]] * [⤉ 2] = [[457.33]] [[789]] * [⤉ 5] = [[999]] quasi-universal subtraction: [[235.11]] * [⤈ 2] = [[13]] (because it is [[013,00]]) focused multiplication: [[2[35].11]] * [⌧ 2] = [[270.11]] [[2[75].11]] * [⌧ 2] = [[350.11]] **LR_equality/L_operator,R_operator: LR_equality: [[ [[expr1]] == [[expr2]] ]] LR_equality may be true or false example: [[ [[A]] == [[B]] ]] * [L: [+ 2] ] = [[ [[A + 2]] == [[B]] ]] precisely: [L: [+ 2] ] <--------[[----[[A]] == [[B]] ]] = [[ [[A + 2]] == [[B]] ]] (A touches L op) likewise: [[ [[A + 2]] == [[B]] ]] * [R: [- 3] ] = [[ [[A + 2]] == [[B - 3]] ]] precisely: [[ [[A + 2]] == [[B]]--]]----->[R: [- 3] ] = [[ [[A + 2]] == [[B - 3]] ]] (B touches R op) layout: a column of L_operators on the left, a column of R_operators on the right **[structure]gm:challenge: build me true equalities target touchSlot is a giant backing touchSlot which has the size of the challenge area the goal is to create a true equality, as soon as a gm becomes a true equality, challenge is completed layout: top: initial [[ [[expr1]] == [[expr2]] ]] left: right: l-operators r-operators ***T is for Truth: a 'T', an 'F', or a '?' is displayed over the relation of a relation-defined statement to indicate its truthValue truthValue-bearing LR_equality: middle relation is bearing truthValue, it updates along with mutations of lhs and rhs T= means truthfully equals T≠ means truthFully not-equals it is equivalent to F= edu: c'est mieux de l'écrire F=, et de demander aux élèves d'essayer de "garder le T" [[ [[A]] T= [[B]] ]] * [L: [+ 2] ] = [[ [[A + 2]] F= [[B]] ]] (=?= means possibly equals identities such as fair rewriters or simplifiers preserve truthValue [[ [[2x(3+4)]] T= [[B]] ]] * [L: rewrite: develop] = [[ [[2x3+2x4]] T= [[B]] ]] truthValue-bearing LR_inequality: [[ [[A]] T< [[B]] ]] * [L: [+ 2] ] = [[ [[A + 2]] ?< [[B]] ]] edu: même système avec les inégalités: demander aux élèves d'essayer de "garder le T" truthValue-bearing statement: T" " edu: expliquer la logique du processus de démonstration: on part de plusieurs T" ... " pour aller à T" propriété que l'on voulait démontrer " **[structure]gm:challenge: solving equations (part 2): initial: [[ [[A]] T= [[B]] ]] ops: L_ops and R_ops target: [[x T= ?]] difficulty: hard: as soon as initial is transformed, relation is displayed '?=' **(*)[structure]gm:challenge: build me an array layout: top: M_operators left: center: right L_operators [[initial]] R_operators [[target]] bottom: M_operators M_operator: element-wise operator that only operates on the middle elements: it neither operates on first element nor on last element L_operator: firstElement-only R_operator: lastElement-only remark: L/M/R_operator may be an enrolling/derolling operator: [ enroll [[4]] ], [deroll], [extend [[4 5 6]] ] 24 décembre 2023: *affirmation operator: [†] (U+2020 DAGGER) it is true that ... [[x + 2 = 4]] * [†] = [[x + 2 T= 4]] remark: T= could be written †= edu: voilà un vrai démarrage pour une démonstration mathématique: "Supposons que ..." **!apply_clone!: number vs object !apply_clone!([[18]] over [[candle]]) = [[candle candle candle candle ... candle]] (18 elements) same thing with !apply_clone!([[candle]] over [[18]]) **dot group(==multiset of dots)/additive union operator [⊎]: reactor maker: [[:::]] * [⊎>>] = [[::: ⊎>>]] [[::: ⊎>>]] * [[:.]] = [[::::.]] unary op: [[:::]] * [⊎ .:] = [[:::.:]] binary op: {[[:::]] [[.:]]} * [⊎] = [[:::.:]] edu: c'est drôle de se dire que "le premier opérateur de notre vie", a une écriture si compliquée **array of dot groups/!enroll_dot!: !enroll_dot!([[:.]] over [[.]]) = [[::]] !enroll_dot!([[:. [:::] .]] over [[.]]) = [[:. :::. .]] eduDemo: 2 + 2 + 2 = 6 workflow: spawn 2 select 2 clone, clone enroll, enroll [[2 2 2]] * [dotsify] = [[: : :]] (here it's an element-wise dotsify, "[¨dotsify]") (¨ is APL each) [[: : :]] * [reduce:⊎] = [[:::]] [[:::]] * [count] = [[6]] **colored dots: black dot = 1, red dot = 10, blue dot = 100 => multisets of colored dots example: [[blue red red black black black]] (.value: 123) fair rewriters: (==conversion operators) develop: [red dot → :::::] [blue dot → red red red red red red red red red red] factorize: [::::: → red dot] ... edu: numération décimale **swing_rub::dots: !swing_rub!([[:::.:]]) = [[::::.]] !swing_rub!([[:::.:.....:]]) = [[::::: :::]] 25 décembre 2023: **colored dots:: relative numbers: white dot = -1, green dot = -10, orange dot = -100 easy: reactor dot VS reactor dot battle: freeDraw black dot ==> [[black >>]] (displayed simply as a black dot) freeDraw white dot ==> [[white >>]] (displayed simply as a white dot) [[black >>]] * [[white >>]] = [[None]] aggregate: [[black >>]] * [[black >>]] = [[black black >>]] *[battle] operator/!enroll_battle!: {[[black black black black black]], [[white white white]]} * [battle] = [[black black]] !enroll_battle!([[black black black black black]] over [[white white white]]) = [[black black]] fair generator: (↦[[black white]]) fair terminator: [ (black,white)↦] (terminate 1 couple) [ {(black,white)}↦] (terminate all couples) **!deroll__bottomless!: the road to infinite debt !deroll__bottomless!([[black black black]]) = [[black]](dropped), [[black black]](held) (same as standard !deroll!) ... !deroll__bottomless!([[black]]) = [[black]](dropped), [[None]](held) (same as standard !deroll!) !deroll__bottomless!([[None]]) = [[black]](dropped), [[white]](held) !deroll__bottomless!([[white]]) = [[black]](dropped), [[white white]](held) variant: anti deroll: instead of losing 1, you gain -1 !deroll__anti!([[black]]) = [[black]](dropped), [[black white]](held) variant: random-variant bottomless deroll: deroll is either bottomless deroll or anti deroll !deroll__bottomless__random!([[black black black]]) = [[black]]dropped and EITHER [[black black]](held) OR [[black black black white]](held) **!deroll__bottomless! on numbers: !deroll__bottomless!([[1]]) = [[1]](dropped), [[0]](held) !deroll__bottomless!([[0]]) = [[1]](dropped), [[-1]](held) **gm:challenge:deroll: layout: initial: [[12]] operators: sinks which must be "watered" with [[1]]s the sum of all sinks need for fill is sometimes greater than initial, and sometimes less example: !deroll__bottomless!([[12]] over [sink: 2]) = [sink: 1], [[11]](held) target: target's touchSlot unlocks when all sinks have been filled target's facade shows the total filling of the sinks edu: pour que l'élève voie petit à petit la gm se vider puis passer dans le négatif au bout d'un moment, -8(gm) + 20(total fill) = 12(initial) lui paraîtra assez naturel la gm est comme un arrosoir et les sinks comme des pots de fleur *simplifier une expression, c'est perdre de l'information quand on lit une chaîne d'équivalences, la plupart du temps, _même si les expressions restent équivalentes_, on perd de l'information exemple: 2 + 3 = 5 <=> 5 = 5 une transformation entre 2 expressions équivalentes ne veut pas dire une expression isentropique réversible passer de 5 = 5 à 2 + 3 = 5, c'est beaucoup moins évident que de passer de 2 + 3 = 5 à 5 = 5 ***(*)imido: the way of the meaning: student visually builds the transformation they want to use the system interprets their drawing/construct so that it behaves like a standard operator ***dot-based imido: fraction via dots: example: (since there are many different ways to represent fractions) student wants to build an operator that takes 2 out of 3 workflow: 1. freeDraw 2 green dots and 1 black dot 2. [[green green black]] * [imido] = [green green black] OR !imido!([[green green black]]) = [green green black] 3. [[30]] * [green green black] = [[20]] scaling via dots: example: student wants to build an operator that rescales from size 3 to size 2 workflow: 1. freeDraw 3 dots, an arrow(→), 2 dots 2. !imido!([[⋮ → :]]) = [⋮ → :] 3. [[27]] * [⋮ → :] = [[18]] remark: student may even simply write [[⋮ :]] !imido!([[⋮ :]]) = [⋮ :] which will work the same as [⋮ → :] ratio via dots: example: [[20(green)]] * [green green black] = [[20(green) 10(black)]] **gm:challenge: great mix: operators with different facades: [x↦x-7], [⋮ → :], [+ 3] ***number-based imido: scaling via numbers: student wants to build an operator that rescales 9 into 6 1. numberWriting(9) 2. numberWriting(6) 3. pathmade from [[9]] to [[6]] => it creates [9⊢∻→6] (∻ is the symbol for homothety) [[45]] * [9⊢∻→6] = [[30]] 26 décembre 2023: **!enroll!::icRect (another road to Singapore) !enroll!([[rect:1]] over [[rect:1]]) = [[rect:1 rect:1]] !enroll!([[rect:4 rect:2]] over [[rect:3]]) = [[rect:4 rect:2 rect:3]] eduDemo: intro aux équations v [[rect:4.1 rect:2.7 rect:5.4]] v v [[rect:10.2 rect:?]] v ***!vertEnroll!/vertArray: create vertical array instead of horizontal array => Singapore = !vertEnroll!(horiz_array1 horiz_array2) shortcut: V.!enroll! **singapore operators: !enroll_fill!, !enroll_fill_max!, !grow!, !grow_max! !enroll_fill!: create rect which goes to next tack of upper row (↦|-->|) !enroll_fill_max!: create rect which goes to next tack of upper row (↦|-->>|) !grow!: grow last row's last rect to next tack of upper row [-->|] !grow_max!: grow last row's last rect to last tack of upper row [-->>|] **vertFocusScroll/horizFocusScroll: change focus vertically, change focus horizontally this allows building complex v/h structures ***behavior:logged: log of transformations is kept in vertArray example: 1. [[2]] * [+ 3] = v [[2]] v v [[2]] * [+ 3] = [[5]] v 2. v [[2]] v v [[2]] * [+ 3] = [[5]] v * [^ 2] = v [[2]] v v [[2]] * [+ 3] = [[5]] v v [[5]] * [^ 25] = [[25]] v edu: se rapprocher du style "Des chiffres et ... des chiffres" **trequality: vArray(expr1,=,expr2,=,expr3)/quadrequality, etc. edu: peut-être qu'avec 3 expressions, ce sera plus clair qu'avec 2 gm:challenge: build me a true non-redondant trequality using vert/horizFocusScroll/focusScroll(=="zFocusScroll"), student can control focus only focused will be touched or applic'd to edu: amener les élèves à fabriquer trois fois la même valeur, mais de 3 façons différentes 27 décembre 2023: **(*)auto-reverse operator: this operator contains its reverse operator 2 flavors: oriented: [[2]] --*--> [x ⇹ x+1] = [[3]] [x ⇹ x+1] <--*-- [[2]] = [[1]] unoriented: operator marks output value to be able to reverse it example1: toggle: [constant1 ⇹ constant2] [[2]] * [2 ⇹ 3] = [[3]](.isBijected__B) [[3]](.isBijected__B) * [2 ⇹ 3] = [[2]]((.isBijected__A))(not necessary) example2: linear func: [[2]] * [x ⇹ 2x+1] = [[5]](.isBijected__B) [[5]](.isBijected__B) * [x ⇹ 2x+1] = [[2]]((.isBijected__A))(not necessary) whereas [[5]] * [x ⇹ 2x+1] = [[11]](.isBijected__B) edu: peut-être que c'est une bonne façon d'introduire les fonctions (même si c'est que des fonctions inversibles) ***zOperator(==donut operator): operator activates when input has dived enough into it user may then encounter other objects "inside" the zOperator (which are completely unaffected by the zOperator) so the descent can continue... zOperator's donut shape may be freeDrawn (as long as it's a hole) 3 flavors: mono: z-in: [⏬+ 2] z-out: [⏫- 3] auto-reverse: z-inout: [⏬⏫x 10] (== [⏬x 10] AND [⏫/ 10]) edu: base décimale avec les dots, [⏬⏫x 10] permet de passer de 1 dot à la scale N à 10 dots à la scale du dessous gm:challenge:z-in,z-out: initial goes to target via a series of descents and ascents **zOp::dots: highest dot rank operators: converts all dots so that the specified color(==rank) is the highest examples: [⏬highest dot value: black] [⏫highest dot value: red] or even more natural: [⏬highest dot value: black : ⏫highest dot value: red] edu: pour montrer facilement la transformation en faisant des zooms avant, zooms arrière, zooms avant, zooms arrière, ... **zMultiOperator(==cheese operator): operator activates when input has dived enough into one of its zones typical usecase: multiFairRewriter: [⏬y→y+1-1:y→y×2/2:y→(y):y→(-y)×(-1)] layout: far: [id] near: [ [] [] ] (each of the 4 zones can be dived in) [ [] [] ] **zCondOperator(==bouncer operator): descent happens only if cond(held) == true remark: there may also exist z-out cond operators: ascent happens only if cond(held) == true **zCondMultiOperator(==cheese guide): this may be a way to guide user to where they should go (given the object that is held) *secured operator: operator is so complex to trigger that user won't trigger it by mistake example: secured operator = condCrossOp+zOp+applicableOp user first has to cross the operator with a valid object, then dive into zOp, then activate applicable operator... **colored dot gradient: black:1, red: 10, so something between black and red may be 7.3 for example edu: numération en base non entière ? **easy:tunable operator: [+ ⇳]: when input is over operator, operand can be valueScroll'd (even coarse-valueScroll'd) numberTyping("+ tune") edu: priorités opératoires **[discovery]!elastify()!/[elastify()]: gm curse at prop level(==[curse: gm()]): prop goes back to its elastified value when object is released example: !elastify(.value)!([[1]](held)) = [[1]](held) (.value:1 is elastified) !valueScroll!([[1]](held)) = [[2]](held) !release!([[2]]) ==> it goes back to its elastified .value: [[1]] some operators may remove the elastic curse (so that they may put back a fresh elastic curse): typical usecase: zOperator/elastify(.homeScale): zOperator is a bridge from one homeScale to another [[1]] * [⏬/ 10] = [[0.1]] (this is a way to create a coupling between the zoom level and the value) **dotsify(number)/numberify(dots): from number to array of colored dots [[4312]] * [dotsify] = [[4{purple} 3{blue} 1{red} 2{black}]] [[4{purple} 3{blue} 1{red} 2{black}]] * [numberify] = [[4312]] 29 décembre 2023: **printPovRect: one content page printed multiple times by varying povs example1: focus on different areas of a map example2: create character-focused cartoon frames from one big diorama workflow: 0. create content loop: 1. spawn printPovRect rect (an index is automatically assigned to it) 2. adjust printPovRect's corresponding page format (A4,A4Landscape,A3, A3Landscape,...) (rect automatically rotates) 3. bring printPovRect to its desired location system dynamically creates a print preview, somewhere on the side, on inside a dedicated "print" area => une tournure d'impression(EN: a printing turn) == une suite ordonnée de printPovRects => as each printPovRect has its own page format, different page formats could be used for a same printing turn :) default printing turn: pour éviter des tracas aux profs, au moins une tournure d'impression(tournure par défaut) devrait être contenue dans chaque fichier ressource de prof (pour éviter de se prendre la tête à retrouver comment l'auteur imprimait son fichier graph-based printing turn: create multiple books of varying complexity by changing the max depth in the printing turn graph simple book: graph depth: 0 (only main sequence) standard book: graph depth: 1 (main nodes + their children) advanced book: graph depth: 1 (main nodes + their children with their children) edu: pour le théâtre par exemple **2D-tunable/space-based tunable: generator: 2D-tunable: (↦✢(2D)) shortcut: !apply_hold!(== keep !apply! down) and move mouse typical usecase: pick 2D vector in a coordSystem variants: (↦✢R²) (↦✢N²) (↦✢R×Z) 1D-tunable: (↦✢(1D)) variants: (↦✢R), (↦✢Z) (↦✢2Z) (↦✢[[1;n]]) operator: same as generator but with an held object examples: [[2 3]] * [+ ✢R×N](choose: [[+ 1.5 10]]) = [[3.5 13]] [[2]] * [+ ✢Z](choose [[+ (-10)]]) = [[-8]] **[structure]edu: history/historicity of math: there are gm challenges for each era in the history of math numbers and operators and other objects are displayed with the notations of the era edu: student is the witness of the igniting/growth/spreading of math over the times **[structure]edu: geography/geographicity of math: edu: student is the witness of the igniting/growth/spreading of math over the world **edu: montrer les zéros inutiles [[140]] * [🄌..] = [[0140]] [[0140]] * [..🄌] = [[0140,0]] [[140]] * [ [repeat(5)] over [🄌..] ] = [[00000140]] (or even [ [[5]] over [repeat] over [🄌..] ]) gm:challenge: operator only works if input has valid number of digits [[000000000000000140,0000000000000000000]] * [+ 000000000000000223,0000000000000000000] = [[000000000000000363,0000000000000000000]] variant: dots [[143]] * [dotsify] = [[. :: :.⌋]] (⌋ is for units box (displayed on screen with thick-border box), the other boxes have normal border) [[: :: :.⌋]] * [🄌..] = [[▭ . :: :.⌋]] (▭ is for 'empty box') [[: :: :.⌋]] * [..🄌] = [[▭ . :: :.⌋ ▭]] **povCurse: while , pov is static typical usecase: while (gm is held), pov is static gm: challenge: out-of-screen experience: workflow: 0. standard pov displays 9 areas : the central area and its 8 adjacent areas (or some part of them) ▭▭▭ ▭▰▭ ▭▭▭ the adjacent areas contain operators 1. as soon as user holds povCursed gm, central area ▰ becomes the screenPov => 2. user has to move gm outside of screenPov to use operators the area on top of ▰ and the area below ▰ will be 2 flavors: "overflow" mouse control: even if cursor seems locked on top of screen, gm may continue going upwards WASD keyboard control: gm hold/release is done with mouse while gm is held, pressing keyboard keys is the only way to move gm *pov::cylinder wrap/torus wrap 04 janvier 2024: **radialPushScroll/radialPullScroll: radialPushScroll(==give air): push what is outside radius even farther, radially workflow: 0. hold an object (or nothing) 1. enterRadialPush: press and hold shortcut key (Shift.R) 2. radialInit: scroll to set desired radius (a default radius had appeared when entering radialPush) press rightMouseButton to set initial radius 3. scroll out to push objects out 4. leaveRadialPush: release shortcut key radialPullScroll(==gather): vacuum things in around held object, control radius with mouseWheel workflow: 0. hold an object (or nothing) 1. enterRadialPull: press and hold shortcut key (Shift.T) 2. radialInit: scroll to set desired radius (a default radius had appeared when entering radialPush) press rightMouseButton to set initial radius 3. scroll in to pull objects in 4. leaveRadialPush: release shortcut key 08 janvier 2024: *pixelGrid/pixelStrech: spawn pixel grid and change size afterwards while dragging, a label dynamically indicates grid size workflow: 1. enterPixelGridMode 2. click and drag to desired size example: 6x5 **pixelPushScroll/pixelPullScroll: same as radialPushScroll/radialPullScroll but inside a grid of pixels: since pixelGrid has a finite size, not only does held pixel grow, but all other pixels shrink accordingly variants: diffusionPixelPushScroll/diffusionPixelPullScroll: neighboring pixels around held held pixel also grow wrt to their distance to held pixel example: gaussianPixelPushScroll colorPixelPushScroll/colorPixelPullScroll: colorPixelPushScroll: don't change pixel size but push its color to other cells colorPixelPullScroll: don't change pixel size but push mean color of other cells to held pixel diffusionColorPixelPushScroll/diffusionColorPixelPullScroll *math:equivalent applications: though the transformations have specific inner workings, they can be considered equivalent this allows explaining how works a new, more sophisticated way of transforming: !apply!( [[2]] over (+ 7) ) <*=*> [[2]] * [+ 7] = [[9]] remark: !apply!( [[2]] over (+ 7) ) <*=*> [[2]] * [+ 7] is lhs of "=" [[9]] is rhs of "=" *symbol for screenPov: 🗖 ***[structure]bombOperator: operator finds its arguments in a certain area, when !apply!'d radialBombOperator: operator finds its arguments in bombRadius, when !apply!'d bombOperator is an applicable operator example: !apply!( (⬭ (a,b↦b-a)){ [[2]] (near), [[3]] (far)} ) <*=*> {[[2]], [[3]]} * [a,b↦b-a] = [[-1]] bombOperator may be enabled/disabled wrt input arguments, to indicate user that it is ready to be applied or not argument resolution algorithm: sort arguments using distance to bombOperator loop: pick first argument matching parameter's type (for example: pick first found string) unused arguments are left unchanged edu: screenPovBombOperator: operator finds its arguments in screenPov(rect and _scale_), when !apply!'d example: !apply!( (⬭🗖 (/)){ [[2]] (near), [[3]] (far), [[5]] (farther) } = [[2/3]](where [[2]] was), [[5]](unchanged) outerFeedBombOperator: operator finds its arguments in outerFeed area, when !apply!'d outerFeed: [[⬭↥ {}]] outerFeedBombOperator: (⬭↧ ({3}+)) {3}+ is the ternary + operator => when 3 arguments are in [[⬭↥ {}]]'s aera, (⬭↧ ({3}+)) can be applied mineOperator: operator triggers as soon as all required arguments are found in mineRadius mineOperator is a standard operator fun(?/edu?): screenPovMine: if you get too close(==if screenPov gets close to the mine), then the mine will find valid-scale arguments and, consequently, actionate outerFeedMine: mine outerFeed: [⬭↥ {}] outerFeedMineOperator: [⬭↧ []] [[2]](held) * [⬭↥ {[[5]]}][⬭↧ [+]] = [[7]](held) [[2]](conveyed) * [⬭↥ {[[5]]}][⬭↧ [+]] = [[7]](conveyed) *bombWell/mineWell: output is spawned where operator is (and then be conveyed by outputConveyor ***geographical scope(== infiniteRadiusBombOperator): operator finds its arguments radially this is nice with named parameters (x("a"),y↦x-y) has 2 parameters, a named parameter "a", and another anonymous parameter !apply! on this operator will make operator look for its input arguments => the nearest object named "a" will be chosen as first parameter edu: pour expliquer les scopes via le programmadraw **pathmade::outputConveyor: make output be conveyed, only output is conveyed => compose functions by creating sequences *edu: make 50-hour math game, like a standard RPG, so that playing this video game is highly rewarding in the school system *spaceScroll: change root iC via scroll (think "change reality") "half in worldA, half in worldB" 10 janvier 2024: **iC in iC::!iC_in!/!iC_out!: as in Inception, enter and leave dreams !iC_in!: enter in child iC under cursor !iC_out!: get out to parent iC (if any) HUD: show current iC as for current color **iC in iC::reverseJigsaw: navigate in each sub-ic, in order to assemble puzzle pieces lying in different spaces [ rootIc ] [ [ ic1 ° ][ ° ic2 ] ] [ [ ic3 \_][_/ ic4 ] ] [ ] (*iC in iC::invisible sub layer: it seems that ic2 is direct child of rootIc whereas the hierarchy is actually rootIc ⊃ ic1 ⊃ ic2 ic1 overflows screenPov so we don't see it (if its background color is transparent) **** is screenPov: [ ic1 ] [ [ rootIc ] ] [ [ ********************** ] ] [ [ * [ ic2 ]* ] ] [ [ * [ ]* ] ] [ [ ********************** ] ] [ [ ] ] **game:dictopia::maths: [1] [1] [2] [2] [+] [-] [+] [×] ... target is interval, or easy-to-build number eyes are still here examples of constraints: use only even numbers don't use "×" **(*)indexScroll: like numberScroll for inner index !indexScroll!([[u_n+1 == 2 u_n]], mouseWheelUp) = [[u_n+2 == 2 u_n+1]] Shortcut: N.I majorIndexScroll: !indexScroll(maj)!([[v_n == 3 u_n+1]], mouseWheelUp) = [[v_2n == 3 u_2n+1]] Shortcut: Shift.N.I edu: pour les suites, bien sûr sequence term may have this layout (like a named variable): [[u_n+1 ]] [[ ]] [[ 2 u_n ]] [[ ]] edu: pourquoi pas aussi pour les fonctions !indexScroll!([[f(x)= 2x - 4]], mouseWheelUp) = [[(f(x+1)= 2(x+1) - 4]] !indexScroll!([[x↦2x - 4]], mouseWheelUp) = [[(x+1)↦2(x+1) - 4]] edu: ce serait intéressant de demander aux élèves (ou plutôt aux étudiants) pourquoi l'indexScroll sur les équations n'est pas une bonne idée !indexScroll!([[x + 3 == 2x - 4]], mouseWheelUp) = [[(x+1) + 3 == 2(x+1) - 4]] réponse rapide: !indexScroll!([[f(x) == g(x)]], mouseWheelUp) = [[f(x+1) == g(x+1)]] pas du tout assuré, car on considère que c'est le même x avant et après **gm:math:challenge:sum of disparate sequence terms: challenge1: manipulate layout: labels: u_n = 3n - 2 v_n = n - 10 w_n = 6n initial: [[u_n ]] (player may have to indexScroll, once held) [[ 3n - 2 ]] ops: tunable operators: (tuning is indexScroll (no need to press indexScroll shortcut)) [+ v_n ⇳] [+ w_n ⇳] [ n - 10 ] [ 6n ] target: [[u_n+2 + v_n-1 + w_n+3]] => when player has crafted [[u_n+2 + v_n-1 + w_n+3]], its general term is thus displayed [[u_n+2 + v_n-1 + w_n+3 ]] [[ (3(n+2) - 2) + ((n-1) - 10) + (6(n+3)) ]] [[ ]] remark: initial may be: [[u_n + v_n+2 ]] to make player understand the effects of indexScroll challenge2: look for valid tuning ops: tunable operators ((and [simplify])) target: expression with n remark: challenge is easier with an unsimplified target, challenge is harder with a simplified target challenge3: composition of sequences labels: u_n = 3n - 2 v_n = 2u_n w_n = u_n+1 + 3 target: expression with n remark: challenge is easier with such a display: [[w_n ]] [[ (3(n+1) - 2) + 3 ]] challenge is a bit harder with such a display: [[w_n ]] [[ u_n+1 + 3 ]] challenge is a bit harder with such a display: [[w_n]] 11 janvier 2024: **iC in iC::holed iC: even more room: holed iC contains the part of the container that is used to contain it, so no room is lost in the process, we add another infinite space to the existing infinite space 14 janvier 2024: **Bekenstein::bit bottom: at deepest zoom levels, we see individual bits as squares. **god objects: GodObject/GodEngine: objects contained in god object must follow godObject's rules GodEngine may trigger when anything happens inside it It's like a curse for all contained objects 2 flavors: semiGod: rect + engine, so big that contained objects are supersmall wrt it fullGod: icCanvas + engine: god is infinitely big wrt objects inside it **challenge:math: compte est bon (non-gm) initial: non-gm initial objects (numbers) ops: [+] [-] [x] [/] target is a number Retry: there is a retry button OR easy: when player releases an initial outside challenge area, all initial objects are reset ***!apply_held!: !apply! "in hand" (operation happens on held objects) !apply_held!({[[3]], [+ 2]}(held)) = {[[5]], [+ 2]}(held) !apply_held!({[[5]], [+ 2]}(held)) = {[[7]], [+ 2]}(held) edu: montrer les suites récurrentes, en faisant !apply_held!, !clone!, !apply_held!, !clone!, ... !clone! a un comportement spécifique quand il y a plusieurs objets dans la main: seul le premier objet est cloné !clone!({[[7]], [+ 2]}(held)) = [[7]](cloned), {[[7]], [+ 2]}(held) edu: fibonacci: !apply_held!({[[0]], [[1]], [+]}(held)) = {[[1]], [[1]], [+]}(held) !apply_held!({[[1]], [[1]], [+]}(held)) = {[[1]], [[2]], [+]}(held) when 2+ values are held, leftmost is popped, new value is pushed on right side 15 janvier 2024: **edu: n-digit-input operator: operator only actionates when all inputs have n or less digits 1-digit-input add: {[[7]], [[8]]} * [+ (1-digit-input)] = [[15]] {[[7]], [[10]]} *\ [+ (1-digit-input)] *\ is the symbol for "operation is not possible, nothing will happen" 2-digit-input add: {[[7]], [[10]]} * [+ (2-digit-input)] = [[17]] {[[70]], [[100]]} *\ [+ (2-digit-input)] edu: l'algorithme d'addition de nombres à 2+-chiffres, l'algorithme de multiplication de nombres à 2+-chiffres l'élève gagne d'abord le droit d'utiliser [+ (1-digit-input)] en ayant réussi un challenge de tables d'addition de 2 nombres à 1 chiffre l'élève réalise des additions de 2 nombres à 2 chiffres en manipulant les chiffres qui constituent les 2 nombres l'élève réalise des additions de 2+ nombres à 2+ chiffres **edu: comma-required-input operator: operator only actionates when all inputs have a comma {[[7,0]], [[8,1]]} * [+ (comma-required)] = [[15,1]] {[[7]], [[8,1]]} *\ [+ (comma-required)] 16 janvier 2024: **zIndexDiveOperator: same as diveOperator but "zooming in" is replaced by "going behind" **icObjType = "icDisplay": displays stuff **icObj.type = "innerCamera": displays what is inside icEye innerCamera = icEye + icDisplay **!autoPov!(icObj): set screenPov so that iC.scale == icObj.homeScale 17 janvier 2024: **icInOutPortal: composite(portal_direct, portal_reverse) ***spaceVar: a small area of space as any other variable ****[discovery]!transport!/transportationScroll: any object can be used as a travel_start/travel_end (fondu sur objet) it's a bit like portals but, now it's ad hoc shortcut: E.scroll workflow: put cursor over object(travel_start) and E.mouseWheel: screenPov changes so that cursor is now over an object(travel_end) which is related to travel_start if there is an held object while using transport, everything changes but held object iC.scale does not change flavors: object-based transportationScroll: from object1 to object2, object2 being "same" as object1 fun: this could be used to create mazes (transportation being the only way to move from area1 to area2 (isolated by hard walls)) pov transportationScroll: shortcut: Shift.E.scroll this is a way to move from pov to pov without using a gotopov button screenPov just needs to be "around" povRect (not too deep inside) value-based transportationScroll: from object1 to object2, object1 and object2 evaluating to same value => this transportationScroll could be used to recreate find/replace in iC transportationScroll("saison", mouseWheelUp) condition-based transportationScroll: held object is condition from object1 to object2, object1 and object2 satisfy condition => this transportationScroll could be used to create a more sophisticated find/replace in iC 18 janvier 2024: ***[transport]: the operator equivalent for !transport! command (screenPov may not follow object) typical usecase: bidirectional transport pod [transport: zoneB->zoneA]'s slot__in is [transport: zoneA->zoneB]'s slot__out workflow: [transport: zoneA->zoneB].in touches [[obj]](held) => screenPov changes to zoneB and we see that [transport: zoneA->zoneB].out touches [[obj]](held) then [[obj]](held) leaves [transport: zoneA->zoneB].out and becomes untouched from this moment, if user moves [[obj]](held) back to [transport: zoneA->zoneB].out, where there is [transport: zoneB->zoneA].in: [transport: zoneB->zoneA].in touches [[obj]](held) => screenPov changes to zoneA and we see that [transport: zoneB->zoneA].out touches [[obj]](held) (this is like transport::menu, but simpler) **transport::[transport_switch]/(transport_switch): touched object is transported to a different location depending on switch function [t] [t.1] [t.2] [t.3] [t.4] example: [["abc" (blue)]] * [t_switch] = [["abc" (blue)]] (transported at [[t_switch.blue]]) ultraeasy version: n * t = t.n (transport_switch): applicable operator counterpart of [transport] !apply!( (t_switch) ) does nothing, user must use !transport! over it, with an held object !transport!([[2]] over (t)) ==> [[2]] is now over [[t.2]] **transport:: rotate and flip dev: fun time!... **freeDrawing X transport: begin at one place, continue at another, etc. **transport::scrolling fever(==scroll scratch): fast transportation scroll makes image appear because of persistence of vision fun: une énigme d'escape game peut être fabriquée de cette façon edu: superposer deux contextes différents, sans vraiment les superposer concrètement draw: create sprite animations workflow: 1. spawn [[1]] and [[2]] 2. draw around [[1]] 3. draw around [[2]] 4. scrolling fever: [[1]] <-> [[2]] to see the 2 drawings superimposing (because of persistence of vision) this allows making adjustments ***(*)transportGM: greenMouse X transport: challenge1 and challenge2 are isomorphic moving greenMouse in challenge1, also moves it in challenge2, so that !transport! feels like a change of representation (and does not feel like a move) variant: that's-math: some operators are disabled in challenge1, but there isomorphic counterparts are enabled so the challenge is to move back and forth from a representation to another to transform initial to target(maybe an isomorphic target) 23 janvier 2024: **(*)functions which return pathmade symbol: [↝ ] [[↝ .]] is the dot path: path consisting of only 1 point example1: [[↝ .]] * [↝ ⤙⇉4] = [[↝ ⤙⇉4]] [[↝ ⤙⇉4]] * [↝ ⤙⇉4] = [[ ⤙⇉4]] [[↝ ⤙⇉ ⤙⇉4]] [[ ⤙⇉4]] [[ ⤙⇉4]] operator applies to each path ending example2: transform standard operator into pathmade by appending a path [+ 2] * [↝ →] = [↝ [+ 2]→ ] (we append an horizontal arrow chunk on right side) **function with callback: callback is called when function has finished **recursion: 2 flavors: 1. by zooming in 2. by using gotos **function sub operator: operator is contained in function definition ***ingredients pathmade: this pathmade returns all the ingredients that would then be combined by combiner pathmade ⤙ ⤚ ⤙⤙ ⤚⤚ input ⤙⤙⤙ ⤚⤚⤚ output ⤙⤙ ⤚⤚ ⤙ ⤚ ingredients combiner pathmade pathmade edu: pour que les élèves séparent d'un côté les constantes et les variables et de l'autre les opérateurs **gm:challenge: bit challenge: the carry proto-rule: □■ + □■ = ■□ layout: initial: □□■□ ops: [+ □■□□] [+ □□□■] ... target: ■□□■ remarks: [+ □□□■]'s use may be limited length 3 then length 5 then length 10 **gm:challenge: base3 challenge: more carry proto-rules base3 will have 3 colors: white, black, red **iCInnerCam::daydream: displayed object may be used as any other object 2 flavors: daydream shade (eyed object is mutated): [[ icDisplay displaying [[4]] ]] * [+ 2] = [[ icDisplay displaying [[6]] ]] daydream (displayed object is independent from eyed object): [[ icDisplay displaying [[4]] ]] * [+ 2] = [[6]] ***!ref!:reference extrusion: create ref from held object and continue with ref edu: pour avoir des objets nombres, les uns placés sur la droite numérique, les autres servant à faire des calculs layout: number line: -----[[0]]---------------[[4]]---[[5]]--------------[[9(ref)]]----------------------> operations: {[[4(ref)]], [[5(ref)]]} = [[9]] !ref([[9]])! !warp!([[9(ref)]]) **!toggle_scaleful!: scaleful object becomes scaleless, scaleless object becomes scaleful edu: pour expliquer les objets avec et sans dimension ****transport::object's place/!object_place!: any object can have its own little place to store objects, host drawings, images, ... !object_place!([[x]]) creates an object place for the input object, if it does not exist yet, and moves screenPov to its location shortcut: E.F.scroll !object_place!([[x]]) = |-------------------------------------------| [[x]] c:[[4]] [[2]] [[y]] [f]| |-------------------------------------------| [[x]]'s place this allows creating arrays, dicts, and OOP objects with attributes and methods (classes and instances) [[2]] in [[x]] may be symbolized [[ x::[[2]] ]] as soon as object_place is created, a default constructor is created !apply!([[x]]) = [[4]] ***!propScroll!/[prop ⇳]: get property in object_place !propScroll!([[x]], mouseWheelDown) = [[ x::[[2]] ]] ("anonymous property") !propScroll!([[x]], mouseWheelDown) = [[ x::[[y]] ]] propScroll may result in a reactor or in an applicable operator: !propScroll!([[x]], mouseWheelDown) = [ x::[f] >>] this mimics object-oriented programming's method application: x.f(y) <=> [[ x:: [f] >>]] * [[y]] x.f() <=> !apply!( (x::(f) ) ) ***!allocate!: copy object to an unused area of iC typical usecase: !allocate!(pathmade function) to apply a pathmade function [f]: 1. !allocate!([f]) = [f(allocated)] 2. [[obj]] * [f(allocated)] 3. destroy [f(allocated)] **eduDemo: dots::[merge]/[count]: workflow: [[13]] -->-- [dotsify] -->---->--- [merge] -->-- [count] -->-- [[22]] [[9]] -->-- [dotsify] -->--/ then same thing with 5.3 + 4.8 and group small dots **eduDemo: [atomize] (create dots with symbols) [[5x + 3y]] * [atomize] = [[ y x x ]] [[ x x ]] [[ x y y ]] workflow: [[5x + 3y]] -->-- [atomize] -->---->--- [merge] -->-- [group] -->-- [[7x + 9y]] [[2x + 6y]] -->-- [atomize] -->--/ **eduDemo: dots: comme les adultes: workflow: [[:.:.:.:.:]] -->-- [count] -->---->--- [+] -->-- [[25]] [[..:..::.:]] -->-- [count] -->--/ (*évaluer 3x+2 revient à colorier les x (normalement rouges) en noir (la couleur des nombres normaux) **[structure]challenge: growing curse/layout challenge: when pressing [play] button, growing curse'd objects start growing (i.e. a circle around them grows and it may touch an operator) the challenge is to find a layout to create target expr [clone] operator creates a clone and is not consuming. As soon as object is returned by op, it starts growing a [== ] operator may be used for challenge completion check (*family board: whiteboard for the family, in the kitchen, for communication between houses draw something in your friends' area, and it will appear on their family board (la version physique d'un mur facobeok en iC neighbor board: to add another communication means between neighbors (not replacing verbal communication) **(**)transport::transmade op: program using transportation: workflow: 1. enter transmade writing mode 2. click and stay clicked: a dummy is now under cursor: it represents input arg 2. loop: !transport! to desired operator !apply! to apply operator to dummy 4. leave transmade writing mode shortcut: enter/leave transmade writing mode: E.² then keep ² pressed ordinal numbers allow representing the sequence when hovering transmade op using transportation allows reaching operators that may be arbitrarily far, as if they were just nearby (*singapore4all: anywhere numbers are used, display at least 2 representations of them *edu: 24-hour progressBar-stack clock: [■■■■■■] _ _ _ _ [■■■■■■] ■ ■ ■ □ [■■■■□□] empiler différemment pour voir l'avancement de la journée ■ ■ ■ ... □ [□□□□□□] ■ ■ □ □ ... - - - - [□□□□□□] *translation: initiation: use holed paper to translate drawing workflow: 0. make holes in a piece of paper 1. put holed paper over source drawing 2. draw on non-holed parts of holed paper to recreate drawing 3. move holed paper somewhere else 4. draw inside holed parts of holed paper to recreate drawing 5. remove holed paper 6. complete translated drawing remark: all this must be performed while keeping original orientation ***history ops/!history_scroll!: undo/redo for iC !history_scroll!([[obj]]) <*=*> !scroll!( [[obj]](held) [history ⇳] ) ==> undo/redo for [[obj]] wrt its transformation history !history_scroll!() <*=*> !scroll!( [history ⇳] ) ==> undo/redo for all iC !anti_history_scroll!([[obj]]) ==> undo/redo for all iC except [[obj]] fun: Braid X iC: faire des challenges à la Braid (basés sur le voyage dans le temps vécu différemment par certains objets) [history(-n)] operator: example: [[x]] * [+ 2] = [[x+2]] [[x+2]] * [/ 3] = [[(x+2)/3]] [[(x+2)/3]] * [history(-2)] = [[x]] ***(*)!history_transport!([[obj]])/traceable object ==> transport wrt object's transformation history (all operators that have transformed the object) [[obj]] * [become: traceable] = [[obj (traceable)]] only a traceable object can be !history_transport!'d edu: pour détricoter des expression numériques ou littérales *eduDemo: create x↦x² function graph using segment bloom 1. pick an integer abscissa, say [[3]] 2. [[3]] * [blockify] = □□□ 3. create square by cloning □□□ 3 times □□□ □□□ □□□ 4. append all segment blocks into a block segment □□□□□□□□□ 5. □□□□□□□□□(held) , !transport_rotate!([[3]]) ^ _______> _______> | ==> | ==> | |___[[3]]__> [[3]] [[3]]□□□□□□□□□ | | v v **platform::homeFloor: object released on top of it has its scale brought back to its home floor (comme une plaque de puzzle) *zPen: like a computer mouse but it's a pen with a scroll wheel to be able to brushWidthScroll and freeDrawingZScroll, and colorScroll, ... scrollWheel is scroll by hand index finger *gm:challenge: theorem application edu: a mathematical proof is the same thing with 1+ steps + the use of "(p ⊢ q) ⊢ (p => q)" *gm:challenge: reductio ad absurdum **emotional typography: display of word "sad" looks sad, display of "asleep" looks sleepy ***transport::menu: [menu] [menu out] !transport!([[obj]](held) [menu], wheelup) = [[obj]](held), now inside [menu]'s object_place in which there are objects, operators (along with [menu out]) so we can create: [numbers menu], [operators menu], [symbols menu], [fractions menu], [shapes menu], [pathmades menu], ... [structure]gm:challenge: menu-based challenge: same as standard challenge but operators must be accessed via menus edu: pour que l'élève commence à construire des catégories d'objets *transport::bit representation: transport to a visual representation of the bits which encode the object **eduDemo: [==] operator: [[5]] * [ [[2+3]] over [==] ] = [[True]] **[structure]gm:challenge: symmetrical pick: when picking an object in top area, it also picks an object in bottom area (not necessarily the same) the move in the top area is mirrored in bottom area target: shuffled expression (numexp or litexp) edu: trouver l'expression fabriquable équivalente à l'expression cible dev: find a structure **transport::from icText to icText, or from word in icText to word in icText... keep same apparent fontSize... **[structure]challenge: povlock'd: clicking on object locks pov, always centered on it mouse does nothing object must be moved using keyboard keys *relative numbers:: [[ [[5]] [[→]] [[→]] ]] * [resolve] = [[7]] **array/composite::fill handle (poignée de recopie): smart handle: generates a logical followup vscroll on an element of the generated part makes generated part auto update to keep the followup logical (*dotScroll after numBaseScroll ***(*)pathmade X transport: function: workflow: 1. spawn a function stub [f] 2. !object_place!([f]): create function definition automatically created in object_place: [[this]] [[param]] (this is a scalar slot which can be transformed into an array or a dict, or an object) [return] use adhere on pathmade to create branching edu: demander aux élèves de construire une fonction [eval] qui retourne [[5]] (ou [[2+3]]) quand on lui donne {[[2]], [[3]], [["plus"]]} overloading: one can create overloads by dropping adequate input types in its input stub, and it creates another function definition object_space "follow the yellow road" (something like a closure): function definition may extend outside its scope, [return] statement may be put anywhere there is a yellow path which defines the function return func, given input func: 1. define inner func inside func object_space (this inner func will be the returned object) 2. pick input func, convey it inside inner func body, and use it there 3. pathmade inner func to [return] ***pathmade X transport: method: workflow: 0. hold object 1. enter method recording 2. use operators on object 3. leave method recording screenPov moves to object's object_place a new method "method_" has been created (user may rename it) obj.methods: use already-defined methods to define new method with obj.square(length_in), one can create square_3(length_in) (nested squares of different lengths) previous methods appear in the object_space where new method is defined 24 janvier 2024: **pathmade::learned functions(==abduced functions): create function using (input,output) tuples workflow: 1. spawn a function stub 2. enter learning mode 3. loop 2.a pick an object 2.b make it touch op: it is the input object 2.c use operators and commands to mutate it 2.d release the object: it is the output object 4. leave learning mode 5. function can be refined by entering learning mode again 2 flavors: strict relation function: [⊢ ←→ →] function only supports inputs that it has learned inferred function: system guesses what is the function you want 2 flavors: symbolic regression: [⊢ ←◱→ →] a formula for the function is produced, and it is used to compute outputs from out-of-bounds inputs black-box inferred: [⊢ ←🤖→ →] no formula is given, function is completely opaque, apart from the training tuples edu: pour commencer à parler d'IA avec les élèves ***(*)[discovery]type stub/!spawn_type!: spawn an object which is not an instance but the type itself examples: [[Nat]]: natural number [[Frac]]: fraction [[Sentence]]: a sentence (Starting with a capital letter and ending with a point.) [[Type]]: type of [[Nat]], as well as type of [[Type]] ... vScroll on a type object will collectionScroll on all the available types edu: une couleur pour chaque grand type **pathmade::[iter]: the first argument will tell how many times the path must be trodden workflow: 0. spawn a [[Nat]] object 1. hold [[Nat]] object 2. draw a pathmade with [[Nat]] object => an [iter] pathmade is created example: [iter]-----[+ 2]--------> all operators crossed by input obj will ignore first argument first argument may be consumed by [iter] at the end [[5 100]] * [iter]-----[+ 2]------[iter::[consume:yes]]--> = [[110]] [[5 100]] * [iter]-----[+ 2]------[iter::[consume:no]]--> = [[5 110]] fun: [[Real]]-based iterator: last iteration stops at "path progress":40% if first argument is [[3.4]] 26 janvier 2024: **(*)object_space::memory-limit: object_space has a size proportionnal to its contents all object_spaces are gathered in a bounded area: icObj = "memory_space" there comes a point where there's not enough room in it for a new object_space, nor is it possible to add content to an existing object_space => create some challenges or eduDemos with memory_space (==limited memory) *icRect can sometimes be considered as icEmptyObject ***(*)pathmade::Type-specific pathmade: tDraw (vDraw with type object) [[Nat]]-pathmade: [iter] [[Bool]]-pathmade: while loop [[String]]-pathmade: create baseline path: to draw text on a curve [[Pen]]-pathmade: create a function which outputs drawings [[Pen]] * [+ 2] ==> brushSize + 2 [[Pen]] * [x 2] ==> comb x 2 there is a commutative comb multiply and a non-commutative comb multiply [[Pathmade pen]]-pathmade: create a function which outputs functions [[Marionette]]-pathmade: to animate a marionette [[iC]]-pathmade: [[User]]-pathmade: **logic::symbols for deduction and abduction: [■...■] [deduce]: [_____] [ □ ] [□ ■...■] [abduce]: [_________] [ ■ ] example: {[[⊢ A]], [[⊢ A=>B]]} * [deduce] = [[⊢ B]] (conditional elimination) [[⊢ A]] is an affirmation, it may be absurd, like [[⊢ 2>3]] (déduction et abduction, c'est comme quand on résout une équation, en moins symétrique. **[affirm]::propositional logic notation: if input proposition P is True, then we output the affirmation "P is indeed true" correct affirmation is colored green [[P]] * [affirm] = [[⊢ P color:green]] [[5>3]] * [affirm] = [[⊢ 5>3 color:green]] [[3>5]] *\ [affirm] edu: une voie vers les mathématiques plus avancées consiste à envelopper avec des ⊢ des propositions où il n'y en avait pas avant, et partir de là **[claim](==[force ⊢], ==[suppose]): even if P is false, we output the affirmation "P is claimed to be true" claimed affirmation is colored grey [[2>3]] * [claim] = [[⊢ 2>3 color:grey]] [[3>2]] * [claim] = [[⊢ 3>2 color:grey]] **[verif]: mutate affirmation to color:green if it is correct, to color:red if it is incorrect [[⊢ 3>2 (claimed) color:grey]] * [verif] = [[⊢ 3>2 (correct (==True)) color:green]] [[⊢ 2>3 (claimed) color:grey]] * [verif] = [[⊢ 2>3 (incorrect (==False)) color:red]] [[⊢ 3>2 (correct (==True)) color:green]] * [verif] = [[⊢ 3>2 (correct (==True)) color:green]] **[deed]: get inner proposition from affirmation symbol: [◈] [[⊢ 3>2 (correct)]] * [◈] = [[3>2]] [[⊢ 2>3 (claimed)]] * [◈] = [[2>3]] **proof making/proof_nectar: workflow: 0. gather useful objects 1. lift to affirmations (⊢) using [affirm] or [claim] 2. loop: use [deduce] operator: [deduce](green green) = green [deduce](green grey) = grey 3. last step is [verif] [verif]'s output may be: green: good old proof red: reductio ad absurdum edu: raisonnement par l'absurde en allant chercher un rouge à la fin de la démonstration, qui remonte jusqu'au début proof_nectar (conditional introduction): _from a proof environment_, pick premisses and conclusion, and create theorem from it {A, B} * [create_theorem] = [A => B] edu: créer des opérateurs théorèmes à partir d'une preuve edu: comme le disait Per Martin-Löf, une preuve c'est à la fois l'ouvrage et l'oeuvre, et c'est important de faire oeuvre avec les élèves, à la fois en transmission et en activité élève **edu: théorèmes de "ab>=100" et applications Th1: Si a >= 10 et b >= 10 alors ab >= 100 Th1: Si a >= 5 et b >= 20 alors ab >= 100 exemple: 1. create ingredients 1.a [[6]] * [>= 5] = [[6 >= 5]] [[6 >= 5]] * [verif] = [[⊢ 6 >= 5]] (or [[6 >= 5 __true]]) 1.b [[22]] * [>= 20] = [[22 >= 20]] [[22 >= 20]] * [verif] = [[⊢ 22 >= 20]] (or [[22 >= 20 __true]]) 2. deduce {[[⊢ 6 >= 5]], [[⊢ 22 >= 20]]} * [{⊢ [[a >= 5]], ⊢ [[b >= 20]]} ⊢ [[ ab >= 100]] ] = [[⊢ (6 x 22) >= 100]] **[assert]: returns an error when condition is not verified [[5]] * [ {[< 3], [[Error: input >= 3]]} over [assert] ] = [[Error: input >= 3]] (*programmation naïve: utiliser les phases pour coder le déroulement d'un jeu de cartes, ou de plateau 27 janvier 2024: *output-store-based generator: loop while value is not contained in output store **type::operators: random element: [?∋] (== [?]) [[Nat]] * [?∋] = [[327]] [[Nat]] * [?∋] = [[12]] [[String]] * [?∋] = [["pfjoje"]] random subType: [?⊃] [[Nat]] * [?⊃] = [[ interval(10,14) ]] [[Nat]] * [?⊃] = [[ interval(0,5) ∪ interval(41,66) ]] [[Nat]] * [?⊃] = [[ 2Nat ]] [[String]] * [?⊃] = [[String of length 5]] **(**)textual function: write javascript function in iC workflow: 1. spawn func stub 2. transport to object_space::code => () { return } 3. enrich function code with your own => object_space::programmadraw is autoupdated with your function object_space::code and object_space::programmadraw represent the same function edu: vers la programmation textuelle *icObj.isHemiOriented: object can follow oriented path but never gets upside down. Rather, it flips horizontally and vertically. imagine a car image following an oriented track: when left-to-right oriented car should get upside down (orientation:181°), it becomes right-to-left oriented with orientation:1° (*on peut résoudre le problème des 3 maisons avec un portail ^^ ***pathmade:virtual path/real path: a virtual path will convey a virtual version of the conveyed object (a shade for example) a real path will translate the input object rightMouseDown/rightMouseUp: enterRealPathMode/leaveRealPathMode virtual path and real path can be discontinuous (discontinuous real path will result in object transportation) => in the same pathmade op definition, we can specify operators which will transform the object but its position (using virtual paths) we can specify transformations of its position/orientation/homeScale (using real paths) specific case: freeDrawing programs (written with [[Pen]] type): example: freeDrawing program: virtual path to [color: red] virtual path to [pen_down] virtual path to drawing starting point real path: draw something virtual path to [pen_up] ... [length:50] operator may constrain next real path to have length 50 child mode: automatically wrap real_path to !pen_down!{real_path}!pen_up! ***spawn::adhere_on_spawn/gluey support: spawned_object.isAdhereOnSpawn: if a valid support exists when object spawns, it automatically adheres to this support support.isGluey: when an object spawns over it, it automatically adheres to this support this would allow creating challenge generators ***drawing-sheet: drawing-sheet generator: operator outputs a support with drawings on it drawing-sheet operator definition consists in placing drawing operators on a blank support (==drawing-sheet) drawing-sheet mutator: operator mutates input drawing-sheet by adding drawings on it drawing-sheet operator definition consists in placing drawing operators on a blank support (==drawing-sheet) ***pathmade::function:[rect_rel]/[[rect_rel]]/rect_rel paths: all paths drawn in [[rect_rel]] are relative paths wrt width and height typical usecase: drawing-sheet workflow: 1. transform [[input]] to [[rect_rel input]] using [rect_rel] ([[input]] may be [[drawing-sheet]]) (1.b resize [[rect_rel input]] 2. draw paths inside [[rect_rel input]] 3. draw path to convey [[rect_rel input]] to [return] edu: programmer des montages d'images (==montages automatisés) **(*)pathmade::path_syncing: allow multiple paths to operate at the same time typical usecase: drawing draw a stroke go back in time draw a stroke when using the operator, both strokes will be pen'd along at the same time ***applicable operator::time-based application: ***pathmade::function::[play]: motivation: build function from a pure-path pathmade and control object move using [play] button edu: à partir d'un chemin pur "balayage télé cathodique", construire un dessin en posant/levant le crayon à des endroits(==moments) bien précis **gm:challenge:pathmade expression: "initial==input", target is an expression (numexp or litexp) layout: initial: [[x]] [[y]] [[10]] [[-2]] operators: [+ 2], [+], [x 3], [x], ... target: [ [==] over [[3x+2]] ] workflow: 1.draw paths from input to operators binary operators require 2 input paths draw paths from operator results to operators draw path from operator result to target 2. press [execute] button *(***)[weld]:meli-melo de fonctions motivation: neural nets transform many inputs in many outputs when we think about [[3]], we also think about [[Nat]], [[Real]], [[dot dot dot]], [+ 3], ... let's do the same with functions: let's create a big cloudy function by welding functions together (edu: Si on arrive à apprendre avec peu d'exemples, c'est que tout est relié pour nous. 3 c'est pas seulement trois pour nous, c'est trois billes, c'est fois 3, c'est une photo sur laquelle on est 3, ... Plus on sait de choses, et plus on fait de connexions entre elles et plus on apprend facilement. Si on a du mal à apprendre quelque chose, c'est peut-être qu'on a pas tout le bagage implicite qu'ont la plupart de ceux qui maîtrisent cette chose. Par exemple, un minimum de latin et de grec pour orthographier correctement, et pour deviner le sens de mots nouveaux. symbol: [‿] [⁀] OR [⥼⥽] [⥼⥽] is a 2+ ary operator ⥼⥽(f,g,h) is the multifunction that results in welding f, g and h {{{X}}} means "cloudy" X [[in__f]] * [f] = [[out__f]] [[in__g]] * [g] = [[out__g]] {{{[[in__f]], [[in__g]]}}} * [ ⥼⥽(f,g) ] = {{{[[out__f]], [[out__g]]}}} flavors: hasty weld(==once weld): when welded function applies, as soon as input is found for inner function, this function applies once exhaustive weld: when welded function applies, any input partition which is valid for an inner function is transformed and added to output cloud significant weld: when welded function applies, any significant input for an inner function is transformed and added to output cloud dev: what is significant ?... (...le fameux module [critique]) **pathmade::apply::ammo apply will effectively happen if object has enough ammo flavors: universal ammo: ammo is valid for any apply op-specific ammo: ammo is valid for apply on a specific operator op-family-specific ammo: ammo is valid for apply operator belonging to a specific family **icObj's limb: motivation: in a board game, touch board game slot [move_character] with the result of ([[myCharacter]]::diceRoll) will result in moving [[myCharacter]] the result of ([[myCharacter]]::diceRoll) is like a proxy for [[myCharacter]] **clone_hold: don't grab object, grab clone of object typical usecase: clone_hold pathmade functions 29 janvier 2024: **icObj.type = "oopObj" attributes may be: obj position (x, y) obj homeScale (h) history store: when oopObj is mutated, a clone of oopObj__old is added to history store then oopObj can be historyScroll'd inner reactors: example: oopObj has a [[pushX >>]] inner reactor then [[oopObj]] * [[obj__other]] *<=>* [[oopObj>>]] * [[obj__other]] ==> [[obj__other]] is pushed horizontally pushX's definition is made by supposing [[other]] has [[x]] attribute (*le nom (d'une fonction) fonctionne comme une position dans un espace plus abstrait. Quelque chose qui permet de retrouver sa définition. ***easy: operator in array: add operator(s) in array 2 flavors: array is still a standard object, inner op is like an object: !protect!([[2 3 5]]) !enroll!([[2 3 5]], [popAtIndex(1)]) = [[2 3 5 [popAtIndex(1)] ]] !unprotect!([[2 3 5 [popAtIndex(1)] ]]) [[2 3 5 [popAtIndex(1)] ]] * [*] = [[2 5]], [[3]] edu: créer des piles d'exécution array becomes a reactor: !enroll!([[2 3 5]], [steal]) = [[2 3 5 [steal] >>]] [[2 3 5 [steal] >>]] * [[8 9 10]] = [[2 3 5 8]], [[9 10]] edu: aller vers les oopObj **gm:challenge: create expression using operation stack: [[[x] 2 [+] 3 [-] 5 6]] * [execute_stack] = [((6-5)+3)x2] edu: les arbres de calcul, encore et toujours ***pathmade::adhesive: draw pathmade on support => create modules (functions gathered at the same place) edu: pour coder de manière organisée, et pour partager son code plus facilement ***pathmade::[freeDrawing → pathmade]: create pathmade from freeDrawing [[freeDrawing]] * [freeDrawing → pathmade] = [pathmade] edu: pour aller doucement des dessins vers les programmes **icObj.type = "course": a start, a path, an end course_adhere: when drawing a course B over a support course A, with B.start over A.end **icObj.type = "courseTree": the 'composite' course **icObj.type = "courseGraph": the 'recursive composite' course edu: programmation par le dessin, avec des graphes **course::[freeDrawing → course]: create course object from freeDrawing freeDrawing "stroke" → course freeDrawing tree → courseTree freeDrawing graph → courseGraph **!courseScroll!: move pov to follow course (each step is an infinitesimal transportation) (supply chain masters programmadraw on the earth surface **icObj.type = "zPath": sequence of paths linked by zSegments 30 janvier 2024: **!hoverSet!: all objects in target similar to overlaying held object have their properties set to mimic held object typical usecase: from numexp to litexp edu: on passe d'une expression numérique à une expression littérale en faisant varier une valeur "un peu partout" exemple: (4 + 2 x 3) / (10 - 4) x 4 -> (5 + 2 x 3) / (10 - 5) x 5 **[structure]challenge:courseGraph: given the input(s), what will be the output of this machine ? _at which output slot_ ? edu: un grand graphe avec des boucles et des conditions: avec une seule valeur en entrée, il faut suivre son parcours de transformations pour savoir à quelle endroit elle va quitter le graphe edu: on peut aussi essayer de remonter le graphe à l'envers, comme si on essayait de résoudre une équation *edu: théorie des catégories avec des objets et des flèches **cursor is an object/flavored cursor/[flavor]: cursor is touchable, as any canvas object typical usecase: reduce number of shortcuts for pathmade creation example: draw_pathmade(cursor:red) = draw real path cursor:red * [flavor: blue] = cursor:blue draw_pathmade(cursor:blue) = draw virtual path **pathmade::function::ref arrow: draw an oi-arrow (==from op1.output to op2.input) to use output without having to realize it on the canvas **pathmade::function::anaphora ("anapharrow"): an alternative to [clone] same as ref arrow but drawn from operator [I] **variable-free self-assignation: (via anaphora) instead of using [a←a+2] (in which 'a' is a bound variable), we can use [ [pure: + 2]--\ ] [ [← <-]-----/ ] (in which there is no variable) with [pure: + 2] meaning: return (input + 2), but don't auto-assign edu: aller doucement vers l'instruction textuelle a←a+2 (où a est une variable _libre_) **[delay: 1]: wait 1 second, then continue trodding []----[delay: 1]----> **[await [[↧]] ]: wait for event, then continue trodding []----[await [[↧]] ]----> when [↥] will apply, conveyed object will resume trodding [await [[↧ Key()]] ]: message is "keyboard key is pressed" *FocusedArray: array + element_cursor **zSegmentPortal: zSegment + portal for this specific portal, the portal travel is continuous: transformation from front to back is a "zSegment transform" 01 février 2024: **easy: inverse operator [(x↦y)↦(y↦{x})] [x↦x²] * [(x↦y)↦(y↦{x})] = [x²↦{x}] [[4]] * [x²↦{x}] = {[[2]], [[-2]]} [[-1]] *\ [x²↦{x}] **freeDrawing::through portal: clone all drawing that is inside screenPov just before changing pov so that redoing freeDrawing path by "cruising" fakes a continuity or more simply: clone everything inside rect_in in rect_out *fun: portal labyrinth: labyrinth X portal freeDrawing through portal helps creating paths there could be more than 2 host labyrinths this game could be played on paper sheets, with a pen *the fractal nature of moving: you leave place A you're on a narrow road you end up on a medium road you end up on a big road you pick a medium road you pick a narrow road you're at place B (**easy: perspectiveField/perspectiveCourses: auto find zPath from zPointA to zPointB **game: zImagine: use Imagine game cards + zScroll 02 février 2024: **curveDrawing: like freeDrawing but path consist of a concatenation of cardinal splines **curve::divide: split or mark curve into arcs of equal length edu: abscisse curviligne **boundSpawn: spawned object is bound to hatch object typical usecase: create bound point on curve or segment boundSpawn may often become a composite child of hatch object bind actuation can be of any type: movement is constrained (point on curve or segment) value is constrained ... **alteration::weak alteration: typical usecase: move point on curve or segment, but curve or segment is not mutated, it keeps its shape shortcut: intlBackslash.alt **(*)[discovery]relativeDrawing: after having drawn snake around curve, bending curve results in mutating snake, to keep snake around curve **relativeDrawing::drawCarriedFunc (user draws amplitude wrt normal at "current carrier point") and then drawCarriedFunc on just drawn carried func, ... 03 février 2024: *pathmade::function:adhoc function: this function does not have an object_place, it is a composite of conveyors and operators typical usecase: create a binary conveyor workflow: 1. spawn [+] operator 2. draw an input conveyor from canvas to [+] 3. draw an input conveyor from canvas to [+] (4. draw an output conveyor from [+] to canvas) []------\ >----[+]-----> []------/ **(*)[numberTyping] (as operator): [numberTyping] operator has the same backing code as !numberTyping! command shortcut: '!numberTyping!()' (press numberTyping shortcutKey, and release it without having typed anything) examples: [["+ 2"]] * [numberTyping] = [+ 2] (unary) [["+"]] * [numberTyping] = [+] (2+ary) [["..+.."]] * [numberTyping] = [..+..] (binary) [["..+...+.."]] * [numberTyping] = [+] (2+ary) [["nt"]] * [numberTyping] = [numberTyping] [["op"]] * [numberTyping] = [op_stub] command strings can be used as input: [["!clear!"]] * [numberTyping] = !clear! command is invoked [["!numberTyping('+ 2')!"]] * [numberTyping] = [+ 2] (because invoking !numberTyping('+ 2')! spawns [+ 2]) 04 février 2024: *les fonctions qui prennent leur temps sont l'équivalent des promesses *aui X Gargantext, ce serait sympa *aui::DjVu support **fun: freeDrawing: autoZForward pen, autoZBackward pen == pen::curse__autoZForward, pen::curse__autoZBackward drawing with such a cursed pen automatically results in zFreedrawing while drawing, not moving results in a pause of zFreedrawing => the longer the drawing, the deeper it is. fun: faire un pictionary avec cette malédiction **!plating!/[plating]: fill object with a custom plating image typical usecase: print an image on a spaghetti surface every surface lying under plating image is plating-filled !plating([[image]] over [[spaghetti freeDrawing]]) = [[spaghetti freeDrawing]] (plated with [[image]]) it's close to patternAdhere (**token expr/parenthesis operator: [[ [][3][][+][][2][][x][][5][] ]] workflow: [[3+2x5]] * [tokenize] = [[ [][3][][+][][2][][x][][5][] ]] [[ [][3][][+][][2][][x][][5][] ]] * [(] (touching first empty slot) = [[ [(][3][][+][][2][x][5][] ]] [[ [(][3][][+][][2][][x][][5][] ]] * [)] (touching empty slot between 2 and x) = [[ [(][3][][+][][2][)][x][][5][] ]] [[ [(][3][][+][][2][)][x][][5][] ]] * [parse token expr] = [[(3+2)x5]] easy: tokenization is hidden from user [[3+2x5]] * [(] (touching left side) = [[(3+2x5]] (color:red because expression is not well formed) [[(3+2x5]] * [)] (between 2 and x) = [[(3+2)x5]] edu: priorités opératoires (**(*)gm:challenge:insert parentheses initial: expr ops: [(] [)] target: number or expr **object_place: oop obj: different areas: attributes methods events incoming this allows outgoing aui-specific props .isTouchable ... **cosmetic::cosmetic surplus: enrich mathematical notation with a meaningful cosmetic surplus example: if 2(x+3)+5 is the age of the captain, one could make it visible, by surrounding 2(x+3)+5 with a cosmetic freeDrawing with label "C" C ((2(x+3)+5))+38 ---------------- 10 + y this cosmetic surplus would survive as long as contained expr is not altered 05 février 2024: ****[discovery]hover-tunable(=="wysiwyg") applicable operator symbol: (⯐ ) a preview of result is shown while obj is touched result is hover-tuned: moving the object over the operator changes the result held object becomes what was previewed when user invokes !apply! typical usecase: cursor-based operations examples: insert parenthesis in an expr (⯐ insert ( ) !apply!([[3x+2]](held) over (⯐ insert ( )(previewing [[3(x+2]]) ) = [[3(x+2]](held) insert an element in an array, at a chosen position [⯐ insert ] !apply!([[1 2 3 4 5]](held) over (⯐ insert 0)(previewing [[1 2 0 3 4 5]]) ) = [[1 2 0 3 4 5]](held) insert perpendicular bisector on a side of a triangle: (⯐ insert perp. bis.) !apply!([[triangle ABC]] over (⯐ insert perp. bis.)(targeting Segment(A,B)) = [[triangle ABC with perp. bis. on Segment(A,B)]] apply operator on expression leaf: (⯐ + 2) 2 flavors: insertion (==dirty application) (don't add parentheses, it may break original expression tree): !apply!([[3+5x6]] over (⯐ + 2 (dirty))(previewing [[3+5+2x6]])) = [[3+5+2x6]] (applied on 5, dirtily) proper application (add parentheses if needed, structure is kept safe): !apply!([[3+5x6]] over (⯐ + 2 (proper))(previewing [[3+(5+2)x6]])) = [[3+(5+2)x6]] (applied on 5, properly) edu: evaluation d'expression: l'élève doit remplacer chaque occurence de x par la valeur qu'on lui a assigné edu: géometrie: programmes de construction ****hover-tunable selection applicable operator: symbol: (⯐▧ ) workflow: while touched by operator, rightMouseDown to enter selection mode while touched by operator, rightMouseUp to leave selection mode and apply operator typical usecase: selection-based operations examples: insert parentheses around selection in an expr (⯐▧ insert () ) !apply!([[3x+2]] over (⯐▧ insert () )(previewing [[3 (_x+2_) ]])) = [[3(x+2)]] erase selection in an expr (⯐▧ erase ) apply operator on sub-expression (⯐▧ + 2) ... gm:challenge: insert parentheses layout: initial: [[]] ops: (⯐▧ () ) and that's all target: value or expr ***hover-tunable scroll-tunable selection applicable operator: symbol: (⯐▧ ⇳) workflow: same as hover-tunable selection applicable operator but after selection has been done, _while object is touched_, operation is scroll-tunable example: change color of selection in an expr or an array (⯐▧ color ⇳) **!show_me_your_setters!: use it when you want to mutate object but you don't want to change its position typical usecase: change the radius of a circle workflow: 1. hold the value you want for radius [[4]](held) 2. move [[4]] so that it is now over circle 3. invoke !show_me_your_setters! => (set radius), (set origin), (set color), ... now appear 4. !apply!([[4]] over (set radius)) => circle radius is now 4 5. move [[4]] away from circle: all temporary applicable ops disappear **(*)pathmade::function: moving function: typical usecase: egg-laying function: each round, loop function spawns object and then shifts a bit flavors: egg-laying function plot-creating moving function: function moves to build segments workflow: loop: moving function spawns iCPoint__start (if needed) moving function enters drawing mode moving function moves to point__end => a segment is drawn moving function leaves drawing mode moving function spawns iCPoint__end **logic:PL operators: operator will only apply if args are matching operator params (PL operators are 'psychorigid') introduction: [i v] [i ^] ... elimination: [e v] [e ^] ... ... **geometry::open segment: affichage en changeant l'opacité de l'extrémité qui n'appartient pas au segment voire: afficher un morceau mangé au segment, depuis l'extrémité 'ouverte' ce morceau mangé peut être réduit à une taille arbitrairement petite en zoomant **challenge:gm:numeration: using [transport] pods layout: main challenge area has initial, operators, target, and transport pods to other areas other areas only have operators and transport pods 06 février 2024: ***sleeping-args operator: first arg being touched by this operator is put to sleep, then object must be released on operator because, when untouched, obj goes back to its normal state then, when second arg is touched, operator wakes up asleep child arg, builds an arg list with the two objects and checks if it can apply if operator cannot apply (for example, because nb_effective_args is below threshold), carried objects are put back to sleep etc. object.isAsleep asleep object on operator is awaken by op just before op attempts applying remark: this behavior is satisfying in some way because it does not alter operator, whereas currying would alter operator this also allows writing "pure nb_args-threshold" func: func acts as a unary operator on each input arg, only their being n at the start is important (it is not coordinating args, but it is rather coordinating existences of arg) 2 flavors: all-consuming operator: when a valid input arg set is found, operator consumes all of them and returns new object symbol: [zZz() ] example: [zZz(3) +]: [[2]] * [zZz(3) +] = [ [[2]](sleeping) over [zZz(3) +] ] [[5]] * [ [[2]](sleeping) over [zZz(3) +] ] = [ {[[2]](sleeping),[[5]](sleeping)} over [zZz(3) +] ] [[1]] * [ {[[2]](sleeping),[[5]](sleeping)} over [zZz(3) +] ] = [[8]] partially-consuming operator: operator does not consume all input args args that are not consumed are called key args args that are consumed are (abusively) called input args symbol: [zZz() key() ] when required keys set is valid, operator can be considered as an all-consuming operator wrt its other input args example: [zZz(1) key([["abc"]]) + 10]: [["abc"]] * [zZz(1) key([["abc"]]) + 10] = [ [["abc"]](key) over [zZz(1) key([["abc"]]) + 10] ] [[5]] * [ [["abc"]](key) over [zZz(1) key([["abc"]]) + 10] ] <*=*> [[5]] * [+ 10] = [[15]] key may be used in operator definition [zZz(1) key([["abc"]]) append keys.0] remark: there can be sleeping-args applicable operators 07 février 2024: **sleeping-args operator::non-commutative operator args are by default gathered first:from top to bottom and then:from left to right typical usecase: [zZz(2) -] [zZz(2) /] this could be facaded with an arrow from TL to BR **sleeping-args operator:: property equalizer: [[obj2]](.color:blue) * [ {[["color]], [[obj1]](.color:red)}(key) over [zZz equalizer] ] = [[obj2]](.color:red) **[structure]gm:challenge:math: history (=="still remains") gm has "history curse": gm displays array of its consecutive forms a new form is appended to the array after a transformation target is array of values: operators must be used to reproduce this sequence student has to think a bit because gm shows unsimplified expressions whereas target shows simplified expressions edu: numexp: montrer l'équivalence entre des expressions numériques et des nombres "simples" **gm:challenge:math: forgetful history (=="st?ll rema?ns") same as gm:challenge:math: history but some internal elements of target are "?" **[structure]gm:challenge:math: cumsum: gm:challenge:math: history with only [+ ] operators edu: pour commencer à voir un peu plus loin que les tables d'addition et commencer à généraliser (par exemple entre 0 et 100) **sleeping-args reactor: reactor only applies when enough args are touched simultaneously 08 février 2024: ***hover-tunable:: hover-tunable command: !⯐ ! typical usecase: clone_Pick digit in number !⯐ clonePick_digit!([[48]])(previewing [[8]]) = [[8]](held), [[48]](unchanged) workflow: workflow1: nothing is held 1. keep hover-tunable command !⯐!'s shortcut pressed: enter !⯐! mode 2. hover-tune *3. _leftMouseDown_ to apply command and start holding result 4. release shortcut key to leave !⯐! mode workflow2: something is already held 1. keep hover-tunable command !⯐!'s shortcut pressed: enter !⯐! mode 2. hover-tune *3. _rightMouseDown_ to apply command and start holding result 4. release shortcut key to leave !⯐! mode **(*)sleeping-args operator::with sleeping platform typical usecase: user doesn't know how many arguments they will use symbol: [zZz ], or more explicitely [zZz ]__[[]] sleeping platform may completely surround operator non-commutative operator args are by default gathered first:from top to bottom and then:from left to right this could be facaded with an arrow from TL to BR (on sleeping platform) workflow: 1. loop: [zZz ]__[[>>put as many args as you want here<<]] 2. trigger operator: by having last arg touched [[argN]] * [zZz ]__[[ [[arg0]] [[arg1]] ... [[argNMinus1]] ]] <*=*> !operation!({arg0, arg1, ..., [[argNMinus1]], [[argN]]}) OR by having [[null]] touched [[null]] * [zZz ]__[[ [[arg0]] [[arg1]] ... [[argNMinus1]] [[argN]] ]] <*=*> !operation!({arg0, arg1, ..., [[argNMinus1]], [[argN]]}) remark: if sleeping platform is empty, default argument(s) may be used edu: pour passer de (0-5) à -5 (d'ailleurs c'est marrant qu'on n'ait pas fait la même chose pour les fractions ((1/5) serait alors /5) ) ***sleeping-args operator::object-like sleeping-args applicable operator if there is enough input args to apply operator, operator is promoted to "object-like" this means that operator_with_args can be used as an argument for another operator => object-like sleeping-args applicable operators may be used as sleeping args edu: une autre façon d'écrire des expressions **sleeping-args operator::domino operator: typical usecase: combine gains and losses, compute fractions symbol: [ [] [] [] ] examples: [(+) - (+)] [(x) / (x)] layout: sleeping platform is completely surrounding operator example: [[ [[4]] [[5]] ]] [[null]] * [[-------[-]----------]] <*=*> (5+4)-(1+10) = [[-2]] [[ [[1]] [[10]] ]] object-like sleeping-args applicable operators (including object-like domino operators) may be used as sleeping args edu: expliquer 1-(-4) = 1+4 edu: fractions, fractions de fractions, ... **sleeping-args operator::position-aware: typical usecase: sum numbers, some of which have implicit zeros, as they are shifted 3 4 + 5 4 _______ 5 7 4 example: [[ [[34]] ]] !apply!([[ [[54]] ]]) = [[574]] [[ (zZz +) ]] edu: on peut codessiner cet opérateur sophistiqué avec les élèves en mettant plein d'opérateurs [+ (carry)] à la chaîne, avec deux objets en sortie: le chiffre résultat qui sera convoyé en dessous de l'opérateur la retenue qui sera convoyée à gauche de l'opérateur (on envoie [[0]] quand il n'y a pas de retenue) [[ <-]]\ [[ <-]]\ [[ [[3]] <-]]\ [[ [[4]] ]] [[ ]] \ [[ [[5]] ]] \ [[ [[4]] ]] \ [[ ]] [[ [zZz(1) +] ]] \[[ [zZz(3) +] ]] \[[ [zZz(3) +] ]] \[[ (zZz +) ]] | | | | v v v v **eduDemo: calculs posés en utilisant commandes aéro-réglables(extracteurs de chiffres...), des réacteurs ([x >>]...) et des sleepingArgs ops ([zZz +]...) et aussi: attention aux retenues... 3 5 4 [x >>] 4 8 _____________ workflow: !⯐ clonePick_digit!([[48]])(previewing [[8]]) = [[8]] [[8]] * [x >>] = [[8x.. >>]] [[8x.. >>]] * [[4]] = [[32]] [[32]] * [digits] = [[2 3]] !pop!([[2 3]])(at the "right spot") = [[3]](held), [[2]](popped) !⯐ clonePick_digit!([[48]])(previewing [[3 8]]) = [[3 8]] [[3 8]] * [x >>] = [[3 8x.. >>]] [[3 8x.. >>]] * [[5]] = [[3 40]] [[3 40]] * [+] = [[43]] ... remark: there can be workflows in which carry is popped somewhere, to be added later on, etc. puis programmadraw: calculs posés avec une étape préliminaire de layout à codessiner dans la fonction (bien positionner les nombres en entrée) edu: pour les débutants: coder des opérations avec des entrées à 2 chiffres edu: pour les expérimentés: coder des opérations avec des entrées avec un nombre de chiffres a priori inconnu => boucles et fonctions mouvantes (moving function) **gm:challenge: op priority: initial is a reactor with an expression structure which must be populated missing elements of expression structure are filled from left to right examples: initial: [[..+..x(..-..)+.. >>]] [[..+..x(..-..)+.. >>]] * [[3]] = [[3+..x(..-..)+.. >>]] initial: [[..+4x(..-1)+.. >>]] layout: [[4]] [[5]] [[6]] [[7]] [[ >>]] [targetTouchSlot] [[4]] [[5]] [[6]] [[7]] edu: priorités opératoires, calcul mental **numberTyping: sleeping-args op: parameterized function: numberTyping("keys() ") spawns a keyed sleeping-args operator, which facade shows a preview: example: numberTyping("keys(a,b) x|->ax+b") on spawn: [[ [[a: ]] [[b: ]] ]] [[ ]] [[ [x↦ax+b] ]] when filled: [[ [[a: [[3]] ]] [[b: [[2]] ]] ]] [[ ]] [[ [x↦3x+2] ]] edu: faire sentir la structure générale x↦ax+b en utilisant différentes instances edu: faire sentir la différence entre variable et "paramètre" 10 février 2024: **moving function::draw vertical stroke and move horizontally to create diagonal stroke edu: expliquer les graphes de fonction (on se déplace suivant l'axe des x et on écrit suivant l'axe des y, et ça donne des morceaux pentus) **easy: opject: object is an operator and an object symbols: [[opj ] when used as an object: [[opj ] * [+ 2] = [[opj +2] [opj ]] when used as an operator: [[5]] * [opj ]] = [[50]] edu: relative numbers: [[opj + 50] * [opj + 3]] = [[opj + 53] [[opj - 10] * [opj + 53] = [[opj + 43]] **easy: copycat opject: symbol: [opj copycat ]] [[5]](held) * [opj copycat [[60]] ]] = [[5]](held), [opj copycat [[5]] ]] [[opj copycat [[5]] ] * [+ 2] = [[opj copycat [[7]] ] **easy: tongued opject: [opj::op [op] <-]----------------------------[[-> opj::obj [[obj]] ]] **easy: tongued copycat opject: [[5]](held) * [opj__copycat::op [clone] ]----------------------------[[-> opj__copycat::obj [[60]] ]] = [[5]](held) * [opj__copycat::op [clone] ]----------------------------[[-> opj__copycat::obj [[5]] ]] ***OOP:: the opject way: object with methods can be considered an operator if a method-finding **cain object: held or conveyed cain object kills all its brothers on its way **cain object generator: typical usecase: prime decomp algorithm (there must be only one "key" object on a key slot) **(*)garbage-tongued generator: when yielding new value, if previous value is in output slot, it is repatriated typical usecase: prime decomp algorithm (there must be only one "key" object on a key slot) (generate prime)<-------------------\ \________________>[ ]----------/ yielding conveyor garbage tongue this gives a feeling of round-robin **dots::write base decomp algorithm 0. set number__current: number_in 1. get enveloppe scale: scale such that base^(scale__enveloppe-1) < number__current < base^scale__enveloppe 2. set scale: (scale__enveloppe-1) 3. loop (while number__current is not zero): get digit in scale: digit such that digit x base^scale < number__current < (digit+1) x base^scale remove corresponding quantity: number__current = number__current - (digit * base^scale) go to lower scale: set scale: (scale-1) remark: scale digit can be computed differently: repeat "try removing base^scale from number__current", and when done, count the number of removed groups *compile func via flood fill: function becomes one big fat stain 11 février 2024: *keyDownToggles:: friendly toggle: when Key is keyDownToggled, Key is considered keyDownToggled too typical usecase: draw straight lines instead of freehand **edu: from sleeping-args based drawn program to expression tree: drawn program is often left to right []->-\ []->----[]--> []->-/ / []->-/ draw it top to bottom and it will look like an expression tree **[structure]challenge: runtime alteration: furnish function that is already running but has incomplete parts: conveyors are slow, but student still has to be quick, to ensure flow does not stop [[initial]] is function's input args [[target]] indicates what object(s) function must return student may programmadraw loops, ifs, etc. student may spawn operators via numberTyping edu: relier la définition et l'exécution, s'entraîner à lire rapidement edu: expressions littérales (encore et toujours) 12 février 2024: **easy: curse:projectile: held object can be launched like a projectile (constant speed) typical usecase: set sleeping args more easily via launching projectiles to operator edu: montrer une séquence de transformation sans utiliser de convoyeur **sleeping-args feeder operator/"squid" operator type: typical usecase: transform array-input operator into (input-)squid operator feeder operator: symbol: [zZ i#]------> (arrow must end inside an operator) input-squid operator: [zZ i#0]-------[--> ] [ ] [zZ i#1]-------[--> op ] /[--> ] [zZ i#2]-----/ **exhaust operator: typical usecase: transform array-output operator into (output-)squid operator exhaust operator: symbol: |-------[[-->o#0]] (arrow must begin inside an operator) output-squid operator: [ |-]------[[-->o#0]] [ ] [ op |-]---------[[-->o#1]] [ |-]--\ [ ] \--[[-->o#2]] **io-squid operator: [zZ i#0]-------[--> |-]------[[-->o#0]] [ ] [zZ i#1]-------[--> op |-]---------[[-->o#1]] /[--> ] [zZ i#2]-----/ ***[discovery]tongue operator/netsquids: the tongue is the altruistic version of the feeder/exhaust typical usecase: build sophisticated signals (road to a new era of spaghetti code) sleeping-args feeder-tongue operator: symbol: [zZ i]===========⊃ (tongue must intersect operator(s)) exhaust-tongue operator: |===========⊃ (tongue must begin inside an operator) tongues should not intersect input-args are resolved by sorting tongues from top to bottom netsquid operators: [zZ i]=======[ ]=====================[ ]=====⊃ (input arg #0) [zZ i]=======[ op1 ]=====================[ op2 ]==⊃ (input arg #1) [zZ i]=======[ ]=⊃ (input arg #2) [ //====]=======⊃ (input arg #2) [ [[ |==\\ ]] ] // \\==========================// op1 and op2 are netsquids operators, i.e. squid operators connected by tongue(s), forming a net **apply feeder operator: typical usecase: trigger operator from afar symbol: [apply]-----> usecases: transform nullary applicable op into n-ary impervious op (op which requires n args but never uses them) [[4]](held) * [apply]-----(--> index generator) = [[4]](held), (index generator) \----> \---->[[0]](generated (and then probably conveyed somewhere else)) [[4]](held) * [apply]-----(--> index generator) = [[4]](held), (index generator) \----> \---->[[1]](generated (and then probably conveyed somewhere else)) transform nullary applicable op into impervious binary (2 args required but (op) does not use them): [apply]-----------(--> ) ( op ) [apply]-----------(--> ) \---------> **apply tongue operator: typical usecase: control flow symbol: [apply]===========⊃ (it's like sleeping-args tongue but it does not broadcast touched object, it only broadcasts 'apply') usecase: synchronized apply examples: [apply]======(op1)========(op2)===⊃ <---/ \----> [[6]] * [apply]======(+ 1)========(+ 4)===⊃ = [[6]](held), (+ 1) (+ 4) <---/ \----> [[7]](gen'd)<---/ \--->[[10]](gen'd) **feeder platform/ feeder platform tongue: input-arg can be put anywhere on platform ***collapsing feeder operator/collapsing execution: input args are dragged to their operator, which applies, when they are touched by operator typical usecase: evaluation symbol: [ ]--->>>-----> visual example: [ [[1]] ]-->>>--[--> ] [ [[1]] ]-[--> ] [ [[2]] ]-->>>--[--> + ] becomes [ [[2]] ]-[--> + ] becomes [[6]] [ [[3]] ]-->>>--[--> ] [ [[3]] ]-[--> ] collapsing execution: if root applicable operator is executed, everything collapses, starting with 'leaves' (or furthest nodes if it's not a tree) in the tree below, !apply!( (x) ) induces !apply!( (+) ) and !apply!( (-) ) 4 3 5 1 (+) (-) becomes 7 4 becomes (x) (x) 28 edu: montrer toute la séquence d'évaluation d'une expression numérique edu: montrer le lien entre la forme arbre et la forme textuelle d'une expression littérale **[arrayify]: [["abcd"]] * [arrayify] = [['a' 'b' 'c' 'd']] [[3x+2]] * [arrayify] = [[ [[3]] [x] [[x]] [+] [2] ]] **operator extension pod/operator extension tongue: typical usecase: parallel execution flows example with 2 extension pods: [[4]] * [ext + 2] = [[6]] | | [+ 2 | | ] | | [[100]] * [ext + 2] = [[102]] example with an extension tongue: [[4]] * ∩ = [[6]] || [+ 2 || ] || || [[100]] * || = [[102]] || ∪ **easy:[operatorify]: create operator by putting [operatorify] over object examples: create transport operator by putting [operatorify] on transport pod create conveyor by putting [operatorify] on course 13 février 2024: *soft conveyor: conveyed object can be picked while object is conveyed hard conveyor: conveyed object cannot be picked while object is conveyed ***[serendipity]in-place conveyor == snapSlot: when touched but kept held, conveyor must display preview of object at point__start when released, conveyor starts conveying object conveyed object props: obj.isBeing__conveyed obj.isDone__conveyed **universal command: invoking universal command will invoke the command you'd most likely have invoked, given context typical usecase: promote operators symbol: !! shortcut: Key'!' **snapSlot::restricted snapSlot: when restrictedSnapSlot.check__restricted(obj__touched) == true, snapSlot previews and snaps obj__touched (obj__touched becomes obj__snapped) otherwise, obj__touched is completely ignored **easy: ad-hoc restricted snapSlot: put [condition] over snapSlot **snapSlot::proper snapSlot: snapSlot with a small light and a small trigger, snapSlot reacts differently wrt snapped object when properSnapSlot.check__proper(obj__snapped) == true, properSnapSlot's small light becomes green properSnapSlot's trigger triggers any op that is over it usual flavors: proper-obj snapSlot: snapSlot is green when obj__snapped == obj__proper proper-set snapSlot: snapSlot is green when obj__snapped ∈ set__proper proper-type snapSlot: snapSlot is green when type(obj__snapped) == type__proper edu: le fameux zPuzzle variant: restrictedProperSnapSlot: properSnapSlot which only previews and snaps proper obj (restrictedProperSnapSlot.check__restricted == restrictedProperSnapSlot.check__proper) **easy: create proper snapSlot from {object over snapSlot} workflow: 1. hold object 2. have snapSlot touch held object 3. while snapSlot shows preview of held object, invoke universal command !! => snapSlot is promoted to properSnapSlot **conveyor::restricted conveyor: when restrictedConveyor.check__proper(obj__touched) == true, restrictedConveyor previews and conveys obj__touched (obj__touched becomes obj__conveyed) **easy: ad-hoc restricted conveyor put [condition] over conveyor 14 février 2024: **operator::AB operator: symbol: [AB A: B: ] example: [[2]] * [AB A:[[2]] B:[[3]] ] = [[3]] [[10]] *\ [AB A:[[2]] B:[[3]] ] ***[structure]objects, operators and _transformings_ a transforming is an object that is still being operated on, it is currently undergoing a transformation sequence if an operator takes transforming into account, it may directly operate on it, i.e. mutate its transformation sequence by interrupting it and replacing what was foregone with a new transformation (sequence) transforming: symbol: [[ [[A]]⭜[[B]] .p: ⭜]] example: [[ [[0]]⭜[[10]] .p:0.5 ⭜6]](displayed [[5]]) transforming-returning operator: symbol: [ ⭜] example: [ [+ 3] ⭜10] input-can-be-a-transforming operator: symbol: [⭞ ] example: [⭞ [+ 3] ] {obj or frozen transforming.current} undergoes [+ 3] [⭞ [ [+ 3] ⭜10] ] {obj or frozen transforming.current} undergoes [ [+ 3] ⭜10] AB-transforming operator: symbol: [⭞ [ [AB A: B: ] ⭜] ] if input is inside AB-transforming operator's orbit, input transforming's transformation sequence is interrupted and what was foregone is replaced with a new transformation (sequence) example: [[ [[0]]⭜[[10]] .p:0.5 ⭜6]] * [⭞ [ [AB A:[[20]] B:[[0]] ] ⭜10 ] ] = [[ [[5]]⭜[[0]] .p:0.75 ⭜2.5]] usecases: animation edu: explain the concept of 'progress' **[grow_tree ⭜]: the inverse operation of collapsing execution: grow tree from expression result is a transforming: result starts transforming gradually, right after [grow_tree] has untouched it [[7+3y]] * [grow_tree ⭜6] = [[ [[7+3y]]⭜[[tree]] ⭜6]] visually: [[3]] [[y]] \ / becomes [[7]] [[3x]] becomes [[7]] [x] \ / \ / [[7+3y]] * [grow_tree ⭜] = [[7+3y]] [+] [+] edu: expressions littérales et arbres de calcul **[collapse/grow ⭜] auto-reverse operator: typical usecase: unfold/fold expression/expression tree **position has a particular status in AUI: a conveyor could be considered a transforming-returning operator but it's not position is like a meta-property some objects live in a geometric space (geometry objects) some objects live over it (programmadraw objects) ("meaningful" objects) 15 février 2024: **sleeping-args multi-conveyor: n conveyors which start at the same moment, when each has its sleeping arg ready they may end conveying at different moments []-----> []\ \--------------> **sleeping-args multi-conveyor::[freeze]: "everybody stops now" if an object is touched by [freeze] on any of the conveyors, all conveyors end conveying and leave their conveyed as is **eduDemo: triangle inequality race: workflow: 0. draw triangle EFG, [EF] being the longest side 1. draw a sleeping-args multi-conveyor: 1.a. draw 1-segment k-speed conveyor from E to F 1.b. draw 2-segment k-speed conveyor from E to G and G to F 2. spawn [freeze] on F 3. pick 2 objects, and have them touched by their conveyor at point E => object conveyed by 1-segment conveyor wins the race everytime edu: perimètre: la longueur du côté le plus long est égale à une somme de 2 longueurs (dont l'une est une fraction de celle d'un des côtés (le coureur s'est arrêté avant la fin)) ***gnipeels-outputs operator: same as sleeping-args but for outputs: they're like standard sleeping-args in reverse time => all outputs arrive at their output conveyor's end at the same moment consequence: this may introduce delays in sleeping-args input conveyors so that each sleeping-args input conveyors now has a delay tolerance one may build sequence of gnipeels-outputs operators when chained, gnipeels-outputs operator1 is (timewise) seamlessly compatible with zero-delay sleeping-args operator2 edu: introduction to task scheduling optimisation by leveraging delay tolerance by hand by rearranging operators in sequence ***restrictedOperator: operator can only touch its related object if related object is destroyed, destroy all its associated restrictedOperators typical usecase: programmadraw: loop conveying counter-and-other-objects composite, operate on individual parts typically: increment counter without affecting other objects in conveyed composite symbol: [# ] examples: [[4 (.id: 156)]] * [#156 [+ 3] ] = [[7 (.id: 156)]] [[10 (.id: 33)]] *\ [#156 [+ 3] ] **!crown!: promote current selection to "super selection" typical usecase: add a protection layer to command invocation (some command will only be realized if their is a crowned object somewhere on screen) shortcut: KeyF1 ***easy: numberTyping::restrictedOperator: workflow: 0. select object(s) 1. crown current selection 2. numberTyping("") => spawned operator will be a restrictedOperator related to crowned object(s): [#id__crowned [] ] remark: crown array handle if you want to restrict operator to this array (treat array as an object), crown array elements if you want to restrict operator to its elements (and don't care that they are contained in an array) there may be a visual indicator showing that restrictedOperator's related object is objX using colors using symbols ... 22 février 2024: **easy: equipment snapSlot: adhere snapSlot on object (freeDrawing for example) typical usecase: equip drawn character with object fun: pour habiller les marionnettes avec des costumes et des accessoires **easy: (home)Scale-wise auto-layout: group of adjacent objects with sameOrClose homeScale are considered as a rect for auto-layout when seen from afar => one can horizontally align a "big object" with a "big" archipel of "small" objects this is strange because it's at the same time exact and fuzzy ***discrete loop: transition from continuous flow to discrete flow workflow: 1. programmadraw a loop: draw a looping pathmade 2. adhere snapSlots on loop these snapSlots become stepSnapSlots => object conveyed by this looping jumps from loop.start to stepSnapSlot#1 to stepSnapSlot#2, ..., to loop.start, etc. edu: passer en douceur de la programmation par le dessin à la programmation par blocs/programmation textuelle **loop generator: tDraw a loop with [[Integer]] this spawns a [loop generator] [[5]] * [loop generator] = [loop: 5] [[0]] * [ [+ 2] on path of [loop: 5] ] = [[10]] **aui VS natural deduction: specific object types: premissa P hypothesis H specific operators: all elimination operators all introduction operators *easy: [rotate] workflow: 1. enter rotateOpCreation mode 2. click on center 3. click on point_start => a preview of point_end now appears based on where mouse pointer is 4. move mouse pointer where you want so that point_end is fine and click 5. leave rotateOpCreation mode *easy: auto-reverse [rotate] typical usecase: make drawn character wave their arm *pen operator over something: auto-adhere as for a standard freeDrawing over an object **game: MMOCodenames: cell is valid when n teams have it valid typical usecase: play in a theater room, resulting game board is displayed on the screen, everyone plays on their phone n games share the same board there are 2n groups of guessers, guessers are seated on the left side there are 2n groups of tellers, tellers are seated on the right side all games are actually part of a bigger game remark: this is only a rough idea **gm challenge: 3+ary [+] and [x]: [] and [Σ] and [Π] challenge can only be completed by using [Σ] and [Π] student has to find combinations that work edu: les tables d'addition et de multiplication, différemment variant: strict arity operators: [zZz(3) Σ] only accepts 3 args **gm challenge: n-ary [Σ] and [Π] and unary [opposite] and [inverse] layout: [inverse] [Π] gm grid target [opposite] [Σ] (***)my office in your office: in a 3D space, by using portals, P2 can insert their office inside P1's office without P1 noticing P1 will cross portals without noticing it [P1 office P1 office P1 office P1 office || P1 office P1 office P1 office P1 office P1 office] / \ / \ / \ [P2 office] what is fun is that P2 walls can show P1 office on each side, so that P2 has the sensation of being in P1's office ***transforming:: custom AB-transforming:: the normal way: typical usecase: create an AB transforming with custom value transforming workflow: 1. spawn segment course 2. start drawing path from course.start transforming.value is projection of point on segment transforming.value = A.value + ((abscissa on (AB) with A as origin) / length of [AB]) * (B.value - A.value) so that when drawing normally wrt to segment, transforming.value stays constant (though transforming.progress changes) remark: this also allows having a value that is outside [A.value, B.value] interval ***sleeping-args::composite sleeping arg: object with snapSlots (one could say a dedicated vessel) when all snapSlots are filled, composite sleeping arg is .ready there could be a snapSlot for an array of any size ***edu: CS: obj.type="var" typical usecase: explicitly create an object which is automatically assigned transformation result symbol: [[[a]]] example: [[[a value:5]]] * [+ 2] (1 var, 1 op) ==> [+ 2], [[[a value:7]]] (1 var, 1 op) [[4]] * [[+ 2]] (1 obj, 1 op) ==> [+ 2], [[4]], [[6]] (2 objs, 1 op) remark: to avoid rewriting everything, we should just keep that in mind edu: pour expliquer aux élèves la différence entre une valeur et une variable **transforming::B-operator: starting value is touchedObject.value, ending value is operator.B.value workflow: (0. spawn [[value]] (this will be used as "B") 1. draw segment course ending at B => [B-operator] is created **challenge: use B-operator to create correct input [ ] | v | []------[x 2]------->[target: 4] | [[10]] **easy: transforming-returning operator: set duration by adhering [[duration]] **(**)easy: moving function by moving function platform: function's definition object_space actually contains a function platform which can be conveyed [ ] [ [f platform ] ] [f] [ ] ] [ [ [] ] ] [ \ ] [ \______> ] conveyor (to move function) function platform conveyor is triggered at the right time via a key touched by conveyor.start (the key is itself conveyed in the function body) **easy: create complex generator using base generator: (gen: [[1:10:1]] )----------[x 2]---------> can be compiled to (gen: [[2:20:2]])------------------> **flow object: (will o' the wisps) this object is a meta object, it is a shining ball that moves to represent execution 24 février 2024: **[meta]meta object type: "animated object": a consistent group of objects and operators (=="insides"), which may be animated, for example by conveyors, or other operators 2 flavors: robot object: insides have a deterministic behavior example: a clock living object: insides have a non-deterministic behavior example: an evolutive organism (in 2D, with 2D tentacles, and other creepy life-specific stuff) remark: animated object may be composed of animated objects living object may be composed of living objects **[meta]{animated object}-specific operator: operator operates on insides of animated object, hopefully, taking its specific organisation into account operator may break animated object the same as [[4]] * [+ 2] = [[6]] we can have [[animated object]] * [operator] = [[animated object (transformed)]] example: change duration of a random conveyor in animated object **[map]/[filter]/[reduce]: these are sleeping-args operators with an operator as sleeping-args key [map] needs a sleeping-args key [op] [[0 1 4]] * [ [+ 2](key) over [map] ] = [[2 3 6]] [filter] needs a sleeping-args key [op] [[0 1 4]] * [ [ [% 2] over [== 0] ](key) over [filter] ] = [[0 4]] [reduce] needs a sleeping-args key [op] and a sleeping arg [[initial]] [[0 1 4]] * [ {[acc,x↦acc+x](key), [[100]](sleeping arg)} over [reduce] ] = [[105]] **[structure]expansion/contraction operators (for collections): the execution of those operators enacts as an expansion followed by a contraction to ease the expansion/contraction layout, operator has a start and an end which are not the same point to be more precise, expansion tree root is not located at the same point as contraction tree root symbol: [⪪⪫ ]--------[[-> end]] edu: montrer le parallélisme des opérations sur les éléments de la collection en entrée ***[⪪⪫ map]/[⪪⪫ filter]: /---[[1]] /---[[1]]---[+ 10] / / [[1 2 3]] * [ [+ 10] over [⪪⪫ map] ] ==> [ [+ 10] over [⪪⪫ map] ] <-----[[2]] ==> [ [+ 10] over [⪪⪫ map] ] <-----[[2]]---[+ 10] ==> ... \ \ \---[[3]] \---[[3]]---[+ 10] transformed elements are then grouped into output collection "smart" map may take dict as input and return dict as output filter works a bit differently, elements not satisfying condition are stuck on condition operator where other elements continue and gather into output collection **explain operator: [⪪⪫] put it over [map] or [filter] to get [⪪⪫ map] or [⪪⪫ filter] workflow: 1. put [⪪⪫] over [op] 2. draw a segment from [⪪⪫] to [⪪⪫]'s desired [[end]] remark: [⪪⪫] on [reduce] results in a loop ([[end]] must still be drawn to specify loop's extent) **loop::multi loop: draw n loops (these could be segment-carried auto-reverse loops, or standard loops), they all start and end at same time typical usecase: create a flame animation using segments with segment.start in multiloop.subLoopX and segment.end in multiloop.subLoopY workflow: 1. enter multi loop drawing mode shortcut: multi + loopDrawingMode (multi key is a generic meta shortcut) 2. loop: draw subloops 3. leave multi loop drawing mode **sleeping-args operator::(generator) as sleeping arg: either: sleeping-args operator has only generators as sleeping args => sleeping-args operator becomes a generator (i.e. an applicable operator) OR: sleeping-args operator has standard objects as other sleeping args => generators yield a value when all standard sleeping args are ready ***sleeping-args operator::default argument sleeping-arg conveyor: this conveyor has 2 slots: one slot for the default value, one for the sleeping arg default argument has a specific display, so it is clear that it is a default argument (==a copycat generator yielding always the same value: the default argument that was slotted in) 26 février 2024: *adhere::fluid adhere (==Hook-and-loop adhere): part.isMobile:true and when part is held and moved, it is unadhered as soon as it untouches its parent support edu: les enfants sont habitués aux scratchs(velcro) **multi properSnapSlot (== sleeping-args properSnapSlot): when all inner (proper)snapSlots are filled and valid, multi properSnapSlot is valid **easy: multi properSnapSlot: workflow: 1. hold many objects 2. invoke snapSlot spawning command to spawn a snapSlot under each object 3. while each snapSlot shows preview of each held object, invoke universal command !! => snapSlots are composited into multi properSnapSlot **(*)easy: crossword: a crossword operator can be made easily with a multi properSnapSlot: when all inner (proper)snapSlots are filled, the operator representing the whole word may become green if all inputs are correct remark: it can also be made via a multi condition operator edu: fabriquer des escape games avec des crosswords qui donnent des objets une fois terminés les escape games pourraient être potentiellement très "edu", avec du vocabulaire de cours et des nombres retournés une fois la grille terminée, pour pouvoir faire d'autres challenges... **fractions::same-denominator-only operators (add,sub): [frac(..1,..3) + frac(..2,..3)] [frac(..1,..3) - frac(..2,..3)] examples: [[1/10 3/10]] * [frac(..1,..3) + frac(..2,..3)] = [[4/10]] [[1/10 1/6]] *\ [frac(..1,..3) + frac(..2,..3)] **gm:challenge:same-denominator-only operators **gm:challenge:same-denominator-only operators and [simplifyBy()] (or [simplify]) 10 mars 2023: **FrankAccess (FR: accès franc): transport X icPeer peerA goes via transport from env__self::[pod_start] to env__peerB::[[pod_end]] workflow: 1. use icPeer object to create connection with peerB 2. spawn frankAccess pod: 2.1. spawn [pod_start] in self's env 2.2. spawn [pod_end] in peerB's env => spawned transport pod is automatically promoted to frankAccess pod => frankAccess pod is auto-configured to support p2p connection frankAccess [pod_start] won't work when peerB is not connected frankAccess pod may be serialized to allow quick resuming of collaborative work: connect back with the peer where the dedicated pod transports to frankAccess [pod_start] works as expected as the peer is actually connected if [[pod_end]] is deleted (by either peers), [pod_start] becomes useless ***workshopeer: collaboration-dedicated peer: this peer is actually a server, creating host peers for humans to work in, 'human' peers must be 2+ to connect to it workflow for 2 human users: 1. peerA and peerB get connected 2. peerA "goes in peerB" and spawns an icConnection to workshopeer peerB "goes in peerA" and spawns an icConnection to workshopeer 3. peerA tries connecting to workshopeer via env__peerB::[icConnection] peerB tries connecting to workshopeer via env__peerA::[icConnection] => workshopeer is created and peers are connected to it 4. peerA uses env__peerB::[icConnection] to go to workshopeer peerB uses env__peerA::[icConnection] to go to workshopeer 5. peerA and peerB work together to create something 6. whenever peerA or peerB is disconnected, workshopper is no longer available or at least readonly ***(*)[structure]challenge: math::fluid equation: Everything has to go / Everyone has to be pleased (this is close to logistics): all-ops are single-use operators there is 1+ terminator(s): [numberA↦] [numberB↦] [numberC↦]... OR [exprA↦] [exprB↦] [exprC↦]... layout may be a bit messy example: [[3]] [x 2] [[2]] [- 10] [15↦] [-6↦] [x 5] remark: sleeping-args (==2+ary) operators may be used exemple: [[3]] [[2]] [[2]] [+] [- 10] [15↦] [-6↦] [x] [[5]] remark: there may be hints since depth grows exponentially ***(*)[structure]challenge: math::zero fluid equation: Everything has to go: the goal is to create zeros so that in the end, nothing is left [[0]] may be rewritten [[ ]] so that [0↦] may not necessarily be displayed example: [[3]] [x 2] [[2]] [- 10] [- 6] [x 5] ***generalized functional programming: chain multi-io funcs (==io-squids) so that it's all wired well (**un opérateur comme [+ 2], c'est comme une fonction, mais on se fout de la variable liée l'opérateur porte d'abord le caractère performatif de la transformation la fonction porte d'abord le caractère structurel de la transformation ***aui X Prolog: visually define predicates and work with them ***icObj.type = "predicate" predicate is a dynamic 1+key'd (and often 1arg'd) sleeping-args operator workflow: 1. spawn predicate stub 2. rename predicate stub to "" 3. put objects on predicate platform (or perfect clones/references of the objects) => all objects on platform satisfy predicate 4. [] can then be used as a standard operator 5. operate on [[?]](== unknown object) to get an object that satisfies predicate step 3. may be done again, anytime example: 1. [predicate] 2. [predicate: magicNumber] 3. [predicate: magicNumber [[22]] [[42]] [[62] ] 4. [[3]] * [predicate: magicNumber [[22]] [[42]] [[62] ] = [[False]] [[42]] * [predicate: magicNumber [[22]] [[42]] [[62] ] = [[True]] 3. [predicate: magicNumber [[22]] [[42]] [[62] [[3]] ] 4. [[3]] * [predicate: magicNumber [[22]] [[42]] [[62] [[3]] ] = [[True]] 5. [[?]] * [predicate: magicNumber [[22]] [[42]] [[62] [[3]] ] = [[22]] (or [[3]] or ... (depends on sorting method used)) fun thing is that, with an infinite canvas, predicate samples can be put inside it, very small, so that [[?]] * [predicate] has the same gambling feeling as in textual code (Prolog for example) edu: programmer avec des prédicats un système de résolution d'un problème qui demandrait beaucoup d'exploration si on le faisait à la main 11 mars 2024: **math:alegbra rules operators::add fracs: [../@ + ../@] {[[2/5]],[[1/5]]} * [../@ + ../@] = [[3/5]] {[[2/504]],[[61/7]]} *\ [../@ + ../@] **icObj.type = "formula" (worksheet-style expression building) ("pure") formula: has ref cells has an expr has a previewed result workflow: 1. write expr 2. for each referenced object, draw bounds from expr obj to referenced object referenced object may be a formula result => formula hierarchy referenced object may be a snapSlot as soon as snapSlot is filled, formulas' previews auto update layout: [[ --\ ]] | \-------------[op1] | [[result]] \--[op2] [[result]] example: [[|2\]] | \----------------[3x²] | [[12]] \---[2x+5] [[9]] **copyHandleScroll: copyHandleScroll([+ 3], "up") ==> [[ [+ 3] [+ 4] ]] ==> [[ [+ 3] [+ 4] [+ 5] ]] ==> [[ [+ 3] [+ 4] [+ 5] [+ 6] ]] copyHandleScroll([+ 3], "down") ==> [[ [+ 2] [+ 3] ]] ==> [[ [+ 1] [+ 2] [+ 3] ]] ==> [[ [+ 0] [+ 1] [+ 2] [+ 3] ]] copyHandleScroll(snapSlot, "up") ==> [[snapSlot snapSlot]] ==> [[snapSlot snapSlot snapSlot]] ==> [[snapSlot snapSlot snapSlot snapSlot]] ***repScroll: change representation of held object(s) or of object in pov if nothing held objects have their facade updated operators have their facade updated **operators have their transformation animation updated example: ctx: [[2]], [+ 3] in this representation: [[2]] * [+ 3] = [[5]] animation may be 2 ==> 3 ==> 4 ==> 5 or 2 + 3 ==> 3 + 2 ==> 4 + 1 ==> 5 (increment) after repScroll: [[||]], [+ |||] in this representation: [[||]] * [+ |||] = [[|||||]] animation may be || ||| ==> || ||| ==> ||||| (concatenate) edu: changer de registre de représentation 13 mars 2024: **obj.type = "deck": well X store typical usecase: probabilities with a deck of playing cards **obj.type = "spawnSlot" ***easy: spawnSlot:: hover-based numberTyping: workflow: 1. hover mouse cursor on spawnSlot 2. input something: type something OR say something example: say "tableau 2 1 3" => preview will be [[2 1 3]] OR ... => a preview is shown continue inputing something till you're ok with preview 3. leave spawnSlot or hold preview to spawn object (==transform preview into a 'real' object) **easy: spawnSlot::alice injection: put physical object on spawnSlot => its icObject equivalent will be spawned *mute operator/catalyst: typical usecase: protect execution mute operator can operate only if put on a catalyst symbol: [/ [operator] \] example: [[3]] *\ [/ [+ 2] \] [[3]] *\ [ [/ [+ 2] \] over [catalyst] ] = [[5]] ***[ux]feature palette: typical usecase: configure keyboard shortcuts easily, so that they suit user's needs the configurable keys will be [1][2][3][4]...[0] workflow: 0. find or spawn an operator related to the feature for which you want a shortcut 1. hover mouse cursor on feature's operator 2. W. => when pressing Digit, you enter feature's mode remark: "Shift.W, <...>, Return" may allow creating multi-keyed shortcuts ***[ui]feature palette: pressed configurable key and its feature will showfade in HUD (near top left corner) example: |---------------------| | [3]ssConveyor | | | |---------------------| ***[ux]feature palette: feature folders / current feature: there may be like feature folders example: if [Pens] is assigned to Digit3 Digit3.mouseWheel will allow to select a particular pen, the same way the current color is selected by using C.mouseWheel ***alice abduction (==universal transfer): capture object from filmed canvas to phone's canvas typical usecase: some mathematical objects are displayed on the whiteboard and students grab them with their phones to manipulate a copy of them 2 flavors: true adbuction: filmed object is kidnapped from filmed canvas cloning abduction: a clone of the filmed object is spawned on phone's canvas edu: à chacun son petit atelier fun: gotta catch 'em all **[discovery]vDraw/tDraw::multiple: what if you vDraw with multiple objects ? or tDraw with multiple types ? vDraw: ? tDraw: consider that type1 is type of input and type2 is type of output **icObj.type = "key" typical usecase: reproduce Scratch's green blocks behavior key object: is not transformed by op forms a composite of type "constant" when over an op symbol: ((]] example: [[ ((2]] over [+ 10] ]] will behave like [[12]] [[2]] * [keyify] = ((2]] ((2]] * [unkeyify] = [[2]] ***(*)snapExpr: expression with snapSlots inside typical usecase: reproduce Scratch's green blocks behavior snapExpr has 2 states: .full .incomplete symbol: [[ with 1+ ⛋[[]] in it ]] (the snapSlots are represented by ⛋[[]]) example1: snap [[3]] in [[2 / ⛋[[ ]] ]] ==> [[2 / ⛋[[3] ]] (which will behave as [[2/3]]) example2: snap [[5]] in [[ ⛋[[ ]] / ⛋[[ ]] ]] (bottom slot) ==> [[ ⛋[[ ]] / ⛋[[5]] ]] snap [[11]] in [[ ⛋[[ ]] / ⛋[[5]] ]] (top slot) ==> [[ ⛋[[11]] / ⛋[[5]] ]] edu: résoudre le problème process/product opérateur: performatif (process) snapExpr: structurel (product) et on peut imaginer un mélange des deux qui serait à la fois performatif et structurant [[3]] * [2 / ⛋[[ ]] ] = [[2 / ⛋[[3] ]] remark: we dump hardcore parenthesis single-line notation and use 2D slot-based layout **(*)[snapExprify]: transform an operator into a snapExpr [2 /] * [snapExprify] = [[ 2 / ⛋[[ ]] ]] [/] * [snapExprify] = [[ ⛋[[ ]] / ⛋[[ ]] ]] **(*)[atomify]: transform a snapExpr into an expression [[2 / ⛋[[3] ]] * [atomify] = [[2/3]] 14 mars 2024: **easy: (home)Scale autoAdjust: system detects when user wants 2 objects to have same size / scale and softly performs this micro adjustment on held object 15 mars 2024: **math::numbers::[sym()]: return symetrical of input wrt to numberCenter example: [[3]] * [sym(5)] = [[7]] **bars_and_numbers: HorizSquaresBarIntegerConstantNode(10) 3(🄹🄹🄹🄹🄹🄹🄹🄹🄹🄹 + 🄳🄳🄳🄳) = 🄹🄹🄹🄹🄹🄹🄹🄹🄹🄹 🄳🄳🄳🄳 🄹🄹🄹🄹🄹🄹🄹🄹🄹🄹 + 🄳🄳🄳🄳 🄹🄹🄹🄹🄹🄹🄹🄹🄹🄹 🄳🄳🄳🄳 0 numberTyping 0 horizSquaresBarDecimalConstantNode(10) 0 manage decimal part 0 control::resize => change value HorizSquaresBarIntegerSumOperatorNode(new HSBICN(10), new HSBICN(4)) 🄹🄹🄹🄹🄹🄹🄹🄹🄹🄹🄳🄳🄳🄳 operators: [+ 2] -> [+ 🄱🄱] (concat) [+ 2] -> [+ □□] (inject in last) [+ 2] -> [+ □□] (inject random) [+ 2] -> [+ □□] (inject fairest) [+ 2] -> [+ □□] (inject weighted) [- 2] -> [- □□] (eject from last) [- 2] -> [- □□] (eject random) [- 2] -> [- □□] (eject fairest) [- 2] -> [- □□] (eject weighted) [x 2] (concat) [x 2] (distribute) [x 2.5] (concat) [x 2.5] (distribute) [/ 2] (concat) [/ 2] (distribute) [/ 2.5] (concat) [/ 2.5] (distribute) **bars_and_numbers::fluid addition: [+] (fluid): result is fluid (==everchanging), to indicate that numbers are perfectly melted together this can also represent that melting is not a thing that numbers do, they simply become something else {[[🄹🄹🄹🄹🄹🄹🄹🄹🄹🄹]], [[🄳🄳🄳🄳]]} * [+ (fluid)] = [[🄹🄹🄹🄹🄹🄳🄳🄳🄹🄹🄹🄹🄳🄹]] ==> [[🄳🄹🄹🄳🄹🄹🄹🄳🄹🄳🄹🄹🄹🄹]] ==> [[🄹🄹🄹🄳🄹🄹🄹🄹🄳🄹🄹🄳🄹🄳]] ==> ... **bars_and_numbers::"from fluid to new" addition: [+] (fluid to new): result is fluid (==everchanging) then becomes result number {[[🄹🄹🄹🄹🄹🄹🄹🄹🄹🄹]], [[🄳🄳🄳🄳]]} * [+ (fluid)] = [[🄹🄹🄹🄹🄹🄳🄳🄳🄹🄹🄹🄹🄳🄹]] ==> [[🄳🄹🄹🄳🄹🄹🄹🄳🄹🄳🄹🄹🄹🄹]] ==> ... ==> [[🄽🄽🄽🄽🄽🄽🄽🄽🄽🄽🄽🄽🄽🄽]] 10 4 + 10+4 10+4 fading to 14 16 mars 2024: **gm:challenge:simple distr 0 target: 4(10 + 4) = 40 + ? target: 4(10 + 4) = ? + 16 0 target: 4(? + 4) = 40 + 16 target: 4(10 + ?) = 40 + 16 0 target: 4(10 + ?) = 56 **(*)[meta]gm:challenge:"making-of" _derived challenges_: create derived challenges "*? = *" and "* = *?" from challenges with target: value edu: en avant, en arrière, à l'intérieur, à l'extérieur: la résolution sous toutes ses formes ("making-of" _derived challenges_ == challenges à trous dérivés) 20 mars 2024: **game: le golf à 2 balles (translation edition): origin (tee) is a ball shooting origin makes ball move too (since ball is living in this coordsSystem) shots are alternatively: player shoots ball towards hole player shoots origin (so that ball gets closer to hole) edu: translation **game: le golf à 3 balles: hole is a ball too shots are alternatively: player shoots ball towards hole player shoots origin (so that ball gets closer to hole) player shoots hole towards ball edu: relative numbers **game: le golf à 2 unités: shots are alternatively: a shot wrt absolute units (in meters for example) a shot wrt relative units (100 % = distance(tee, hole)) **"reverse" painting challenge (paint the same way as in hover-tune) brushes are static, sheet moves ***[AI](*)aui pleasure: let generative AI code of class from crafted instance engine(s) code is also generated from crafted funcs ***[AI](*)"ultimate bootstrap": ask wired generative AI to create object or operator then try it via manipulation then improve/rework it via conversation => this may allow a non-programmer to create arbitrarily sophisticated objects ***icObj.type = "blueprint" blueprint operators can be used as is: operator will be realized just before being used symbol: ▙ examples: [[4]] * [▙ + 10-20] = [[19]] [[4]] * [▙ + 10-20] = [[22]] ... [[▙ 2-4]] * [+ 5] = [[9]] [[▙ 2-4]] * [+ 5] = [[8]] ... [[▙ 2-4]] * [▙ + 10-20] = [[12]] [[▙ 2-4]] * [▙ + 10-20] = [[20]] ... ****the blueprint way: use challenge creation DSL in iC, and use [realize] to generate challenge from blueprint typical usecase: allow teachers to create their own challenges [[blueprint]] * [realize] = [[interactive object]] blueprint may be a big object: [▙ ] [ [op5] [▙ op6] [op7] [▙ op8] ] * [realize] = [ [[▙ initial]] ] [ [▙ op1] [▙ op2] [▙ op3] [▙ op4] ] objects in root blueprint may or may not be blueprint objects themselves instead of using blueprint operators, one may use random operators (*le problème majeur, c'est la fabrique du nihilisme par négligence (tout le monde semble se foutre des changeurs de monde) (MiMi: mi lettré, mi manuel: prof 50% du temps, manuel 50% du temps **gm:challenge: derivative: build expr ==> [expr ↦ f] ==> [f ↦ f'] ==> [f ↦ expr] ==> [[target]] **opCount: count of operator use is displayed under each op **gmCount: opCount + reset when gm dies each gm has its own gmCount environment **gmOrder: opOrder + reset when gm dies ordinal numbers are used to display index under each op each gm has its own gmOrder environment 03 avril 2024: ***obj.type == "pointCell": the equivalent of a spreadsheet cell in a coordsSystem typical usecase: equation of a line workflow: 1. spawn a coordsSystem 2. spawn a pointCell (whose parent will be the coordsSystem) 3. set pointCell's formula example: [[=2x-y]] => if [[=2x-y]] is at point (0;4) then cell will display [[-4]] (4. move cell around and clone it many times to "paint" coordsSystem with values edu: toutes les équations à 2 variables (iC) edu: toutes les équations à 3 variables (3DWorld) 05 avril 2024: **easy random spawn configuration: 1. press and keep pressed randomSpawnKey 2. press and keep pressed randomSpawnConfigKey 3. scroll until config is ok (randomSpawnConfig is previewed) 4. release randomSpawnConfigKey 5. randomSpawnKey => desired random object will spawn 6. as random config has be set up, randomSpawnKey will now spawn object with the active randomSpawnConfig edu: travailler avec du same same but different 16 avril 2024: ***breadthScroll/depthScroll: ease selection of object in composite (parent or child or content) **hierarchyScroll: depthScroll with memory of what was the last visited member in each layer 21 avril 2024: ***shrinkWarpScroll(== zPushScroll): every object inside screenPov stays self-centered but has its homeScale modified typical usecase: layout ***(*)[meta] !screenMap!/[screenMap]: when you screenMap an operator, all objects on screen are operated on example: !screenMap!([+ 3]) on {screenPov: [[2]] [[80]] [[24]] [[□□□]]} ==> {screenPov: [[5]] [[83]] [[27]] [[□□□□□□]]} edu: !screenMap!([x 10]), !screenMap!([÷ 10]), ... ***(*)[meta] !poolMap!/[poolMap]: when you poolMap an operator, all objects in pool are operated on typical usecase: poolMap'd tunable operators (c'est le concept de machine) pool: _______________________ _______________________ | [+ ⇳] | | [+ ⇳] | | | | | | [[x+2]] | ==> mouseWheel(8) on [+ ⇳] ==> | [[x+10]] | | | | | |______________________| |______________________| ***challenge: equations VS poolMap'd tunable operators: pick equation and move from pool to pool to finally **[notation]: la virgule seconde, tierce, etc. edu: pour bien faire comprendre que 3,45 < 3,5 on noterait 3,456 de cette nouvelle façon: 3,4,,5,,,6 3,4,,5 < 3,5 on pourrait aussi s'en servir pour faire comprendre que 3,4,,5,,,6 = 3 x 10^0 + 4 x 10^(-1) + 5 x 10^(-2) + 6 x 10^(-3) (*experience: faire traîner de manière très visible sur internet le corrigé d'un devoir mais ce corrigé est faux (pour détecter la triche) **utiliser le DSL de RNG pour créer des générateur de devoir sur table _avec leur corrigé_ "latex++" **[notation]generics: u_n = 3 x 4^n should better be displayed u_🄽 = 3 x 4^🄽 the boxing should emphasize the fact that 🄽 is a generic _placeholder_ ***(*)auxiliary objects: these objects only live to supplement their related object, they often contain metadata typical usecases: use_counter a use_counter on a operator is an auxialiary object that shows how many times the operator has been used history_counter a history_counter on a object shows how many times the object has been operated on (history_counter is incremented even though transformation was [identity]) a history_counter could be used on a lambda-decay cursed object to create statistics with 1000 of such objects, to exhibit exponential decay object-specific use_counter: an object-specific use_counter on a operator is an auxialiary object that shows how many times the operator has been used on a particular object auxiliary objects may be hidden to end-user, and used by challenge creator to program the challenge ***[game]: ranked objects: all object are ranked objects, ranging from common object (rank:1) to legendary object (rank:5) high-rank objects may have special properties for example: legendary objects could have a gold color, or a special color effect (foil, polychrome,...) ranked objects can be dropped by the game, after completing challenges, or hidden in some places edu: motivation extrinsèque any object can be ranked: ranked operators, ranked generators, ranked objects, ... a [rankUp] operator may be used (this may be a single-arg'd single-use operator, or a sleepingArgs operator requiring consumable items, ...) ***challenge: **panMove: keep object at same screenPos but move screenPov typical usecase: dual mousepad control (for example: Steam controller) left mousePad is object pan, right mousePad is pan move (==screenPov pan) **icObj.type = "flower": growing object *[voice]zoomIn/zoomOut by voiceControl: high pitch is zoomIn, raising pitch is accelerating zooming in same thing with zoomOut and low pitch **challenge: from colored clothes to distributivity with numbers: "[x 5] is [color: yellow]", "[+ 5] is [+ trousers]" bloomScroll allows shifting back and forth from [[t-shirt color: yellow]] to [[3 x 5]] [x 0] is [color: transparent] [x 1] is [color: ] [x 0.5] is [color: dirty] [x 0.2] is [color: very dirty] 3 yellow shirts <-> 5 blue shirts [x 5]: change color to yellow [x 5] (then): multiply quantity 30 avril 2024: ***lazy display: the visual equivalent of lazy computing: see value of object by zooming in it typical usecase: chain operations on big object and only look at result at the very end ***zMetroid: 2D platform game with non-rectangular quadrilateral game panels so there is a feeling of going deep (ce que l'on veut pour nos élèves: 1. qu'ils aient envie de faire quelque chose (pas forcément changer les choses mais faire quelque chose) 2. avoir les langages pour le faire (concepts généraux, vocabulaire spécifique, langage mathématique, ...) (adaptation d'impédance d'échelle: transfert d'une puissance d'une zone zoomée vers une zone dézoomée et réciproquement ***(*)language zone: same operatorSlot behaves differently in the 2 spaces typical usecase: a dedicated zone for APL operators language zones: APL Python Javascript Maths example: [+] in the language:APL zone [[3 1 2]] * [+]/[[4 1 1]] = [[7 2 3]] [+] in the language:Python zone [[3 1 2]] * [+]/[[4 1 1]] = [[3 1 2 4 1 1]] !numberTyping!:"lang apl" ==> a language:APL zone is spawned (([[2]] is like man, [+ 2] is like woman ***[structure]color trace: last simplification's result is displayed with a specific color edu: c'est une trace semi-explicite: on n'affiche pas l'expression entière mais on affiche une trace de la transformation variant: each operation colorifies object in a certain color: + ==> yellow - ==> blue x ==> magenta / ==> pink ^ ==> cyan ***color trace challenge: target has specific color(s) ***[structure]color levels: "blue with blue gives red", "red with red gives yellow" 2 flavors: color level raises with pairing 2 same colors 2 sub flavors: only objects are colored: [[blue 2]] * [+]/[[blue 3]] = [[red 5]] operators are colored too: [[blue 2]] * [blue +3] = [[red 5]] color level raises with complexity: [[blue 2x+5]] and [[red x+5]] because 2x+5 is more complex than x+5 ***color levels challenge: target has specific color(s) edu: priorités opératoires minimathador: initial: [["low" color 4]] ops: low+ color operators medium color operators medium+ color operators target: [["high color" 56]] ***challenge:color levels X logic: player has to figure out how colors react/appear before solving the challenge (there is an exploration phase) 01 mai 2024: **APL::interactive functions: require focus (==move screenPov) where user input is awaited or where function bombed (==suspended execution with an error) [⍞]/[⎕] operators: ⍞: raw text input ⎕: evaluated input "When the ⍞ function executes, it causes the computer to pause and "listen" while the user types on the keyboard." [[4]] * [⎕]{user types: "+ 2"} = [[6]] !Break! command to escape from current execution 06 mai 2024: ***[structure][duality]PokeSlotOperator: [+ 2](held) * [[6]] = [+ 2](held), [[8]] DropPokeSlotOperator: drop operator over object to transform object ***another workflow for sleeping-arg ops: 0. pick dyadic operator [+] (PokeSlotOperator) 1. poke an object (it will become the ⍺ argument of the operator) example: [+] * [[2]] = [+ 2] => now you have a monadic operator (TouchSlotOperator) 2. pick an object and have it being touched by operator: [[4]] * [+ 2] = [[6]] (3. decompose monadic operator to turn it back to dyadic operator !decompose!([+ 2]) = [+], [[2]] **edu: notation: priorités opératoires: au lieu de noter "+", noter " + " pour que la priorité de la multiplication devant l'addition devienne évidente exemple: 3 + 4x2 + 7 c'est simple mais ça fait le boulot (et comme ça, on arrête de se prendre la tête avec une _notation_) (*edu: notation: utiliser ⍵ au lieu de 𝑥 *edu: more challenges for each operator create interesting challenges, even for the -'simple'- + operator these challenges should be interesting, even for 'full-grown' human adults ***keep-in-hand execution mode: when user has object touched by pathmade, ghost1 is being held and ghost2 is being transformed while function executes, ghost1(held) * [op] ==> [op] is enqueued (it is displayed at bottom right of ghost1) release(ghost1) ==> the 2 ghosts reunite in the pathmade when function execution is done, the 2 ghosts reunite and object is back to a fresh(==transformable) state **import python code and translate it into objects/operators/pathmade... **[protect] X array: protected element will ignore operation example: [[a b c d e]] * [ [[4]] over [protect] ] = [[a b c (d) e]] [[a b c (d) e]] * [toUpper] = [[A B C d E]] 07 avril 2024: **ultra easy: pathmade creation: 1. spawn pathmade stub => [pathmade_X123] is created (you may rename it) 2. click on pathmade stub => enter pathmade drawing mode (==no need to keep pathmade drawing key down) 3. draw as many curves as you like you may create 'repeat(n)' by clicking on a number before drawing a curve to specify how many times you want this curve to be repeated you may create 'sub blocks' by clicking on [{] before drawing, and [}] after drawing (for example to create: repeat(5){A repeat(2){B C} D}) 4. click on pathmade stub => leave pathmade drawing mode (5. do 2.3.4. again if you want to rewrite pathmade **challenge: draw pathmades corresponding to a given instruction sequence 12 avril 2024: **challenge: gm X prime numbers: with 4 and 7 you can make 1 (Bezout), so with [+ 4] and [- 7] you can make anything it may be long sometimes, but if you use quick loops, it's ok layout: initial: [[3]] ops: [+ n] [+ n'] [+ m] [+ m'] etc. (cherry-picked so that the solution is necessarily the co-prime loop solution) [loop] (pathmade mode toggle button) target: [[16]] edu: the student 1. must find 2 coprime numbers 2. must create a loop which is equivalent to doing [+ 1] (or [- 1]) 3. must create another loop, which makes use of the [+ 1]-loop, to reach target number **heat engine -like program (manipulate the gist of the heat engine, i.e. cycle synchronization) **[structure][edu]"learning speed": in a challenge-based teaching environment, student can choose (and change anytime) the bandwidth at which new concepts are introduced a student may want things to go slow sometimes (because it's too hard or just because it's enjoyable) the same student may want things to go fast other times (because it's too easy for them) ***edu: sliceable banknotes: by cutting a 30€$ bill in half, you get two 15€$ bills (originating from a 30€$ bill) typical usecase: fractions each note type has a special color lower bound: bill cannot be broken into bits than are smaller than ... in length, in area, in €$ challenge: sliceable banknotes: layout: initial: [[30€$]] [[5€$]] [[5€$]] [[1€$]] ops: [slice in 2] [slice in 3] [slice in 4] [slice in 5] target: Tony wants [[21€$]], Tony only accepts 30€$-bill bits Laura wants [[17,5€$]], Laura accepts all bill bits challenge: sliceable banknotes with slicing machine: this time there are no slicing operators but a slicing machine with rulers in centimeters, or in relative size (|0---------0.5---------1|) edu: "propose une graduation que l'état imprimerait sur les billets pour faciliter leur découpe" **[keyboard]keyboard key (combination) trigger the command for their related operator **[keyboard]easy: assign command: drop command on keyboard key to assign it to combination visual keyboard keys are divided into sectors, each corresponding to a combination each key will have vanilla sector shift sector shift-alt sector etc. **[keyboard]easy: !visual_keyboard! displays visual_keyboard on screen (with opacity:0.5 for example) to help user locate the symbol they want typical usecase: locate the APL-symbol you want keyboard key "[,]" may be used for array creation ***gm:challenge: "blindfold labyrinth": once object is in labyrinth, it cannot be controlled. Enqueue pathmade conveyors (user-drawn or already created) so that object gets through labyrinth. edu: translation et enchaînement de transformations layout: left side: pathmade conveyor enqueueing right side: labyrinth at start of labyrinth, there is a [*] (== [apply]) operator, to start pathmade sequence labyrinth may be curvy because player can draw curvy pathmade conveyors synchronization challenge: labyrinth may contain pathmade operators which are played concurrently with the enqueued ones example: [up up up](enqueued) + [down down down](just met) will result in [nop nop nop] **gm:challenge: "translating leash": same as blindfold labyrinth but object can still be moved by mouse ***The Super Ruler: With this tool, student can measure the "true length" of anything on screen but they will have to agree on a certain lower bound for precision, otherwise, they will keep on zooming infinitely edu: "Comment être sûr que l'on a bien placé l'origine à gauche ?" On va peut-être frustrer les élèves avec cette activité qui montre que rien ne peut être mesuré absolument avec cette technique, que ce sera toujours par rapport à une certaine précision ***(*)[structure]challenge: compute-it (GM Edition): player becomes the interpreter player has to follow the instructions that they are given challenge area resets when player does a wrong move layout: left side: gm challenge area | right side: instructions list | | edu: passer du texte au symboles edu: l'avantage, c'est qu'_a priori_, il n'y a pas d'initiative de la part du joueur edu: on peut aussi se servir de ce système pour donner la solution d'un exercice à un élève mais sous une forme qu'il doit tout de même exécuter (il reste un peu actif) **giant poke operator: easily perform operation on a lot of objects for example a big [+ 2] poke operator to add 2 to all objects "blobbed" by it variant: screenPov-poke (very close to screenPov-restricted command invocation) ***[edu]'scale' animations for add,sub,multiply,divide: with addition: [[x]] * [+ 2] ==> [[x + 0.1]] ==> ... [[x + 1.3]] ==> ... ==> [[x + 2]] animation of stepping from a "+ 0" state to a "+ 2" state with multiplication: [[5]] * [× 7.4] ==> [[5×1.2]] ==> ... [[5×3.23]] ==> ... ==> [[5×7.4]] animation of stepping from a "× 1" state to a "× 7.4" state 15 avril 2024: **3dRoom::solid store: extract solid figures (3D) by pulling them out of a 2D screen displaying them in 2D (perspective or set of projections) these solid figures may be used to build staircases to reach new areas to complete 3D puzzles (3D puzzles display the missing bits with opacity: 0.4) **practical operators: touchSlot behavior when static, pokeSlot behavior when held **(*)3dRoom::3DPov to 2Dvania / 2Dvania to 3DPov 3DPov roaming player may enter a 2D world by "diving" into 2D character when close enough to 2D surface then player moves, as in a 2D platformer, or in a 2D projective world (as in JPRGs) this makes 2D player move on the 2D surface consequence: when going back to 3D, this may result in player having moved 2 levels up, or 3 levels down, or on the left etc. a HUD indicator displays when 2D->3D "stepping out of the 2D surface" is available 21 mai 2024: **(*)edu: scale1/scale2/scale3 drawing game: draw a castle, draw a princess, draw a necklace then draw a village, draw a goblin, draw an earring drawing instructions are displayed in the HUD layer by giving coordinates of points of segments the display of the coordinates in the grid is dynamic (screenPov-dependent) edu: faire comprendre l'utilité des nombres décimaux dans le repérage à différentes échelles **easy: programming: icObj__op.apply() 28 mai 2024: [meta]autosimplify::all challenges may be "variated" by removing autosimplification when using an operator [meta]autosimplify::random activation of simplification: sometimes it autosimplifies, and sometimes it does not edu: improve student's self-confidence [meta]autosimplify::cyclical activation of simplication: when the light is green, it autosimplifies. When the light is purple, it does not autosimplify. typical usecase: timed challenges: cycle starts with purple (==autosimplify:off) to reward mental processing edu: une béquille toujours à disposition de l'élève s'il attend un peu 03 septembre 2024: **GM x pathmade: pathmade should prevent gm from dying gm should be holdable at end of pathmade *(**)mathroid: gm as platformer [+] beam **[structure]gm::multi-end level their are 2 legitimate targets **loading bar for transformation: [[obj]] * [op] ==> [====----------] ==> [[obj']] (([[obj]] * [op])) ***activable poke operator: like applicable op but for poke => colorBrush poke operator teacher could colorize some objects to explain better **conditional access challenge area: gm can enter only if condition is met [>2 ] [ [- 10] [- 5] ] [ ] **(*)conditional pathmade drawing: when "if" is a 2-color well workflow: 1. spawn [if] pathmade well 2. drag and draw [true] pathmade by starting clicking on [if] 3. drag and draw [true] pathmade by starting clicking on [if] ***reverse pathmade: say you have a rich pathmade like []--[+ 2]--[x 3]--->, then you could put the reverse operator, namely <---[- 2]---[/ 3]--[] over it to create an animation loop: forward-reverse-forward-reverse input obj could be a number [[5]], a symbol [[x]] or an equation [[x=5]] ***easy: numberTyping("grid 5 6") should spawn a grid with 5 rows and 6 columns 08 septembre 2024: ***dualFace object: loop: show face1 for 2 seconds, then show face2 for 2 seconds symbol: [[obj1///obj2]] typical usecase: instead of displaying an equality, show lhs in face1 then flip to rhs in face2 then flip to lhs in face1 etc. [[eq.lhs///eq.rhs]] [[obj1///obj2]] * [op] = [[obj1'///obj2']] ( [[obj1]] * [op] = [[obj1']] [[obj2]] * [op] = [[obj2']] ) ***[conform ]: dualFace maker workflow: 1. prepare with obj1 [[obj1]] over [conform] = [conform [[obj1]] ] 2. create dualFace object [[obj2///obj1]] [[obj2]] * [conform [[obj1]] ] = [obj2///obj1] **(*)eduAtelier: solve simple equation by creating inverse operators layout: a forwards transformation chain is displayed: it is a pathmade operator with +-x/ operators in it, ending by a conformingZone containing a value [[x]] []---->---[+ 2] --->----[x 3]---->---[- 10]--->---[conform [[29]] ] there is a [inverse operator] that students can use to create inverse of [+ 2], [x 3], and [- 10] ([+ 2], [x 3], and [- 10] on pathmade are actually wells) there is an empty backwards pathmade, below the forwards pathmade <----------------------------------------------[] workflow: 1. student picks [[x]] and makes it go through the pathmade => output is a dualFace object object.face1 is [[3(x+2)-10]] object.face2 is [[29]] 2. student creates the inverse operators and puts them on the backwards pathmade 3. student puts the conformed dualFace object on the backwards pathmade to get the initial value of x in face2 of dualFace [[3(x+2)-10///29]] * [pathmade__backwards] = [[x///11]] 14 septembre 2024: **(*)gm::challenge from reduced(expr) to x ("deshabillage débrouille") This will encouraging students to use distributed mult or div **(*)obj= "gm_step__blackboard": before new gm step starts, what was on blackboard is destroyed (or put somewhere else) typical usecase: when analyzing a challenge with a student, one may write stuff on this blackboard, then when target is reached, it autoclears **gm::challenge: 2-target (x and ?) simple equation solving challenge layout: panel[[expr = value]] <-- displays the equation currently being solved operators_top initials targets [[expr]] [[safety zone where]] [[x]] [[value]] [[transformed expr and value]] [[?]] [[can be put together]] operators_bottom workflow: for student not to miss a step, they alternatively must transform expr then value 15 septembre 2024: **maths needs a symbol for symbol, so that we could formulate assumptions as "if list(A,B,C) is not proportionnal to list(D,E,F) then A/B [[symbol1]] C/D [[symbol2]] E/F with != in set([[symbol1]],[[symbol2]]) notation: doubleZ: which would appear a bit like this ⌇ A/B ⌇_1 C/D ⌇_2 E/F ***mariage d'opérateurs: les fractions et les relatifs marry([+ 2], [- 5]) = [+ (2-5)] = [+ (-3)] marry([x 7], [/ 4]) = [x (7/4)] = [x frac{7}{4}] **gm:challenge: only marry-generated ops are enabled layout: [/ 4] [/ 7] (all operators are disabled) initial: [[marrying zone]] target: [[4]] [[ ]] [[7]] operators: [x 4] [x 7] (all operators are disabled) workflow: 1. student brings [/ 4] in marrying zone 2. student brings [x 7] in marrying zone, over [/ 4] => operator [x frac{7}{4}] is created and is enabled 3. student uses this enabled op to reach target: [[4]] * [x frac{7}{4}] = [[7]] 28 octobre 2024: **blueprint refiner::challenge graph: display targets graph and allow user to disqualify some **blueprint refiner::targets table: ⌈display a table with all targets and their probability of appearance **[structure]exhaustive challenge completion: indicate how much of the diversity of the challenge has been completed so far **hot edition of target: teacher can edit target typical usecase: use a target that is not contained in the challenge graph (reach something deeper) ***(*)transformation cast: a cast is a static way of representing the act of operating on an object the cast.output is dynamically related to cast.input so that cast.input * ... always equals cast.output workflow: 1. enter castDraw mode 2. start castDrawing on [[obj1]] => [[obj1]] stays in place a clone of [[obj1]] is now under cursor a thin line is used to display the path 3. go through [op1] [[obj1]] * [op1] = [[obj2]] => [[obj2]] is now under cursor 4. end castDrawing at desired location => a cast is drawn: an thin arrow from obj1 to obj2, via [op1] typical usecases: draw by hand a challenge graph display the challenge graph with different challenge.initial by using numberScroll on challenge.initial display the convergence/divergence when using a function repeatedly display the behavior of a function by using numberScroll on cast.input (cast.input, cast.output) may be linked to a function graphing coordSystem **!refresh! command (applies to the refreshable situation which is active in screenPov) **[print] operator: typical usecase: allow student to check if they are right when they mentally track the value of a (storage) variable when it's a numerical expression which undergoes transformations whose effects are not displayed to the user when it's an array which undergoes transformations whose effects are not displayed to the user workflow: initial: [[a]] is [[6]] [[a]] * [x 2] = [[2a]] (numerical value is no longer displayed) [[2a]] * [print] = [[2a]] and "12" showfades on screen 30 octobre 2024: **B for board: spawn platform using KeyB **(*)operator pyramid: to touch op2 contained in op1, you have to touch op1... pyramid may be contained in pyramids, etc. example1: pyramid([+ 3 [x 2] ]) [[10]] * [+ 3 [ ] ] = [[13]] [+ 3 [[13]] * [x 2] ] = [[26]] example2: pyramid([+ 3 [x 2] pyramid([+ 5 [/ 3] ]) ]) variant: operator concentric grommets: same as pyramid but leaving op2 triggers op1 again (op2 is not contained in op1) **gm:challenge: pyramid operators typical usecase: make student use inverse operators to neutralize 'outer' operators the pyramid topology must be taken into account when compositing operators to create challenge example: with pyramid([+ 3 [x 2] ]) we have access to [+ 3] and ["[+ 3]then[x 2]"] **binary operator pyramid: same principle, but any operator may be binary ****blueprint::distributed !apply!: a composite containing multiple applicable operators can be promoted to an applicable operator so it will trigger all of its children applicable operators typical usecase: from a composite with generators to a composite with generated (==from a blueprint to an instance of it) ***easy: composition of composites: no surprises ! alt is for alteration (alters nearest rootObject) shift.alt is for deep alteration (alters object directly under cursor) **negativeEdgeTouchSlot: negativeEdgeTouchSlot activates when object _leaves_ touchSlot (== stops touching negativeEdgeTouchSlot) symbol: ]op[ **operator decoration via operator pyramid: ]opDecorationAfter [opDecorationBefore [opOriginal] ] [ typical usecase: convert;transform;deconvert 31 octobre 2024: **stamping [[2]] on binary operator [+] yields unary op [+ 2] **? stamping [[2]] [[3]] on binary operator [+] yields [[5]] ? **icObj.type="sticker": same idea as "freeDraw:adhesive(==sticky) joining" and "freeDraw: single-sided tape adhesive" but for icRect and non-drawn objects **right after completing a challenge like ne1_numexp_writing_add_mult, ask for the numerical value of the numerical expression this companion challenge is displayed on the right side of the main challenge 01 novembre 2024: (**)TH::advertising: ad people may put ads here and there: ads will have stronger impact because of player's "TH focus" ça détruira toute la beauté du jeu de piste mais de toute façon, tôt ou tard, quelqu'un aura l'idée 04 novembre 2024: **challenge:drawing: target is a drawn surface and user has to draw a copy of it there is a completion percentage which is displayed there is a tolerance level (so that challenge may be easy, normal or hard) **vDraw: using generator: instead of drawing with an object, user can "longPress-apply" a generator of this object **icObj.type = "spawner_platform": onApply: poops a copy of the object that was on its terrace (or a copy of its terrace if there were 2+ objects on it) **icObj.isEntity: to ease cloning, copy, platforming, etc. : manipulate and refer to "big" objects **[touchable_next__time(s)]: this operator may have the ability to touch untouchable objects [[4 (.isTouchable==false)]] * [touchable_next_2_time(s)] = [[4 (.isTouchable==true)]] [[4 (.isTouchable==true)]] * [+ 2] = [[6 (.isTouchable==true)]] [[6 (.isTouchable==true)]] * [x 10] = [[60 (.isTouchable==false)]] [[60 (.isTouchable==false)]] *\ [+ 3] **easy: Shift.N (keyUp): create generator from selected objects: if there is more than 1 object, create random variable with the selected set ***ultraeasy: stampers may be used to add behavior easily to an object typical usecase: add [kill] button, add [well], ... stamp a curse on an object 05 novembre 2024: ***biplatform/n-platform: composite with n platforms on it typical usecase: create [[biplatform: + [[2]] [[5]] ]] to display structure of operation biplatform is a composite content: (a [+] or a "+" or anything you want) parts: platformL (or platform0) platformR (or platform1) **biplatform/n-platform: equation (or more generally: relation) typical usecase: display transitivity of equation biplatform may have a dynamic engine which checks if "platformL equals platformR", and, if "platformL equals platformR" then display an "=" sign between the two sides else display an "≠" sign between the two sides example: [[biplatform: = [[6-1]] [[biplatform: = [[2+3]] [[5]] ]] ]] ***structuring operators: transformation output is a structure (which may contain input) typical usecase 1: create tree diagram (FR: arbre de calcul) without the hassle of having to release/hold/release/hold etc. typical usecase 2: create complex objects, with a tree structure, without the hassle of having to release/hold/release/hold etc. symbol: [🁑 op] example: [[2]] * [🁑 .. + 5] ⭬ [[biplatform: + [[2]] [[5]] ]] [[biplatform: + [[2]] [[5]] ]] * [🁑 3 x ..] ⭬ [[biplatform: x [[3]] [[biplatform: + [[2]] [[5]] ]] ]] [[biplatform: x [[3]] [[biplatform: + [[2]] [[5]] ]] ]] * [eval] ⭬ [[21]] example2: [[2]] * [🁑 .. + 5 + 4] ⭬ [[3-platform: + [[2]] [[5]] [[4]] ]] example3: [[2]] * [🁑 opposite] ⭬ [[1-platform: - [[2]] ]] ***structuring operators: auto flatten: when structuring operations are compatible with flattening, output (n+m)-platform without growing depth [[biplatform: + [[2]] [[5]] .autoFlatten: true]] * [🁑 .. + 5] ⭬ [[3-platform: + [[2]] [[5]] [[5]] .autoFlatten: true]] **(*)infinite tree structures of well-known numbers: display Pi and e as infinite sums, etc. infinite depth is achieved using dynamic computation and display wrt zoom level this would also allow the displaying of siblings of well-known numbers: numbers with different numerators in the infinite sum of fracs, yet converging **biplatform/n-platform: if-else/switch: see "conditionally-activating conductive platform" dump d'idées diverses: *neveremptiness: when zooming in an "empty" area, something is generated so that zooming in makes something appear variant: hot and cold: generated neveremptiness message tells TH player if they are near or far from the next step *[structure]challenge: black operators: operators are displayed but their effect is unknown, player has to try them to see how they work, and memorize which is which *[structure]stacks: object promoted to platform can be used to create stacks as in card games stackScroll: circular permutation of 'cards' in stack challenge: stack-based challenge: unary operator transforms top card binary operator transforms top 2 cards ***embedded operators: click and drag from this button to make use of operator which input is its container typical usecase: embedded operators won't bloat the ui, if you need something based on objectA, then zoom inside objectA and check if there's something that suits your needs this is a good way to set "meta" properties of an object (.isTouchable, .isMovable, etc.) examples: embedded [pick random] in [[1 2 3 4 5]] will yield a random element of that set embedded [well] in [+ 2] will yield a fresh [+ 2] embedded [unstick] in object on a platform will allow unsticking the object without touching KeyAlt for alteration **C is for Core: keyup KeyC to spawn a core **eraser X adhere X alteration: erasable surface **[structure]: mirror symmetry: challenge is displayed in mirror, [+ 3] becomes [Ƹ +] **challenge: counting challenge: player has to count the number of objects on screen and build a result number variant: with fractional numbers variant: with +1 -1 numbers ***(*)freeDraw: bigPen: composite(penTip, penPlatform) with penPlatform containing pen configuration (color, shape_of_tip, etc.) hold it and use !apply! to draw example: you want to change color ? pick red icRect on config platform and put it away, then put a yellow icRect on config platform remark: bigPen can actually be microPen if you embed config platform inside penTip (so that screen is not bloated by config platform) ***replace tool: a bigPen with a biplatform containing obj__before and obj__after typical usecase: batch change on complex structures (structure is conserved) workflow: when drawing, if penTip touches an object which is obj__before, it will be replaced by obj__after example: math: replace symbolNode(x) with constantNode(4) in a tree structure and then [eval] 06 novembre 2024: **ephemeral operator: operator only affects the visual display of input object, for a very short period of time typical usecase: display filtered values (given a certain condition) in a collection by animating them, but leave the collection unchanged (it's just a peek) 07 novembre 2024: **icObj.type = "apparition": neveremptiness::apparition This object appears as a ghost, somewhere (not overlapping any 'true' content). When ghost has disappeared (say, via zooming out), zooming-in won't make it appear again : it will appear somewhere else (god knows where). 08 novembre 2024: **icObj.type = "ghostFlashLight": increases currently-on-screen ghost ghost's bounds (ghostDistances povInside and povOutside) typical usecase: allow player to play the game with a reduced difficulty level: ghost are easier to detect ghostFlashLight.revealingPower allows a spectrum from "shitty flashlight" (ghosts are a bit more visible) to "ghosts don't exist" (ghosts are always with opacity:1.0) ghostRevealer is ghostFlashLight with .revealingPower:1.0 ***icObj.type = "zNumber": change number value by zScrolling it, value is set using a zNumberContext zNumberContext may contain a zNumberOrigin and a zNumberUnit, or a zNumberBoundary min and a zNumberBoundary max typical usecase: tune object's params by zScrolling edu: big is big, small is small dev: standard use of zNumber will rely on implicit context, built using container iC's global variables "les gens normaux ne se posent pas toutes ces questions" *rotation: R.Numpad0: get back to original rotation angle (0°) **memex: tag X transportation: transport(icObj.myTag) transports to a generated place where all items tagged are gathered **neveremptiness::neveremptiness floodFill: inside this floodFilled area, neveremptiness is as told by floodFill => there is an infinity of possible neveremptinesses, and user can floodFill using any of them **neveremptiness::effective emptiness: when zoomed-out too much, screen is considered empty though it's theoretically non-empty, neveremptiness messages can appear because it's 'effectively' empty => neveremptiness messages can appear 'behind' screenPov: if user continues zooming out, then neveremptiness message appears ***neveremptiness::wayfinder: get back to a 'content zone' when zoomed-out too much neveremptiness messages spawn so that when (repeatedly) zooming in them, user gets to a 'content zone' if there are many 'content zones' deep inside screenPov, there is a neveremptiness message for each of them => zooming out will make more and more wayfinder directions available to follow in remark: wayfinder message could be anything examples: the name of the content zone/a name for the content zone a visual thumbnail of the content zone a colored rect with the background color of the content zone a gotopov button bringing you to content area a clone of an object in content area, which you can use transportation on **!wayfinder! command: force wayfinder messages to spawn on screen **icObj.isWayfindable: an object with .isWayfindable:false won't have a wayfinder message leading to it (it's like privacy) (game: game like gta2 (top down view) of entire planet 11 novembre 2024: **neveremptiness::nevercompleteness: when zoomed-in enough in an object (static object), so that entire screen is filled with the same color, a nevercompleteness message may appear it's the neveremptiness concept but now applied to any object rather than solely applied to iC pov is declared "complete" when it's displaying a monotonous part of an object (so it's like a monochrome for example) message may be displayed using complementary color (so that it's visible) **neveremptiness::fresh pov: when neveremptiness triggers, an associated pov is created and is not deleted when going away **neveremptiness::?should held object break neveremptiness or not? **neveremptiness::scenery: a scenery is a rect that is filled with neveremptiness(es) it may contain an infinite number of different neveremptinesses **[structure]neveremptiness::scenery's inner neveremptiness is portal to next scenery, scenery's outer neveremptiness is portal to previous scenery remark: there may be many nexts this allows navigating in graph structures examples: linear sequence of sceneries: scenery_i.next == scenery_iPlus1 (which could cycle (scenery_N.next == scenery_0)) binary tree this could be a way of navigating in a dictionary (or an encyclopedia) etc. remark: in a non-hierchical structure, _for the same scenery_, what is experienced as a "previous" scenery in one particular navigation path could be experienced as a "next" scenery in a different navigation path """Perceval : Ces conneries de gauche et de droite ! Ça veut rien dire ces machins ! Selon comme on est tourné ça change tout !""" **[structure]neveremptiness::navigation: Le Petit Poucet's pebbles: user may 'pebble' a scenery to indicate that it's meaningful to them so that zooming-out == moving to previous scenery directly brings to the last pebbled scenery, skipping the intermediate sceneries, etc. !pebble! command is thus used to achieve that !pebble! spawns a pebble object in the current scenery 13 novembre 2024: **[structure](nevercompleteness::)overlooked objects: overlooked objects are disregarded when zoomed too much in them (==when screenPov's trueArea is a lot smaller than their trueArea) there are not considered displayed on screen when they are overlooked **scale-aware touchSlot: canTouch == false if incomingObj.homeScale is too different from touchSlot.homeScale **scale-aware touchSlot X pyramid operators: [+ 10] becomes [+ 10 [+ 10,0] [+ 10,1] [+ 10,2] [+ 10,3] [+ 10,4] [+ 10,5] [+ 10,6] [+ 10,7] [+ 10,8] [+ 10,9] ] or even better: [+ 10] becomes [+ 10 [+ 9,5] [+ 9,6] [+ 9,7] [+ 9,8] [+ 9,9] [+ 10,0] [+ 10,1] [+ 10,2] [+ 10,3] [+ 10,4] ] typical usecase: roughly vs precisely: target may be "[[10,36]] (roughly)" or "[[9,98]] (precisely)" 14 novembre 2024: **neverborderness **nevercornerness **floodFill: industrial-clone fill: clone as many X as needed to cover Y flavors: overfill (==Y is at least covered entirely) underfill (==Y is at most covered entirely) **frameSpawn: F while held: spawn rect with same size as held object if holding composite: spawn composite of rects each with same size as child ***freeDrawing::"transparently opaque" brush: painting over (or adhering to) semi-transparent stroke does not result in a color addition, it's rather a continuation of previous stroke **(*)copy/paste::manage sources when pasting: display modal (inner, outer, voire inner1, inner2, outer1, outer2, ...) typical usecase: use AUI with another tool shortcut: Ctrl.V.V.V.V.V (à la Alt.TAB.TAB.TAB.TAB.TAB) ***copy/paste::manage sources when pasting: (inner, outer, ...): ioPasteScroll shortcut: CTRL.V(then keep held) + scroll (*)copy/paste::copyScroll typical usecase: select a particular portion of a composite or a scenery shortcut: CTRL.C(then keep held) + scroll **[principle](à la Stuart Card) cardinal scroll: if I have a set with a "small" cardinality, scrolling though it is a good way to interact with it ***copy/paste::batch paste: batchPasteScroll shortcut: CTRL.B(then keep held) + scroll: select number of clones by scrolling ***easy: freeDrawing::selection: selection is "all objects intersected by freeDrawing" typical usecase: select part of a complex freeDrawing without selecting all variant: strictly-inside: selection is all objects fully inside freeDrawing remark: strictly-inside freeDrawing selection seems more useful *!flip! command: mirror symmetry F.H: flip horizontally F.V: flip vertically *icObj.type == "dropZone": can drop images from other tabs or from operating system via dnd (see "heliport" above) 15 novembre 2024: **blockOperator: create block instruction sequence (à la Scratch) and use the whole block blob as a touch op typical usecase: from aui to Scratch's ui **[easy]numberSlicing: slicing a number with a freeDrawn stroke results in n numbers, with a fair share typical usecase: teaching: a natural approach to distributivity 2 flavors: rational slicing: the n numbers are the closest rational numbers wrt the slicing real slicing: the n numbers are the closest real numbers wrt the slicing example: slice([[5]] 'on top') ⭬ [[1]], [[4]] 17 novembre 2024: **icObj.type = "areaDog" beware of the dog: as user zooms in (in the area watched by the dog), the dog object gets closer to screenPov (as to intercept screenPov), until 'user has been caught' and something happens flavors: automobile dog: as soon as screenPov is close enough to dog's area, dog will move _at its own pace_ to reach screenPov dog will continue to track screenPov until screenPov is far enough from dog's area superhotdog: dog gets closer or moves away relatively to screenPov getting closer or away from dog's area zooming-out makes the dog go back to its home position proportionally to the 'distance' made out of the dog's area **neveremptiness::neverunwholesomeness: zooming in an individual part of a scenery triggers its neverunwholesomeness behavior this can be interpreted as the neveremptiness of a faraway container ***bottom-up content: a usually "small" content may be allowed to display at a bigger scale typical usecase: coordsSystem axes typical usecase2: narrative context of TH the "expanded" display may be temporary (timeout), or permanent, or may be "minimized" (folded back to its small form) by user remark: there may be more than one bottom-up content expanded at the same time bottom-up content may bounce animate when expanding **icObj.type = "panGhost": ghost wrt screenPov.center 18 novembre 2024: **maskScroll: like opacityScroll but changes obj in range: full mask(==monoChrome) <-----> full object(==usually polyChrome) **(*)color::apply: C.mouseRightUp (i.e: color + !apply!) 20 novembre 2024: **apply::freeDrawingApply: .mouseRightUp + move mouse like for a freeDrawing: command is applied to any new encountered object while freeDrawing typical usecase 1: freeDrawingApply(setColor) typical usecase 2: freeDrawingApply(setValue) typical usecase 3: freeDrawingApply(vitrify) typical usecase 4: freeDrawingApply(setIsInvisibleToUser) (in editor mode, to hide the nitty gritty from user) it's as if brush tip was a [] poke operator **icObj.type == "background": this object is only used for its being at the back it may be considered empty when checking the emptiness of the screen it may be used as a good container for neveremptiness **apply::screenApply: .KeySpace: apply command to all objects on screen the apply is a smart apply (to say it a bit too simply : system determines "if it's a map or reduce") typical usecase 1: create composite with all objects on screen typical usecase 2: screenApply(setColor) 21 novembre 2024: **game: the 16 squares game: Pictionary with 16 monochrome-colored squares are on the screen (with .zIndex from 1 to 16). Player can zScroll the squares. variant: Player may use colorPicker and colorApply on squares but not colorScroll : beware of not painting everything with bg color. faire passer le temps discrètement **frames::keyframe container (KFC) **frames::frameScroll: F.mouseWheel frameScroll on a non-KFC object promotes it to a keyframe container and moves to desired frame mouseWheelUp moves to next frame: original object is on frame 1 and active frame is frame 2 (this frame inits with frame 1's content) mouseWheelUp moves to previous frame: original object is on frame 2 and active frame is frame 1 (this frame inits with frame 2's content) **frames::frameScroll: Shift.F.mouseWheel: insert frame **frames::operators: non mutative: [next_frame], [previous_frame], [first_frame], [last_frame] mutative: [swap_with_next]/[swap_with_previous]: swaps two frames [insert_next]/[insert_previous] **bigStamper: stamper X frames: like the big pen but from stamping typical usecase: quickly navigate in a collection of sprites and quickly create a visual display for a story **img operator: to square monochrome-colored ("pixel") rect grid **(*)dicey object (composite.cType = "dicey")/diceyEngine: this object may display different features each time it "appears" on screen this composite object contains at least one random generator (or at least one KFC) each time object will appear on screen, the diceyEngine refreshes the object using the random generators typical usecase: math: create display-based random variables typical usecase 2: fun: create kinda-lively (kinda-bizarre) objects remark: if two different clients' povs (for example: me on my pc, and you on yours, both of us in my iC) look simultaneously at the same dicey object, the object is very likely to appear differently on each screen variant: dicey but not too much: "quantum dicey": two different clients' povs will see the same display if they look at the object simultaneously **(*)flavoring object("fais comme chez toi"): this object infiltrates its entire container hierarchy and flavors it as it wishes (i.e. mutates stuff here and there) typical usecase: visualize a neighrborhood of an object (flavoring object is coloring the other objects) it is a complex and versatile object since there are many different ways to flavor: infiltration _span_ and _effect_ 2 flavors: permanent: objects which have encountered this object keep the mutations induced by the object temporary(default): removing the flavoring object from the container brings everything back to its original state (==how it was before the arrival of the flavoring object) variant: perfuming object: objects which will endure mutation don't have to be in the hierarchy, they just have to be in the vicinity of the perfuming object (à la Blood Bowl's "Disturbing Presence") 24 novembre 2024: **(**)hierarchy-aware operation: while nodeC (child of nodeB) is the active selection, operating on nodeC updates tree with nodeC__new typical usecase: math: perform "unnatural(/illegal)" operations on an expression tree [[3 + 4x2 (with 4 as active selection)]] * [+ 5] ⭬ [[3 + (4+5)x2]] teacher (to students): "what will you operate on ?" **platformScroll: update number of platforms on an n-platform (same principle as combScroll to increase or reduce the number of pen tips) 25 novembre 2024: **touchSlot::transformationOutput.type = "wrapped" 3 flavors: wrapped_to_new: touched object is wrapped in a composite that was not in iC before the touch typical usecase: promote item to something more complex example: [[E]] * [◽A] = [[ E A ]] [C B] [[ C B ]] wrapped_to_existing: touched object is wrapped in a composite that was in iC before the touch typical usecase: add items to an existing collection (touchSlot enables the transfer) wrapped_to_mixed: wrapped to new and to existing remark: "sandwich wrapping": icObj_incoming is now a part of a bigger composite and the content of a composite which has parts [[7]] * [sandwich_wrap] = [[composite([[3]], composite(content: [[7]], parts: [[2]], [[11]]))]] 26 novembre 2024: ***touchSlot::[wrap]: complex wrapping: decompose incoming composite and recompose it differently typical usecase: unleashed creativity example: aztec monuments [[A B]] [[A B]] [ 1 2] [[ 1 2 ]] [[ H ]] * [complex_wrap: ] = [[ H ]] [[C D]] [ 3 4] [[ 3 4 ]] remark: [[C D]] some parts may be lost in the process **neveremptiness::navigation::confirmation timeout: if user does not want to leave current page, user simply has to zoom out/in back to the area they were coming from **neveremptiness::navigation::holding magic: user continues with the object they were holding after crossing page-reload portal typical usecase: -"j'ai apporté une bouteille" (-"oh, fallait pas", etc.) typical usecase2: -"j'ai apporté un petit jeu" (-"oh, tiens, bah on va l'essayer", etc.) typical usecase3: -"j'ai apporté mes outils" (-"ah, bah ça tombe bien", etc.) remark: on a le droit de rêver **neveremptiness::navigation::"going back" may display different destinations default destination is the one over which mouse pointer is user can choose to "go back" to another destination by putting mouse cursor over it (and waiting for completion timeout to complete) 29 novembre 2024: *(**)bootstrapping "imageLib": when user saves mini scenery(=="image") with a title, it is then invocable via textConstructor() or speechConstructor(<title>) typical usecase: quick creation of more complex sceneries (which themselves could be added to imageLib, etc.), comic book creation, ... **easy: "ZFreeDrawing is z-railway"/zRailwayScroll: while ZFreeDrawing is non-branching ("just one spike") and if cursor is on zFreeDrawing, zRailwayScroll will happen along the freeDrawing this would ease finding the right iC.scale before starting a freeDrawingAdhered branch screenPov is kept as is (like when using transportation) and is "zTranslated" along the path shortcut: Z.mouseWheel there could even be a transient object to show where we are progressWise: like a zscrollIndicator on a zscrollBar **icObj.type = "operative platform": when such a platform is put on an object, the platform's "value" is (obj__support * platform.op) typical usecase: create multiple variations of an object simply by putting a grid of operative platforms on it (après, tu fais ton marché) typical usecase2: preview the effect of an operation **challenge: value_platforms: stack platforms to create target object: a [[10]] value_platform has initial value [[10]] and [+ 10] op edu: travailler les opérations différemment example: put [[10]] over [[30 ]] results in [[30 [[40]] ]] target is a pyramid: [[30 [[40]] [[50 [[80]] ]] [[32]] ]] 2 flavors: free positionning of platforms: only the structure is important, not the perfect positionning of the components slotted platforms: the structure and the positionning is important (more difficult challenges could be made with this constraint) **easy: handle::easy_handle: easy handled object automatically applies hovered object layout (.homeScale, .zIndex, etc.), and recovers its original layout when unhovering typical usecase: put something on a platform remark: it's just another handling mode since standard handle should not be lost because users may sometimes want to perform complex stuff with complex .zIndex'd structures *gm:challenge: write(5(y+2)-7) with different startups starting from y: y [+ 2] [x 5] [- 7] starting from 5: 5 [x (y+2)] [- 7] etc. variant: monomania with colors write(5(5+5)-5) ((5blue(5green+5red)-5orange)) **biPlatform/n-platform::triPlatform for if, n-platform for switch 3 flavors: triPlatform([condition], icObj_out__when_true, icObj_out__when_false) (the good old ?: ternary operator) triPlatform([condition], [op__when_true], [op__when_false]) (an operator version of ?: ternary operator) triPlatform([condition], path_to_follow__when_true, path_to_follow__when_true) (a real flow-control if operator) same principles for switch with an n-platform 01 décembre 2024: ***(*):Spawn 3DRoom in iC (à la "iC in iC") typical usecase: "where am i ?" 02 décembre 2024: **easy: cropping: colorPicker(background) results in brush is now cropBrush typical usecase: create holes to put content in, or neveremptiness 03 décembre 2024: *composite::promote composite part to composite.content or even to composite.handle **portal::abstract portal: portal.out is not really the destination of the portal but portal.out contains info for abstract location that system can bring user to typical usecase: reload page with different query vars or open another webpage user configures abstract portal via textFields **portal::platform-based portal: portal.out depends on what user has put on portal's platform example: find-this platform-based portal: put X on portal and portal will lead you to the first instance of X that it finds on iC **portal::abstract platform-based portal: user configures abstract portal via a platform typical usecase: build your website easily **easy:portal::multiIn-portal: clone portal.in and put it where you want: it will bring to portal.out typical usecase: "Tous les chemins mènent à Rome". **apply::freeDrawingApply:textApply (==freeDrawingApply(setText)) typical usecase: user no longer has to enter textField in editMode and paste text: user can simply textApply on textField **apply::freeDrawingApply::gun magazine (==list-based apply): first apply() uses list_params[0] then second apply() uses list_params[1], etc. typical usecase: load content as list and sow pieces of content here and there (to build your website easily) 04 décembre 2024: **(**)[technical]screenSlots and areaSlots to off all engines that do not matter and allow practical infiniteness space is partitionned either manually or automatically (based on where content is put) **!variablize!: promote object to icVariable (==createComposite(icText__name("<name_of_variable (maybe guessed)>"), obj)) typical usecase: ease configuration and inter-object communication 05 décembre 2024: **composite::composite injection: using a 2 step interaction like "CTRL-C CTRL-V", inject icObj__incoming into icComposite__target typical usecase: configure an object without using a platform **icObj.type = "hardGhost" a hardGhost is something that can only be stared at, _only if you have been brought to_, or else it vanishes (any innerMove will lead to its vanishing) typical usecase: games variant: expelling hardGhost: any innerMove (pan or zoom or whatever) leads to being brought to hardGhost.rect__expelled **typeWise clipboard: clipboard is not a single stack but many stacks (one for each type (color, text, img, etc.)) typical usecase: use textApply and colorApply and imageApply and <X>Apply etc. without having to prepare clipboard each time 06 décembre 2024: **portal::halfPortal_in/halfPortal_out: couple(==link) a halfPortal_in with a halfPortal_out to get a fully fledged portal **[structure]portal::halfOut-halfIn objects: these objects have been decorated with a halfPortal_out(to be used as a landing) and a halfPortal_in(to be used as a takeoff) typical usecase: easily create portal ways between sceneries workflow1: 0. create your scenery and decorate it so it's now halfOut-halfIn 1. create a halfPortal_in, put it where you like and couple it with obj.landing 2. create a halfPortal_out, put it where you like and couple it with obj.takeoff workflow2: 0. create halfOut-halfIn scenery1 and halfOut-halfIn scenery2 1. couple(scenery1.halfPortal_in, scenery2.halfPortal_out) shortcut: Space.I, Space.O ***[structure]portal::constructorPortal: user gives innerUrl to func__create and portal finds an unused space to call func__create typical usecase: load challenges without refreshing page actually, any valid object could be used to feed constructorPortal including: a loaded file code typed in an editorObject inside iC innerUrl (targetting hardcoded function) flavors: jitConstructorPortal: scenery to create is only done when user crosses portal_in eagerConstructorPortal: scenery to create is done as soon as user enters a valid constructionObject in constructorPortal's configuration object remark: there could be a system with a func__destroy to clean space when leaving ***[structure]portal::editorPortal: constructorPortal but after portal crossing, content can be edited, _and is saved on leaving_ typical usecase: create dedicated spaces remark: empty constructor is used to "create new file" 07 décembre 2024: **[structure]icObj.type = "cage": zone with ceiling and pan walls, a big landing (near ceiling) and a small takeoff inside the cage (to leave it) typical usecase: create a zone with a bounded zoom-out scale *zBilliards: a billiard will balls of very different sizes: some 10^(-5) times smaller than the big ones ? est-ce que ça ferait apparaître des choses ? *screenStamp is like "screen is a platform which sticks on its back" on en vient de plus en plus à l'idée que l'écran est un objet comme un autre ***zPixel/zPixelBrush: painting at zoomLevelX(==quantified zoomScale) creates square pixels with homeScale=zoomLevelX typical usecase: like paint.net but with infinite zoom remark: this would give birth to zPixelArt 08 décembre 2024: **zoomSlot: object touched by a zoomSlot will be automatically zScrolled so that its homeScale is now zoomSlot.homeScale typical usecase: zTroidVania screenPov may or may not follow (any position or homeScale or rotation transformation on object may or may not be followed by screen) 10 décembre 2024: **zPixel::zPixelStepEasing: zPixelImage__a has zLevel__a, zPixelImage__b has (zLevel__a + 1): use diffusion so that the "zPixel gets smaller" step is eased typical usecase: make zPixel zoom-in/zoom-out look "continuous" remark: Fourier transform may be used in order to seam all the frequencies (apparent zPixel size, zPixel color, contrast, luminosity, ...) a__pure, a__seam, b__seam, b__pure also: system could indicate when it's too difficult to do the seam (==seam will be unsastisfying) given two juxtaposed zPixelImages dev: il y a du gratin *(?)zPixelPathmade: pathmade X zPixel (meteo: moving meteo icons transition from meteo.morning to meteo.afternoon (lien entre le symbolique et le réel) **[structure]zTopography: how stuff is arranged, zWise **[magic]zPixelBrush::zPixelHop: hop from one zPixelCoordsSystem to another typical usecase: start painting on zPixelImage1 and continue painting on zPixelImage2(with a completely different zPixelCoordsSystem) 11 décembre 2024: **freeDrawing::doubleBrush: zPencilBrush X zPixelBrush ***zPixelBrush::zPixelPatternBrush: instead of drawing a square, draw something in replacement (carrots, stars, dots, ...) typical usecase: zPixelComplexPatternBrush: draw "snake arrow" for computer science challenges (with a complex pattern: start/oriented arrows/end) 12 décembre 2024: ***(*)[serialization]"zExtensions" for images: .zPng .zJpg, .z<your_extension>: lightweight formats which support zPixels the formats may contain the number base(s) used for zLevels **(*)[serialization] "zExtensions" for anything: .zXslx .zMp3, .z<your_extension>: lightweight formats which support zPixels **[structure]: parallel zImages/zDocuments: though they don't contain the same info, they are referring to the same info, and using the same zLayout typical usecase: zDocument1 is full of exercises, zDocument2 is the answer keys for the exercises (we superimpose zDocument2 over zDocument1) **easy: ZImage: load_zImage_here(): use zPixel under cursor as zPixel__origin for loaded zImage shortcut: 2.I (2 is to enter zPixelFreeDrawing mode (so that zPixel preview appears under cursor)) **zPixelMove: (==move X zPixel): workflow: 1. hold an object 2. enter zPixelFreeDrawing mode 3. move object: it moves so as to have top left corner at cursor's zPixel top left corner **zPixelZScroll: (==zScroll X zPixel): workflow: 1. hold an object 2. enter zPixelFreeDrawing mode 3. zScroll object: it zScrolls to match the nearest zPixel matching its size (...or something like that, so that it works fine) **navigation::wayfinder X zPixel: glowing tiles: a path is indicated by a matrioshka sequence of glowing zPixels glowing is oscillating and glowing of a zPixel stops when user is close enough to it (so next glowing zPixel becomes visible, etc.) **zPixel::zPixelPicker: pick sub zPixels inside zPixelCursor flavors: select only zLevel+1 pixels: extrapolate zLevel+1 zPixels if they don't exist (extrapolate from deeper zLevels) select all zPixels inside typical usecase: remark: le "tampon de clonage" de paint.net peut avoir lui aussi sa "variante zPixel" **zPixel::zPixelSelection: select zPixels inside zPixelRect typical usecase: zImage editing typical usecase2: use sprite sheet as a side library and have fun with it :) remark: actually, (maybe one day), one could build zPaint.net by doing paint.net X zPixel 13 décembre 2024: **zPixel::zPixelCirculatorySystem: streets, avenues, highways, air corridor, space corridor, etc. context: screen or held object collides with walls screen or held object can grow only if it's inside something bigger, up to the point when it touches the boundaries again related: "the fractal nature of moving" **zPixel::coords-labeled zPixel: there is a label on the zPixel with "zLevel:..., ix: ..., iy: ..." **edu: zPixelPuzzle: coords-labeled zPixelOrigin is displayed and locked, "target coords"-labeled zPixels are scrambled here and there, player has to put them in their target position difficulty: easy: on hover, each "zPixel slot" on screen displays its zPixelCoords medium: as user zooms in or out, zLevel of zPixelCursor (but not ix, nor iy) is displayed and refreshed in HUD hard: the only hint is the coords-labeled zPixelOrigin (player may create its own zPixel markers here and there to ease the solving) remark: some parts may be missing (to avoid relying too much on the matching with other parts), but when done, the complete image appears remark2: on pourrait en fabriquer physiquement (et même avec des coupes jigsaw) (ça pourrait faire un puzzle où les adultes et les petits enfants pourraient jouer en même temps 15 décembre 2024: **easy: freeDrawing:: atomic continuation: sometimes user has to freeDrawingPan but they don't want 2 freeDrawing objects to be created, so there is a way to resume where they left last location of brushDown brushTip is displayed, so user can resume its "atomic" freeDrawing from here 18 décembre 2024: **(*)image::image promotion: user selects a rect of zPixels and says "this, is an now image" remark: since an image becomes kind of a selection, the same zPixel can be part of different images typical usecase 1: get those images in .png format in infinishute.shu to use in other software typical usecase 2: when image is moved from its birth rect, zPixels are copied and cropped etc. so that it becomes kind of a deep copy (as opposed to a shallow selection) **edu: gm:challenge: mathNode X zPixelImage => zPixelNumber: number is count of non-transparent zPixels in zPixelImage typical usecase 1: teach orders or magnitude typical usecase 2: teach the formula for the area of a rectangle using zPixels eases display of big numbers: the adequate zPixelRect (i.e. the adequate zLevel) will be used to contain the zPixelImage **edu: gm:challenge: zPixelMultiNumber: x is count of red zPixels, y is count of yellow pixels, etc. constant part is number of grey pixels typical usecase 1: teach distributive operations typical usecase 2: teach equations solving differently **(*)[structure]coloredRect-based selection: selection output depends on the color of the selection rect typical usecase 1: select only text objects in selection rect (when selectionRect.color is blue for example) typical usecase 2: select only objects with color == selectionRect.color there may be all kinds of variants of this idea, because there are lots and lots of ways to filter objects 19 décembre 2024: grand dump (des notes dans mon téléphone) { nt("+ (-5)") zBD, zCartoon zSeamBrush ZPixel Puzzle : differnenr shapes zWise Filter: zpixelseamIn , ZPixelseamout (zPixel)ImageEditing: sélect image then zpixelFreedraw inside to édit its pixels Ultra easy: doubleObjectFreedrawing: what is drawn at scaleX is what will be displayed at scaleX and below Edu : gm:challenge : [[x]] * [f] -> [[f(x)]], target is [[g(f(x))]] ZPixel::zColor : displayed color is différent for each dZlevel (screenPov wrt ZPixel) Select ZPixel matrioshka sequence, !toZColor! Then colorPicker then (ZPixel)Freedrawing We can create tunnels this way (as in lands of lore) Convenience: !toZColor__ghostColor! (Which is an opacity gradient or a double opaxity gradient (in and out)) Same data but different origin: when saving a zsvg, save also the zPixelOrigin, so that loading is done at thé right place AnimatedZPixel: keyframe-based for example Select ZPixel séquence then !toAnimatedZpixel! Then color picker then (ZPixel)freeDrawing Cuisine fractale : enrober(enrober(...enrober(petite poudre)...)) ZPixelGhost : (ou lod pour les sachants) freeDrawing: stroke then rect then stroke then rect etc. (2 then 2.3 then 2 then 2.3 ...) Ttpical usecase : create path + povRects in one "élan" Fentes d'young X scale down provoqué par l'energie du photon (déformation locale de l'espace qui l'environne) Fractal qrcode SelextionDepthSxroll Assoxiate perspective with object : when editing objectX, its associated perspective guides appear 'Vous regardez pas, attendez que j'ai terminé': in a party, other players simply have to zoom out, or zoomin elsewhere not to see what active player is doing ZBD: une bulle au niveau N, la réponse au niveau n+1 etc ZPixel::perspective zPIxelZSegments guides Zpixel::color spiral: bleu blanc rouge finit par donner qqchose de rose violet. Bleu bleu blue blue blue ... Blanc blnav nblav blanc blanc labfz ... ZPixel::antialias2xBrush: when brush passes over a zPixel area, each zPixel is split into 4 sub-zPixels ZPixel::transition to 2x: 3 deviennent 4 (1ere couronne) puis 6 deviennent 9 (on est arrivé à 2x) ZPixelFractal: ZPixel is actually getPerceivedColor(innerZPixels) etc. Gm: loadChallengeInTrueRect(trueRect, challengeInnerUrl) (find some free space and do not refresh page) + add outrance over challenge area ScreenSlot : screenSlot.func__onEnter() screenSlot.func__onKeep() screenSlot.func__onLeave() 3dRoom in ic: 3dRoom as a link between the rectoCanvas and thé versoCanvas Freedrawing while zRailwayScroll : the two drawings share a common trait: their zness Decoration (context) operator : example : all [+ 2] are now [platformOp: + 2] neveremptiness_operator : same as biplatform operator but sets something in the neveremptiness Labyrinth operator using pictures à la Lands of Lore repeat::!apply!(5) curse : next time object is touched, the touched is applied 5 times Macrop: incoming-wise operators : create wrapper only if necessary (comme des sortes de projecteurs) template operators : wrapper is put inside ***in-template operators : operators inside template apply to incoming Operator pipeing : freeDrawPipe ((Text is thé best conveyor of metadata That's why it's fractal : it's also mainly about itself !screenBloat!: interfill screen area with rects of random color : this makes an area more 'unique' Cycles (composites) Classe VS Instance : représenter une classe dans l'IC ... Struct vs classe vs instance Operator : [to class] "[classify]" BioCrop/bioSplit: move cropping mask on image to create composite (split_out,mask,split_in) : when mask is moved out, image is restored So it is actually composite(s_in,m,s_out,bioCache:img_src) Gm challenge::mandatory first, mandatory last, etc. (Typical use case: around équations) Embodiment : zoom-in impersonation to become it Impersonation is granted particular rights Rôle : hud has opérators and objects relatéd to impersonated role GroupSelection : different types of groups Family: all for one: when family.x is touched by op, all family members are touched too (like a burial) 'Diabolic group', heteroup : opposite of family : non-family FlatScroll: scrolls contents of eminent object but without zooming (tourne les pages d'un pdf par exemple) Neveremptiness : probing pebble: this object 'falls' into sceneries and crosses portals, ... It may trace its path SpeedOp : operator résult dépends on speed of touched object ([+ .speed] [x . speed]) like a tunable operator but with 'sense of speed' => screenSpeedOp vs trueSpeedOp Same concept with accelOp, angleOp, ..., rulerOp ( value is the one touched between value_left and value_right) Antifont : freedrawing is generated from text, it is almost impossible to reverse thé algorithm Star system : point to indicate content area Dotted Yield: yield by définition Vidéos de solutions de problème ou d'interactions objet/opérateur pour petit à petit comprendre le truc Multiplayer::hide & seek: Opérateurs en pyramides : pour utiliser op2 contenu dans op1, il faut passer par op1... On peut aussi imaginer [op1 [op2 [op4] ] [op3] ] etc. Blueprint::multigen : !apply! on a composite containing multiple generators distributes !apply! on each of them, and replaces their being part with their generated 1Animation de step (1 seconde pour remettre la table) (remarque de JM Laborde) Malediction : black jack: gm breaks if >21 (Marked(3) + spécial(7) )*7+3 = doubly marked 73 Play/resume (global play/ global resume) (locam play...) Log<n> binary op Group continuous Sieve of eratosthenes : op X store (step to next element of store), division euclidienne par 1 ... Aui X Withering rooms : Shrine memory way (memorize operators, colors,...) Dual mouse : right mouse draws while left mouse pans (couteau / fourchette) La notation superposée : écrire un programme en superposant les éléments (touchHooks for exemple, or sleeping args...) : input programs may be drawn images Free draw transparent stroke, Press color key to draw color, user may press multiple color keys. This would result In différent color strokes Or In addition of colors Color keys palette is régistered in 1-9 read in edit mode Operation as expression : [[4]] * [+ 2] = [[ [[4]] * [+ 2] ]] [[ [[4]] * [+ 2] ]] * [exécute] = [[6]] AUI :: Turing machine game porting ZMetroid on icText game story is floor : player walks and jumps on icText } grand dump dump (de quelques notes manuscrites) { *view::graph: display objects as graph nodes (comme dans l'article sur Zigzag, ce genre de graphe) *l'ascensceur: un zTraveling animé (il y a un point de fuite) *compatible chutes: when the "cones" two chutes intersect one another without chute objects intersecting themselves ("ça s'imbrique bien") *iC X Glitch:: Slowmo X zoomScroll: zoomScroll gets slower and slower (i.e. zooms in with less and less efficiency), so user zooms out and surprise ! zooming out is efficient ! so it's repulsive for user to zoom in } dump **easy:zPixelSelection::quality selection: zPixelImage__punched will have zPixels according to zPixelSelection typical usecase 1: get blurry faces easily typical usecase 2: get "nice, pixelated, big" zPixels to transition with upper zLevel typical usecase 3: get "plank" of same color, small zPixels to transition with lower zLevel (those small zPixels may be colored later) 20 décembre 2024: **(*)zPixelSeamRectBrush/zPixelSeamRect: the zPixel sewing machine to say it simply: it's zDithering workflow: 0. say we have 2 zImages with (zImageLeft.zLevel == zImageRight.zLevel + 1) 1. like a zip on trousers, user selects a rect for the seam to happen 2. in this rect, zPixels are a bit shuffled: some zPixels of zImageLeft go on the right side and their zLevel becomes zImageRight.zLevel some zPixels of zImageRight go on the left side and their zLevel becomes zImageLevel.zLevel => this is like a blur but with zLevel taken into account there may also be zPixels which change side without changing zLevel (so that the transition is smoother) ***pov::keyDown pov: pov has an associated keyboard key which, on keyDown, triggers a gotoPov and on keyUp brings screenPov back to where it was typical usecase 1: easy access to operator pools (because held object follows gotoPov back and forth) typical usecase 2: easy access to well pools 22 décembre 2024: idée bizarre: (**zPixelBrush::code-painting innerPaint zPixelBrush: when brush paints over an object, it updates object's _render() function by injecting a specific _renderZPixel() for the painted zPixel context: object's _render() func is primarily a loop over the individual zPixels _renderZPixel() funcs typical usecase: when brush.color is decorator3(decorator2(decorator1(good old color))) (i.e. color has become something really sophisticated) ***easy: workspace deployment: import res folder: all hierarchy is imported, items are smartly layouted, folder hierarchy is respected typical usecase: before starting to work on a zPixel scenery, user creates a folder where they put all they need, and then they import it, and now, it's time to create! ***zPixel:!stamp(zPixelImage)!: because the purpose of the zPixel is to contain other zPixels, fill them with zPixelImages typical usecase: square tiling (because square tiles fit perfectly in a zPixel) (but it could be generalized to other shapes) workflow: 1. select zPixelImage 2. enter zPixelImage stamp mode (this is (like) a brush) 3. when brush paints in a zPixel, a clone of zPixelImage is created in this zPixel **zPixel::!zPixelify!/zPixelification workflow: typical usecase: pixel art resources are fine, but there is so much more on the web to be pixelized workflow: 1. screen capture (in OS) 2. paste in iC (in browser) 3. !zPixelify!: image with a lot of zPixels is transformed into a lightweight image with a few big zPixels workflow: 1. zPixelRectSelection 2. zImage__original is destroyed and what's left is its pixelized version ***[structure]roots and branches ("des feuilles et des racines"): zooming in allows exploring different branches, zooming out should allow exploring different roots typical usecase 1: z-based games typical usecase 2: build "two-way tree hierarchies" (enfin ce genre de structure bizarre si une branche d'arbre pouvait être une racine d'un autre arbre) example of implementation: if user has keyDown(arrow_left) while zooming out at a "root branching pov", root__left is what they'll see if user has keyDown(arrow_up) while zooming out at this "root branching pov", root__up is what they'll see remark: fondamentalement, pour le graphiste, ça reste la même chose: dessiner des tunnels (==des tubes), mais là il faut dessiner des variantes de "conteneur" pour un même contenu 23 décembre 2024: ***zVoxel: zPixel X 3DRoom: comme un minecraft mais avec des cubes de taille différentes (avec quantification) **zVoxel: zPixel X zVoxel: si un espace zVoxel est accessible depuis un iC, pouvoir traverser avec un objet en zPixel pour ensuite le travailler en zVoxel **easy:(zPixel)freeDrawing: "beyind"(== behind and beyond) drawing mode: object user wants to draw beyind is now a "ghost_in"(when zooming very close to it, its opacity fades to zero wrt to zoom) the freeDrawing is kept behind the ghost typical usecase: draw the insides of a house **[structure]start/end imageDrawing: create image (be it in raster or in vector) once user says they're done with it typical usecase: have a nice image in infinishute/res/img instead of a collection of strokes 25 décembre 2024: ***(*)easy: zPixel: auto object: in a sprite sheet where elements are separated by transparent pixels: auto select+clone pixels of object under cursor when click and dragging typical usecase: use sprite sheets without the hassle of selecting pixels variant: smart auto object: auto object in a sprite sheet where elements are not separated by transparent pixels 26 décembre 2024: **easy: (zPixel) custom font/custom font typing mode: typical usecase 1: create "zPixel strings" typical usecase 2: create zPixel sceneries (a street with a sequence of different houses for example) workflow: 0. select an object which you want to assign to KeyA as a font 1. enter key assign mode 2. type KeyA 3. leave key assign mode => in custom font typing mode, when you press KeyA, the associated font object will spawn and "typing cursor" will offset, awaiting for next character **easy: (zPixel) auto font: system automatically assigns the correct key to each custom font object typical usecase: use font sprite sheets 31 décembre 2024: **(*)freeDrawing::drawingMode: fun: a drawingMode which changes brush at each atomic step dev: for the sake of dev *(**)imageFormat with (r,g,b,a,zIndex) for each pixel typical usecase: draw a cup of coffee in which you can dip stuff "realistically" 05 janvier 2025: **iC X p2p::only send relevant changes if 2 employees work on very distant parts of iC, they receive nothing because they are not concerned with the other's changes because each client holds a state of the screenPov of the other clients and only send changes when it's relevant (?**iC X p2p::central backup server: the central backup server is observing any change (==of any other client) a company could use a central backup server to save the work done by all the employees the employees would work using p2p but this server would centralize all the changes as they go along 06 janvier 2025: **zPixelZLevelScroll: determine zPixelZLevel by scrolling typical usecase: flatten zPixel images example: flatten zPixel images workflow: 1. select zPixelImages 2. keyDown() 3. scroll to change the zPixelZLevel of output: the corresponding output (preview) is displayed 4. keyUp() => output is the flattened image with desired zPixelZLevel (no surprise) dump { ****zPixelPaint anything (entrances, operators, etc.) when such a drawingMode is on, what has previously been painted (using it) is displayed (so that user sees what has been painted and what has not) Partition fractale avec des fréquences 'subtonales' (entre 2 lignes, on peut mettre des lignes) ('Innerlay': same concept as overlay but 'inside' ***ux: ZoomOutBrakes/zoomInBrakes: zoomOut is kinda quantified: there are particular scales (typical exemple : thé scale at which a scenery fills screenPov entirely) at which the zoomout is slowed down typical usecase : allow user to go back and forth from zoomed zoneA to dezoomed zoneB (for exemple pick image drop image pick image drop image etc.) operateOnSelected__splitIntoPuzzle icObject.isZpixelObject : zpixelObject has zPixelZscroll, zPixelMove, etc. by default *save::export selected image as png typical usecase: after flattening some (z)images, export it as png to be used in another software **(*)clone::clone_charge: next time click and drag will clone what was clicked on typical usecase: clone an object without the risk of moving it when selecting it **F1 for help: 2 flavors: the help is there: spawn the help in the current iC easier: flip to help: help is a dedicated iC and user can flip to it ***(*): tab-like iC: F1 is for canvas "help", F2 is for canvas 1, F3 is for canvas 2, etc. typical usecase 1: parallel canvases example 1: programmadraw something in canvas 1 and run it in canvas 2 example 2: create sprite animation in F2,F3,F4,F5 canvases and play it by pianokeying F2,F3,F4,F5 example 3: architecture: water pipes in F2, electricity in F3, etc. typical usecase 2: canvas in canvas typical usecase 3: p2p: switch to clientX's iC **game:Tetris-based z-puzzle: comme les jeux de qi où il faut trouver comment ranger les pièces ***zPixelPhoto: a zPixelPhoto (taken using a cellphone) is a smartly-created composite of photos at different focal lengths there is a relationship between zPixelZLevel and zIndex: what is distant has a deeper zPixelZLevel than what is close typical usecase 1: a zPixelPhoto (taken using a cellphone) could be examined in an iC (which color was the eye of the bird on the branch of the distant tree?) typical usecase 2: different zPixelPhotos (taken using a cellphone) would be easily mergeable in an iC z(pixel)Artists: a revival for scrapbooking (un peu comme les fleuristes qui font des bouquets personnalisés) **zPixel::'z-compatible' tilings triangles, hexagons, and more sophisticated tilings (any tiling which, at some point (eventually deep), _"contains itself"_) } dump **image::punch hole flatten: B becomes flatten(part_of_A, B), and A becomes rest_of_A **zPixel::zPixelScale: scale output conforms to the zPixelGrid **zPixel::zPixelZoom: zoomin/zoomout is quantified: only zPixelZLevels are valid zoomLevels typical usecase: spawn non-zPixel objects at a "canonical" zoomLevel (== spawn them with a canonical homeScale) 07 janvier 2025: ***[structure]zIndex::"delicate" zIndex: zIndexScroll's screment should be f(iC.scale, arr_zIndex__objects_near) zIndex is a decimal number of arbitrary precision so that zIndex is a the same time an absolute property and a relative property (it is zOrder-compatible (we can consider it coarsely and precisely)) this would allow arranging objects in a scenery without caring about "background"'s zIndex *(*)zoom::telescopic: any object can only be zoomed up to a maximum zoom. At that point, smaller objects continue to be zoomed in, up to the max zoom, etc. typical usecase: folder management in a zOS: the "zoom hierarchy" is the folder hierarchy 08 janvier 2025: (*homeScale is the "linear part" of scale (**[game]with easy user-friendly grid generators, and iCpeers, some people could play board games by quickly spawning the game material and using smart visibility areas typical usecase: bootstrap a codenames game, or a codenames variant some objects (or collection of objects (via composite)) will be visible only to some of the players the generators (and labels and drawings...) could then be saved to play directly, some time later 09 janvier 2025: **composite::!addPart!: you have an object that you want to add to an existing composite typical usecase: you create a scenery that you want to create variations of, by cloning it multiple times and, in each variation, by moving some parts typical usecase 2: you want to partition a scenery into different scenery parts (which will be composites), to reuse these scenery parts elsewhere a scenery part which characters, a scenery part with furniture, etc. workflow: 1. select the object you want to add 2. invoke !addPart! 3. select composite handle => object is now a part of the composite ***halfPortal_out::named halfPortal_out (==named landing): typical usecase: use landing name label as an abstract color for "zPixelPaint anything" workflow: 1. create a scenery 2. create a pov which will be used as a landing 3. create an icText("link: my awesome scenery") and use it on coreified pov => when user will "abstractColorPick" the icText, _the abstract color that will painted with is an halfPortal_in_ leading to this halfPortal_out ****easy: zPixelPaint anything:: abstract color is link typical usecase: create links to a sub scenery in a blink workflow: 0. create a main scenery, create a sub scenery elsewhere with a named halfPortal_out 1. in the sub scenery, abstractColorPick the link (i.e. the halfPortal_out name label) 2. in the main scenery, zPixelPaint the abstract color where you want the halfPortal_in to be => the painted zPixelImage is an abstract zPixelImage: it is an halfPortal_in leading to the sub scenery's landing pov (==halfPortal_out) 10 janvier 2025: **(*)colorScroll:: group colorScroll: color is not a single color, it's an array or a generator (there could be very sophisticated behavior). typical usecase: change color of each group element in a blink (like group.getObjects().forEach((elt) => elt.color = ...)) workflow: 0. setup color to be an array or a generator color will be smart enough to determine the best sorting algorithm for the coloring (i.e. sort using zIndex ? sort from left to right ? etc.) 1. select group (==> "activeSelection") 2. colorScroll => each group element will have its mapped color remark: if color is a single color, all elements will be colored with the same color 14 janvier 2025: **brush::chameleon brush: brush's color is the color of what it paints on typical usecase: TH: easily create hidden messages 16 janvier 2025: **zPixel: zPixelMove(icPoint) is interesting (discovered by chance) typical usecase: math: show what is a point: you zoom in and you never get it, but you can still locate it (mentally) (move it on each corner of a zPixelRect) ****picture event: as photos are taken by people at a meeting, photos are displayed in iC and the photographers (and other people) are allowed to arrange them dynamically typical usecase: some people are more into the sharing and reporting of an event rather than living it fully (they live "fully" it that way) examples: weddings, concerts, etc. 17 janvier 2025: **freeDrawing: drawingMode is a living thing: typical usecase 1: drawingMode gets older as time goes by: the drawingSessions colors are less and less vivid typical usecase 2: talk to your drawingMode while in a drawingSession to refine the results dynamically **freeDrawing: "freeDrawingZScroll X color gradient" can be achieved by dynamically setting colors of drawing bouts while in a drawingSession 18 janvier 2025: **[art]"image d'une transformation": brush is comb_with_a_little_spacing(brush__freeDrawing, brush__zPixelFreeDrawing) typical usecase: paint images which represent our times, made of vector strokes (good old "painters" times) and pixel strokes (the digital world) 20 janvier 2025: (**game: codenames X jigsaw puzzle: a guesser team not only has to guess its team's words but also has to be the first to guess what's represented on the the underlying jigsaw puzzle on its turn, a guessing team can either guess a word, or guess the underlying when a word is found, it's replaced by the corresponding "background"'s puzzle piece **portal:_ZPixel_ abstract color link portal: easier zoning: less precise but who cares Social network full transparency: see the graph of people you like/dislike in order to reach the outsides of your usual echo chamber DrawingMode__unitLength : each bout has a length which is 1 unit at max, each bout has a different color for explicit 'counting' Typical use case: math: perimeter and curve length 21 janvier 2025: **(*)freeDrawing: cursed drawingMode: the curse updates the drawingMode config (as freeDrawingXScrolls do) typical usecase: drawingMode's homeScale changes randomly, at random times: this may create some special effect (maybe some more realism) ***(*)easy zPixelFlatten: a way to work with very different zPixelZLevels workflow: 1. keydown : enter flatten mode 2. select rect 3. zoom until the preview zPixel is at the desired zPixelZLevel 4. keyup : leave flatten mode => the flatten process now starts with the chosen zPixelZLevel *(*)edu:numeral bases: any-size wrapper: In base n, When grouping n squares (black) close enough, a super square blue that wraps them is created The key is that the size of the wrapping square does not have to be n times the size of a wrapped square (it's only representations) **freeDrawing: cosmetic: a cosmetic drawing does not last, it's built _not to last_ flavors: screenPov-aware cosmetic: cosmetic destroys itself when screenPov changes time-wearing cosmetic: cosmetic fades away with time remark: time-wearing cosmetic with slow wearing could be used as a draft: refined drawing would be drawn "over" it ("over" in quotes because cosmetic could be "in front" of refined drawing) 22 janvier 2022: **edu: zPixel is a good way to teach what is precision: (1, precision:more or less 1) is a big zPixel, (1, precision:more or less 2^-10) is a very small zPixel 23 janvier 2023: **game: RolePlayingGame: (same as childs making stories with Playmobil) GameMaster controls visibility of objects, for exemple GM can fade-in a monster using opacity scroll Players can cast spells and animate them using time-wearing cosmetic freeDrawings and GM can hold the monster and shake it as if it were touched by a fireball for example **gm: [+][-][×][÷] at top left corner : these are operators that operate on the challenge area: when [+] is touched, all operators become [+1] [+2] etc. One could create mathador with such operators **[structure]Corkscrew arrow: to indicate halfPortal_in (zoom in) or halfPortal_out (zoom out) **zPixel: always preview zPixel even when not in drawingMode 25 janvier 2025: **(*)freeDrawing: session's zPixelCoordsSystem: like adhere, when entering drawing session with cursor over a zPixel object: use this zPixel coords system for the session **rotateScroll: control rotation angle with mouseWheel **adhere: velcro adhere/ magnet adhere : obj1 will adhere on obj2 if dropped on obj2 and if obj1.magnet intersects obj2.magnet ***icCamera: zindexScroll using Keydown(Z) and Z.space to reset **icCamera: switch camera: ic.switcthToCam(cam__2) **icCamera: icCamera X icPeer: grab otherUser's cam and move it and zScroll it, etc. to where you want to show them something ***zPixel: import/export minishute: minishute is an infinishute but enclosed in a rect. Import minishute goes the same way as import image minishute is exported via zPixel selection but without a lower bound for the zpixelZLevel **icCamera: cameraify(icObj): create a camera which is "the eyes of the icObj" typical usecase 1: tell immersive stories by adopting the pov of characters the immersion is reinforced by the fact that the resulting camera has zIndex:icObj__character.zIndex-epsilon so we only see the things that the character can see (character does not see the things with a greater zIndex than theirs) moving the camera will also move the camera's wrapped obj (typical usecase 2: check what employees are working on dev: cameraify(icObj) {createCameraForIcObj(); createComposite(camera__icObj, icObj);}, then: ic.switchToCam(composite.camera__icObj); ****icObj.type = "icUse": the vehicle that a user can hop in: icUse = icCamera + own HUD + own tools (==own key-mappings, own behaviors) typical usecase: a icUse for each specific use of the software examples: icUse__drawing icUse__gameX icUse__editor icUse__reader icUse__boundedArea icUse__localization__french icUse__localization__spanish icUse__localization__trump (icUse__bloatHUDWithAds (icUse__premium shortcuts: U.click to enter the icUse under cursor keyUp(U) to enter the icUse in active selection 27 janvier 2025: ****icCamera: cameraScroll: similar to povScroll but the camera will be left where user left it typical usecase: work in areaA, work in areaB, work in areaA held object should, of course, "follow the move" ****icUse: useScroll: keep the same camera but change use: at last the solution to the abscence of menus (PUIs become irrelevant) typical usecase: switch from zpixel to pathmade to cosmetic to etc. topLeft corner showfades which use is now active (à la colorScroll) remark: zPixelEditor is an icUse zPixelMove, zPixelScroll, etc. should be handled by the zPixelUseEngine **icUse: upgradeTo() typical usecase: you have a friend in an icUse__reader in your iC and you want to upgrade its use to icUse__writer ****[structure]absolute vs relative: icCanvas stores absolute props, icUse sees relative(==subjective) props **(**)icUse: subjectivity: myEye: visibility of objects is relative: not everybody sees the same thing icUse.isObjectVisibleWrtMe(icObj) {} **icUse: subjectivity: myEar: sounds are relative: not everybody ears the same thing **icUse: subjectivity: my<X> **icUse: subjectivity: icUse__filter: imageFilter is applied to display **icUse: carrier: this icUse can carry other icUses (which can move freely inside the carrier bounds) typical usecase: move a team of people who draw from one site to another typical usecase 2: move a team of puzzle solvers from one site to another ?typical usecase 3: decorate the carried with icUse__carrier: they see the world with the superimposed subjectivity of icUse__carrier *zPixel: zPixelRotate: round screenRotate to nearest 90-multiple orientation this should be soft: user should still be able to rotate freely **(*)freeDrawing: change camera while in drawingSession: typical usecase: this allow drawing objects with very distant parts **(*)freeDrawing: icUse: change icUse while in drawingSession: typical usecase: this allows drawing objects with parts that have a different "culture" ***icCamera: smartZindexCamera: camera's zindex changes with what's in its rect : you zoom too much on the house and you see its insides (the house is ghosted as camera zooms in) (zIndex ghost trail) **[ux]: allow user to switchMouseLeftMouseRight easily typical usecase: convince user that using realLife rmb as computer lmb makes ux nicer keyUpABToggle(KeyF8) (choose a key that is not usually reached) **gBrush/gScroll: assign a gid to the drawn objets typical usecase: draw stuff in many drawing sessions and flatten them to a zPixelImage easily via gGrouping use gPicker to pick gid from an existing object 28 janvier 2025: ****program by doing(=="monkey programming"): workflow: 1. enter programByDoing session: (like a brush) => a dummy obj is now under cursor 2. have the dummy obj touched by operators (you can zScroll, pan etc. to reach any operator you like) 3. leave programByDoing session: an operator is created where cursor was when session was left, it will reproduce the sequence of operations that the icUse__progByDoing did on the dummy object remark: async operations may be awaited using !await! (_after_ an async operation) (why after? because it's more human) **iCcamera/icUse: Escape to go back to previous camera Shift.Escape to go forward in camera history **icCamera: multiverse camera: camera which is at "the same location" on 2 different ics (i.e. which moves "the same way" in different ics) typical usecase: create worlds with different seasons ***icCamera: camera composite: cameras will move the same way typical usecase: create variants of a scenery (without having to use multiple ics) *icCamera: camera looked by a camera: cumulative eye: what is inside inner camera's rect also suffers inner camera's transform: typical usecase: téléphone arabe, people say..., rumors inner camera has an iceye *icCamera: mask camera: create camera from zpixelImage: device screen displays something like a mask 30 janvier 2025: ***icCamera: drawingMode__screenStamp (=="cameradhere"): it's like any drawing mode but the object to adhere to is the current camera so the freeDrawing object will follow this camera's movements ***icEye: cursor forward: cursor can hold and click on objects etc., _inside_ an icEye typical usecase: use the icEye to use objects that are actually very far as if they were "there" ***icEye: icEye crossing: hold object _inside_ an icEye and have it crossing the icEye so it's now "there" to use ***icEye: icEye-crossing pathmade: one part of the pathmade is inside the icEye and another part is outside of it icEye-entering: draw a pathmade that starts _outside_ of an icEye and ending inside it icEye-leaving: draw a pathmade that starts _inside_ an icEye and ending outside of it icEye-passing: icEye-entering then icEye-leaving icEye-touring: icEye-leaving then icEye-entering 31 janvier 2025 **icUse: repulsive: other uses may always be kept out of current use's camera eye (they get back to their original place when use is escaped) **icUse: icUse description: since it won't be visible during its use, an icUse can be described on its outer frame typical use: "zPixelEditor here ----> [ ] <--- press U to enter" 01 février 2025: ***partScroll: like a frameScroll but for an individual part of a composite typical usecase: marionettes (==icTheater) this could be real fun to use example: partScroll the leg of a footBall player marionette (to simulate a kick) and make it score a goal (by moving the ball to the net) **icCamera: lock camera to moving object: camera must still be able to zoom in/out typical usecase: planet Earth (see how it moves when scale is around Earth.homeScale, otherwise: see how we don't care) 03 février 2025: **icObj.type = "brush": brush is an object that automatically binds to the cursor when entering drawing mode ***brushScroll: change brush by scrolling: typical usecase 1: easily change brush in an icUse (between 2 drawing sessions) typical usecase 2: change brush while in a drawing session (each bout will have a very different brush) **icUse: icUse's brush: an icUse-bound brush can only be used when using the icUse typical usecase: brushScroll is limited to the pool of brushes bound to this particular icUse **squatter behavior: as soon as object is fully contained in camera (in a certain zoom range), it sticks to hud until camera has left its squatter area 09 février 2025: **zScroll: smart zScroll: system comprehends which truePoint you target for the zScroll and automatically adjusts so that target truePoint is perfectly under cursor (== "snapZScroll" ) **filmstrip: put frames in an horizontal line (or vertical line) and have camera passing by all those frames to create an animation effect typical usecase: show how (old school) animation works 10 février 2025: **compass: show a compass on top right of HUD **Myopia: capture camera pixels and render them in a dedicated canvas: canvas__render typical usecase 1: pixelated display will allow seeing messages that could not be seen otherwise typical usecase 2: draw "big" zPixels more naturally **portal: oriented portal: portal only triggers if camera has a compatible orientation typical usecase: many portals can be at the same location: orientation allows choosing where to go *watermark: skew-based watermark: use ultra-slight skew as a water mark (each user has its own ultra-slight skew) 11 février 2025: **(*)grabber: single-use inverted pathmade op (like a chameleon tongue) typical usecase: think like a human workflow: 1. start at the location where you want the object to be at the end 2. freeDraw a pathmade and stop when you touch the object you want to move => (camera will follow the object being conveyed and) the object will end where you wanted it to be edu: parler de P-1MP avec un chemin aller, une transformation et le chemin retour **precisionScroll: control precision of computations via scrolling 12 février 2025: **zPixel: zPixel-adjusted cam: update cam so that zPixel is displayed as a square on screen 15 février 2025: ***game: different characters with each his own orientation,scale and skew (each character is related to an icUse) "entering" characterA changes the view so that we now have its point of view on the world => some buildings are accessible while others become too skewed, too bizarre, to get inside typical usecase 1: make kind of a different approach on top-view games like Secret of Mana, Chrono Trigger, Zelda or Pokemon typical usecase 2: make kind of a different approach on platformers like Super Mario or Metroidvanias (2D transforms are triggered by powerups / suits ) 17 février 2025: **icUse: keyUse/keyCam: when left, it goes back to its original location (and transform, etc.) typical usecase: arrows and stuff create a big surrounding of keyUse with labels like "enter use X" => extremely skewed stuff can be accessed using this use after a bit of exploration, it's easy for user to find the keyUse because it's back to where they found it the first time ***freeDrawing: context picker: <drawingModeKeyDown>.Space why ? because otherwise, there would be a conflict with adhere typical usecase: zPixelFreeDrawing: configure drawing mode with zPixelCoords (main context property), then benefit from the preview with the fresh zPixelCoords *"espace éclaté": what seems continuous in metricX is actually frequently discontinuous in metricY typical usecase: puzzle frame is a square in metricX but pieces can not be moved in metricX in metric Y, all piece slots are very far from each other, but pieces can be moved in metricY (plutôt une idée pour le zPuzzle) 20 février 2025: ***zPixelPlunge: (while holding something), make it adopt the zPixelCoords system of object under cursor typical usecase: make zPixelZScroll more natural shortcut: Space while holding something (same as freeDrawing::contextPicker) 21 février 2025: **zPixel: zPixelEraseBrush: mouseDown: create and use cropping mask with drawn zPixels mouseUp: update image by removing zPixels (i.e. color = "transparent") use contextPicker to 'select' object that will be edit:erased **zones: zone is a convex polygon **zones: zones can be displayed for debug ***(*)plunge: plunging an object in a context allows interactions of that object with the context it's plunged in typical usecase 1: plunge an icMathNode in a gm challenge: icMathNode can now be touched by challenge's ops typical usecase 2: plunge an operator in a gm challenge ***ZPixelBrush: "diplomat" zPixelBrush: zPixelCoords are updated at each cursor move typical usecase: if a zPixelFreeDrawing crosses many objects, it will "respect" each object it crosses (by adopting their zPixelCoords system) dev: break bout only when zPixelCoords system changes 24 février 2025: **freeDrawing: "free zPixelBrush" / "griddy pencilBrush" and all possible mixes starting point: free zPixelBrush: zPixelCoords used for the zPixelFreeDrawing are determined only when drawing starts grid-start pencilBrush: starting point for freeDrawing is determined using zPixelCoords => there might be an offset between brushTip and mouse cursor drawing: pixel-salted pencilBrush: at some point, a zPixel is generated along the pencilBrush's path grid-snapped pencilBrush: similar to straightLine mode but this time, a segment is generated as soon as an end point belonging to grid is close enough this is between pure pencil drawing and pure zPixel drawing ***(*)composite: time-based decompose: typical usecase: extract sub composite which has a "time coherence" in a composite which results from stacking, stacking and stacking again at different times example: extract [[ [[l]] [[o]] [[l]] ]] adhered on a surface by using the fact that [[l]], [[o]] and [[l]] were created at approximately the same moment 25 février 2025: **game: FPS: red light, green light (FR: "1,2,3 soleil") one player is redLightGreenLight: when redLightGreenLight is red, if another player is detected moving in redLightGreenLight's pov, then this player is caught what is nice here is that the motion detection is not human-based variants: redLightGreenLight must protect something redLightGreenLight has an objective redLightGreenLight becomes a crowd as more and more players are caught redLightGreenLight is invisible **portal: portal to camera/portal to icUse: entering portal triggers !use!(camera) or !use!(icUse) typical usecase: move "seamlessly" to a skewed pov typical usecase 2: use an icUse without having to type anything on the keyboard 26 février 2025: **save: save zones: so as to load them dynamically and avoid a big initial loading this is only possible online because there is cors protection when offline **(*)icTheater: change camera: spectators see active camera typical usecase: shift from day to dusk **camera: static camera: a pov is a static camera **icUse: static icUse: a static icUse is kinda like a function, it's there to do something particular typical usecase: bring an object with you when using an icUse 28 février 2025: **(**)lifeline: it's a zPath, which is automatically followed when zooming in and there is a constraint: user can't pan too far: there should always be a lifeline point at camera's homeScale displayed on screen 03 mars 2025: **miroir déformant: zPixelMap: fresh zPixel's dict_truePoint is not determined by brush but by substrate **easyLayoutMove: same as zPixelMove but using center and corners 06 mars 2025: ***freeDrawing: piercing zPixelBrush: brush will edit all zPixelImages "under" it typical usecase: "industrial" paint: paint the same logo on different substrates ***freeDrawing: "pile of papyrus": non-piercing brush will paint over all zPixelImages "under" it ; each zPixelImage with its own zPixelUnits typical usecase 2: using substrates with different zPixelUnits, free yourself from the usual pixel grid (though it's still pixel grids...) typical usecase: easily create zIndex-based puzzles remark: the "pile of papyrus" effect could be highlighted by drawing the border of each zPixelImage rect ***(*)zPixel: renderableZPixelImage: each zPixel renders on underlying substrate (this image is "abstract" and needs a substrate to be displayed) typical usecase: game **icUse: contextual button: if current icUse is icUseX then (world) button will do X **(**)icUse: contextual programming: if current icUse is icUseX then programmadraw's context will be icUseX 10 mars 2025: ***edu: challenge: "rejoins-moi à la case 107546" 1.an image is given 2.its width and height are given if they are too big 3.the way to index the cells is also given (reading-like indexing (== left to right, top to bottom) is not the only way to index) 4.when student has determined which cell to go, they zoom in and they check if their guess is correct edu: this is also a way for students to realize that many many pixels are in an high-res image 11 mars 2025: *madness: xWards object::fromZoomX: object only appears when zooming a particular way it's different from a ghost because once object is on screen, it won't vanish like a ghost when zooming in/out xWards:in: object only appears when zooming in xWards:out: object only appears when zooming out xWards:inout: the standard display of objects (object displays when in camera's rect) (*game: crosswords using ZigZag data structure (==multimultimultiDimensional crosswords (which are usually in 2D)) **game: 2D crosswords in which every cell is a scene in which you have to find the letter you want to activate 12 mars 2025: *(**)zAscii art:extract pixels to utf-8 black/white squares example of output: ■□□□□■■■■□■□□□□■■■■ ■□□□□■□□■□■□□□□■■■■ ■□□□□■□□■□■□□□□■■■■ ■■■■□■■■■□■■■■□■■■■ ***(*)inner qrcode/draw your inner qrcode: an inner qrcode is a qrcode that provokes changes inside the infiniteCanvas when read by an icEye it's an archaic way to program stuff in iC what is fun is that inner qrcodes can be drawn using zPixelFreeDrawing (*qrcode grammar: """""obj1 moves_to obj2""""" could be turned into a qrcode by concatenating the atomic qrcodes of each element of the sentence 13 mars 2023: **(*)chest and key/!chestify!: if you want what's inside you have to have the associated key typical usecase 1: TH (treasure hunt) typical usecase 2: have people read a bit of the instructions before doing X (some instructions are displayed where key is first located) typical usecase 3: a bit of security (as oldschool as it may seem) workflow: 1. select obj 2. !chestify!(obj) => obj is now wrapped into a chest and key is on the side 3. pick key and put it where you want flavors: single element (standard) chest-based generator: as soon as object has been taken out of the chest, another chest is created, at the same spot, with the same content variant 1: key is recreated at its home key location variant 2: key is put anywhere in iC (comme les dragonballs) **chest::open chest: you can put anything you want in it, then, when you close it, it's locked *chest and key: singleUse/persistent *chest and key: colored key: this key can open any chest which has its color **(*)colorScroll X image: colorScroll all pixels that have the same color as the pixel below cursor 2 flavors: lossless: pixels that are being colorScrolled are marked to avoid being merged with other pixels of the image that already had the target color lossy: no care is taken to preserve original composition typical usecase: (lossless): easily create variants of characters, buildings, objects, etc. by changing colors 15 mars 2025: ***freeDrawing: zPixelBlobBrush: like the zPixelRectBrush but with any shape (the interior is filled) *whirling zone: zooming in/out in this zone makes screen rotate same principle to be applied to scale and skew **use "opacity vignette" filter to create a good transition from an image to an inner image 16 mars 2025: *flatify: vitrify + destroy all composite engines 19 mars 2025: **easy: area forbidden/forbiddingRect: to make an area forbidden, simply spawn a vitrified rect over the area you want to be forbidden typical usecase: when conditionX is fulfilled, remove forbidding rect 23 mars 2025: **oldScroll::oldScrollObject: when cursor hovers an oldScrollObject, mouseWheel results in oldScroll on this object typical usecase: allow stuff with scrollerBars inside iC (those objects also have a right to exist) ***server-based::auiCMS: the same way a user can edit an article in a CMS, a user can edit an iC in an auiCMS typical usecase: create website pages the same way as you draw images in paint the different created iCs can then be linked using portals ***easy: images from my webcam: take captures of webcam to easily get images of "real life" objects typical usecase: don't browse on the web when you have the object at hand *(*)madness: xWards object::fromSideX: object only shows when coming from sideX of screen (from top, from left, etc.) typical usecase: hide things from non-initiate *freeDrawing: safeDrawing: prevent drawing a freeDrawing(or zPixelFreeDrawing) that fully covers a renderZone that is an ancestor of an obj's renderZone 24 mars 2025: *(**)edu: gm challenge: between numer/n3 and numer/n4: bigger span initial: [[0]] ops: [+ 1] [+ 10] [+ 100] [+ 1 000] [+ 10 000] [+ 100 000] [+ 1 000 000] [+ 10 000 000] target: [[24 256 895]] remark: so that, at some point, students says "haaaaa, ok, got it" (with just [+ 1] [+ 10] [+ 100] [+ 1 000], it's not enough) remark: the same "bigger span" attitude could be applied to fixed point numbers like 2.451, or even other challenges *(**)edu: challenge: symmetry X zPixel: create the symmetrical of [[ scene with (zLevel__max - zLevel__min) >= 6 ]] image should be colorful so that student can't force smaller object to be the copy of original scene smaller object because otherwise it will be blatant that something is wrong remark: it may take some work to find the right size for the scenes (shouldn't be too big, shouldn't be too small) 25 mars 2025: **icCamera: pixel adapting camera ("a rectangle is a square"): camera updates its transform along time so that object underCursor displays square pixels typical usecase: achieve "impossible" layouts remark: this may cause something like seasickness **!camera:pixelAdapt!: force pixel adaptation just for now *(***)multiplayer zChallenge: like Escape Simulator but in iCs **(*)randomSpawn: icObj is spawned randomly in renderZones "stalactites" fractal structure typical usecase: create iC-roguelike games **infinishute server: author drops its .shu files in the server and a link is automatically create for clients to explore the infinishute *graph-movable object: object can only move by snapping for snapSlot to snapSlot *zPixel:!zPixelContour!: contour zPixelImage under cursor (create zPixelImage: contour) a contextPicker is implicitly done so that brush's zPixel__preview is compatible with target zPixelImage zPixel__preview's zLevel could be anything that is lessThanOrEqualTo zPixelImage's zLevel so that chaining contour results in smaller and smaller contours *aui X localStorage: an iC stored in each tab: use query vars to make url unique so that each tab can be stored 26 mars 2025: *(*)zPixel: [pixel recycler]: give an image to this operator, it will begin to reconstruct its target image with the pixels it is fed with one input pixel for one output pixel, and it must be the right color, otherwise unused pixel is left on a heap, on the side **freeDrawing: aggregation mode: drawings tend to merge into bigger images (this reduces the number of objects) typical usecase: drawing landscape typical anti-usecase: drawing characters or objects (which will be held and moved later on) **(**)ai: use ai image generation local server (like krita-ai-diffusion) 28 mars 2025: **icObj.type = "card"/!cardFlip!: this object is two-sided typical usecase: card games 30 mars 2025: **(*)!generateStalactree!: automatically generate a fractal structure with colored rects, from the current renderZones typical usecase: have a structure to populate with content (==don't start from scratch: decorate the house, don't build the house) remark: icTexts and other objects could also be spawned to create the stalactree remark 2: depth of stalactree may be configured max number of objects in a renderZone could be configured **!generateStalactree!(jsonObj): use stalactree to display dicts, arrays, trees, ... typical usecase: edu typical usecase 2: game bootstrap (give content to aui and it generates a display for it) 02 avril 2025: **(**)freeDrawing: complex operators: each part of the complex operator is drawn with a specific color typical usecase: drawing instead of coding workflow: 1. swap to icUse__operatorFreeDrawing__X 2. draw the parts: each part with its associated color (example: chest operator: key comparison: yellow chest: red, treasure: green) 3. operator is created and now you can configure it with objects 03 avril 2025: **icUse: use multiple icUses at the same time: they share the same camera typical usecase: combine filters 08 avril 2025: ***game: elastomania X iC: sometimes you have to shrink, sometimes you have to grow player controls grow/shrink as well as accelerate/slowDown 09 avril 2025: **aui::isometric 10 avril 2025: ***zPixelMove: move wrt camera: If camera is high, zPixelUnit will be big. If camera is deep, zPixelUnit may be sub-zPixel. typical usecase: perfect gapFilling 11 avril 2025: *[creation]speed draw format: record a video while drawing in aui, then output it with speed 16X 4+ flavors: 1min, 5min, 15min, 90min, ... remark:could be used: drawing on camera and then create blank camera, and drawing on camera, etc. to metatell the story 12 avril 2025: ***zPhoto: photos are seamed to create a big photo typical usecase: take a big photo with a cheap device workflow: 1. user activates image capture device => image #1 is put on iC 2. user moves image capture device => image #2 is put on iC and seamed with image #1 etc. (dump: Détecteur de métaux Random spawn a la pokémon "Flash wireframe skeleton" Image editing operators (à la factory balls) IcConfiguration/icCase:case contains variations of scenery elements, it's kinda kv-based: drag original in k and drag variation in v case select: eventX could then trigger configurableY.swapToConfig(2) config(0) is original config IcSpirit: this icObj is rendered through another obj Spirit in spirit, etc. ? **fullMap: example: full map of Super Metroid by seaming game screenshots example: full map of each Mario Bros level by seaming game screenshots **15' of drawings on the same infinishute: this could be a sequence of 1' sessions but it is required to see the growing of the infinishute **N.1 : next of collection #1: Typical usecase: tell a story, line by line: spawn line#n when done enriching line#(n-1) with a drawing SpaceX: les mondes: like icUse__visibility but for any object operateOnSelected__swapToWorldX: now you see the world as seen by objX ****AnimationFrame: anywhere typical usecase : create an animation starting in sceneryA and ending in sceneryB AnimationFrame is a recording typical usecase : create smooth animations by chaining frames which are not frames zGif: like a gif, but in an iC (== gif is a stalactree) ) **behavior: notThatSticky: object that is stuck on camera may unstick if some conditions are met typical usecase: games: Something is stuck on camera. Camera zooms out too much. object unsticks and is left there. 14 avril 2025: **edu: faire comprendre le concept de fonction (==de "map") via les customizable fonts **(**)zPixel::zPixelFont/zPixelFont creator: each char has arbitrary depth 16 avril 2025: *game: blind-test using a grid of music videos, organized in bulks of {min:3,max:8} (like a bad mashup) when game master zooms in a bulk, all videos can be heard at the same time players can only listen and have to find every song played *zPixel: zPixelDitheringBrush ***icUse: use CAPS_LOCK to toggle "draw on camera" mode: it clearly indicates a "different stance" 18 avril 2025: **(**)website editor: draw a zWebsite workflow: 0. user draws stuff on pageX 1. user creates buttonLink to pageY 2. user clicks on buttonLink => changes made on pageX are saved => if it did not exist, pageY is created => user is now editing pageY remark: the drawn pages can be used as templates if user spawns tags on the elements they have drawn (when you want to precreate a website for someone) dev: un peu de travail côté serveur 21 avril 2025: ****icObj.type = "document": can be saved as an individual entity 2 documents can have objects "in the same space" 23 avril 2025: **(?**?)icObj.type = "movingVideo": it's a video that, at each frame, sets its transform corresponding to the transform that the recording object had when the video was recorded so not only the image is recorded, but the "position" is also recorded dev: this is not a renderZone-friendly object 01 mai 2025: **!cosmeticCompose!: put tape on stuff (==create temporary composite) in order to move stuff in bulk but quickly remove tape later(== make composition obsolete) 17 mai 2025: *game: puzzle: each puzzlePiece is a video: videos must match seamlessly in time difficulty: easy: all pieces have the same time origin medium: most pieces have the same time origin (player has to tune the time origin of some pieces) hard: no two pieces have the same time origin (player has to tune the time origin of all pieces) even harder: pieces with different time flow 20 mai 2025: Leo/AUI { ***InfiniteLoop: cannot pan, can only zoom, zLevel__min == zLevel__max (it loops) typical usecase: build stuff with a built-in infiniteLoop typical usecase 2: build content with parts that are very easy to access via scroll remark: user may be able to "insert space" in the infiniteLoop, to add more content when the loop is completely occupied spherical stuff multiplayer: everyone has a character ***metaDraw/deepDraw: draw an abstract category, which is then automatically stuffed with stuff example: draw 'city': when you zoom in, there are houses. When you zoom in a house, there is furniture, etc. typical usecase: easily create maps for role-playing games (draw 'city', draw 'forest', ...) Leo AUI } **(**)zSquare: mining in 2D: to spawn a zSquare at zLevel:n, you need 4 zSquares with zLevel:(n-1), etc. player has a pool for each color(including the most abstract definitions of "color") in their inventory the game is to mine enough zSquares at deep levels to be able to draw at a higher levels there may be buffs that improve the number of squares mined (4 extracted for 1 mined, for example) there may also be zSquares that are zLevel independent if player wants to write something, they have to mine first, in order to have enough zSquares to spawn .