oskar/cours
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Oscar Plaisant 2024-04-02 05:22:45 +02:00
parent 0a72fe01d3
commit e013bd828b
10 changed files with 868 additions and 445 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
.DS_Store vendored
View File

Binary file not shown.

4
.obsidian/graph.json vendored
View File

@ -130,6 +130,6 @@
"repelStrength": 6.39485677083333,
"linkStrength": 1,
"linkDistance": 30,
"scale": 0.05607792726105202,
"close": false
"scale": 0.05650571961780555,
"close": true
}

593
.obsidian/plugins/obsidian-excalidraw-plugin/data.json vendored
View File

File diff suppressed because it is too large Load Diff

2
.obsidian/plugins/various-complements/histories.json vendored
View File

@ -1 +1 @@
{"matrice hessienne":{"matrice hessienne":{"internalLink":{"count":2,"lastUpdated":1710324879177}}},"baptême":{"baptême":{"internalLink":{"count":5,"lastUpdated":1709864270370}}},"gradient":{"gradient":{"internalLink":{"count":1,"lastUpdated":1710325461961}}},"obsidian plugin tag and wordcloud":{"obsidian plugin tag and wordcloud":{"internalLink":{"count":1,"lastUpdated":1710345237714}}},"intersection de sous groupes":{"intersection de sous groupes":{"internalLink":{"count":1,"lastUpdated":1710465530327}}},"valeurs":{"valeurs":{"internalLink":{"count":1,"lastUpdated":1711459246780}}},"Learning APL":{"Learning APL":{"internalLink":{"count":1,"lastUpdated":1711584419388}}},"structure de donnés":{"structure de donnés":{"internalLink":{"count":1,"lastUpdated":1711621251914}}},"paramètre":{"paramètre":{"internalLink":{"count":1,"lastUpdated":1711621492446}}},"langage de programmation":{"langage de programmation":{"internalLink":{"count":4,"lastUpdated":1711920773085}},"langage":{"internalLink":{"count":1,"lastUpdated":1711920903060}}},"argument d'une fonction":{"argument d'une fonction":{"internalLink":{"count":1,"lastUpdated":1711624010397}}},"argument":{"argument":{"internalLink":{"count":2,"lastUpdated":1711624133731}}},"techniques de pkm":{"techniques de pkm":{"internalLink":{"count":1,"lastUpdated":1711627281333}}},"paradigme de programmation":{"paradigme de programmation":{"internalLink":{"count":6,"lastUpdated":1711917618071}}},"état":{"état":{"internalLink":{"count":3,"lastUpdated":1711905774038}}},"structure de données":{"structure de données":{"internalLink":{"count":1,"lastUpdated":1711643699590}}},"structures de données":{"structures de données":{"internalLink":{"count":2,"lastUpdated":1711904665130}}},"enregistrement":{"enregistrement":{"internalLink":{"count":1,"lastUpdated":1711668283936}}},"envoi de messages entre objets":{"envoi de messages entre objets":{"internalLink":{"count":1,"lastUpdated":1711742931869}}},"programmation structurée":{"programmation structurée":{"internalLink":{"count":1,"lastUpdated":1711764089506}}},"effet de bord":{"effet de bord":{"internalLink":{"count":2,"lastUpdated":1711906516742}}},"programmation impérative":{"programmation impérative":{"internalLink":{"count":4,"lastUpdated":1711988908729}}},"composition de fonctions":{"composition de fonctions":{"internalLink":{"count":1,"lastUpdated":1711904385231}}},"fonction":{"fonction":{"internalLink":{"count":2,"lastUpdated":1711904857369}}},"fonction pure":{"fonction pure":{"internalLink":{"count":1,"lastUpdated":1711915488076}}},"effets de bord":{"effets de bord":{"internalLink":{"count":1,"lastUpdated":1711915498637}}},"Alan Perlis":{"Alan Perlis":{"internalLink":{"count":1,"lastUpdated":1711915724379}}},"fonction racine carrée":{"fonction racine carrée":{"internalLink":{"count":1,"lastUpdated":1711916013705}}},"méthode de Newton":{"méthode de Newton":{"internalLink":{"count":1,"lastUpdated":1711916030171}}},"langages formels":{"langages formels":{"internalLink":{"count":1,"lastUpdated":1711916816989}}},"logique":{"logique":{"internalLink":{"count":1,"lastUpdated":1711916822650}}},"sophisme":{"sophisme":{"internalLink":{"count":1,"lastUpdated":1711916957089}}},"définition":{"définition":{"currentVault":{"count":1,"lastUpdated":1711920701861},"currentFile":{"count":1,"lastUpdated":1711920749062}}},"remplissage":{"remplissage":{"currentVault":{"count":1,"lastUpdated":1711920704851}}},"défini":{"défini":{"currentFile":{"count":1,"lastUpdated":1711920747172}}},"SE - organisation des données":{"SE - organisation des données":{"internalLink":{"count":1,"lastUpdated":1711920824428}}},"Frédéric Lordon":{"Frédéric Lordon":{"internalLink":{"count":1,"lastUpdated":1711942941375}}},"taxonomie des paradigmes de programmation":{"taxonomie des paradigmes de programmation":{"internalLink":{"count":2,"lastUpdated":1712001528811}}},"FermetureInformatique2024":{"FermetureInformatique2024":{"internalLink":{"count":1,"lastUpdated":1712011439635}}}}
{"matrice hessienne":{"matrice hessienne":{"internalLink":{"count":2,"lastUpdated":1710324879177}}},"baptême":{"baptême":{"internalLink":{"count":5,"lastUpdated":1709864270370}}},"gradient":{"gradient":{"internalLink":{"count":1,"lastUpdated":1710325461961}}},"obsidian plugin tag and wordcloud":{"obsidian plugin tag and wordcloud":{"internalLink":{"count":1,"lastUpdated":1710345237714}}},"intersection de sous groupes":{"intersection de sous groupes":{"internalLink":{"count":1,"lastUpdated":1710465530327}}},"valeurs":{"valeurs":{"internalLink":{"count":1,"lastUpdated":1711459246780}}},"Learning APL":{"Learning APL":{"internalLink":{"count":1,"lastUpdated":1711584419388}}},"structure de donnés":{"structure de donnés":{"internalLink":{"count":1,"lastUpdated":1711621251914}}},"paramètre":{"paramètre":{"internalLink":{"count":1,"lastUpdated":1711621492446}}},"langage de programmation":{"langage de programmation":{"internalLink":{"count":4,"lastUpdated":1711920773085}},"langage":{"internalLink":{"count":1,"lastUpdated":1711920903060}}},"argument d'une fonction":{"argument d'une fonction":{"internalLink":{"count":1,"lastUpdated":1711624010397}}},"argument":{"argument":{"internalLink":{"count":2,"lastUpdated":1711624133731}}},"techniques de pkm":{"techniques de pkm":{"internalLink":{"count":1,"lastUpdated":1711627281333}}},"paradigme de programmation":{"paradigme de programmation":{"internalLink":{"count":6,"lastUpdated":1711917618071}}},"état":{"état":{"internalLink":{"count":3,"lastUpdated":1711905774038}}},"structure de données":{"structure de données":{"internalLink":{"count":1,"lastUpdated":1711643699590}}},"structures de données":{"structures de données":{"internalLink":{"count":2,"lastUpdated":1711904665130}}},"enregistrement":{"enregistrement":{"internalLink":{"count":1,"lastUpdated":1711668283936}}},"envoi de messages entre objets":{"envoi de messages entre objets":{"internalLink":{"count":1,"lastUpdated":1711742931869}}},"programmation structurée":{"programmation structurée":{"internalLink":{"count":1,"lastUpdated":1711764089506}}},"effet de bord":{"effet de bord":{"internalLink":{"count":2,"lastUpdated":1711906516742}}},"programmation impérative":{"programmation impérative":{"internalLink":{"count":4,"lastUpdated":1711988908729}}},"composition de fonctions":{"composition de fonctions":{"internalLink":{"count":1,"lastUpdated":1711904385231}}},"fonction":{"fonction":{"internalLink":{"count":2,"lastUpdated":1711904857369}}},"fonction pure":{"fonction pure":{"internalLink":{"count":1,"lastUpdated":1711915488076}}},"effets de bord":{"effets de bord":{"internalLink":{"count":1,"lastUpdated":1711915498637}}},"Alan Perlis":{"Alan Perlis":{"internalLink":{"count":1,"lastUpdated":1711915724379}}},"fonction racine carrée":{"fonction racine carrée":{"internalLink":{"count":1,"lastUpdated":1711916013705}}},"méthode de Newton":{"méthode de Newton":{"internalLink":{"count":1,"lastUpdated":1711916030171}}},"langages formels":{"langages formels":{"internalLink":{"count":1,"lastUpdated":1711916816989}}},"logique":{"logique":{"internalLink":{"count":1,"lastUpdated":1711916822650}}},"sophisme":{"sophisme":{"internalLink":{"count":1,"lastUpdated":1711916957089}}},"définition":{"définition":{"currentVault":{"count":1,"lastUpdated":1711920701861},"currentFile":{"count":1,"lastUpdated":1711920749062}}},"remplissage":{"remplissage":{"currentVault":{"count":1,"lastUpdated":1711920704851}}},"défini":{"défini":{"currentFile":{"count":1,"lastUpdated":1711920747172}}},"SE - organisation des données":{"SE - organisation des données":{"internalLink":{"count":1,"lastUpdated":1711920824428}}},"Frédéric Lordon":{"Frédéric Lordon":{"internalLink":{"count":1,"lastUpdated":1711942941375}}},"taxonomie des paradigmes de programmation":{"taxonomie des paradigmes de programmation":{"internalLink":{"count":2,"lastUpdated":1712001528811}}},"FermetureInformatique2024":{"FermetureInformatique2024":{"internalLink":{"count":1,"lastUpdated":1712011439635}}},"processus":{"processus":{"internalLink":{"count":2,"lastUpdated":1712026279944}}},"swap d'un processus":{"swap d'un processus":{"internalLink":{"count":1,"lastUpdated":1712026273892}}}}

563
Excalidraw/concurrence vs parallélisme 2024-04-02 04.40.22.excalidraw.md Normal file
View File

@ -0,0 +1,563 @@
---
excalidraw-plugin: parsed
tags: [excalidraw]
---
==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠==
# Text Elements
concurrent ^3rnPZe1u
non-concurrent ^Nx29YN6t
parallèle ^Vftdkv64
non-parallèle ^YT8E0ZUd
exécution de plusieurs processus, un par un.
ordonnancement ^a03Drs6K
parallélisation des calculs (et non des parties du programme) ^iBNxvWWH
programmation impérative stricte : un seul fil d'instructions qui s'exécute linéairement ^DPM29I4O
exécution simultanée de plusieurs parties indépendantes du programme. ^wU8oLvUN
%%
# Drawing
```json
{
"type": "excalidraw",
"version": 2,
"source": "https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/2.1.1",
"elements": [
{
"id": "3rnPZe1u",
"type": "text",
"x": -99.75139999790707,
"y": -239.2023453522998,
"width": 140.89593505859375,
"height": 35,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1950843954,
"version": 128,
"versionNonce": 1695641778,
"isDeleted": false,
"boundElements": null,
"updated": 1712025942891,
"link": null,
"locked": false,
"text": "concurrent",
"rawText": "concurrent",
"fontSize": 28,
"fontFamily": 1,
"textAlign": "left",
"verticalAlign": "top",
"containerId": null,
"originalText": "concurrent",
"lineHeight": 1.25
},
{
"id": "Nx29YN6t",
"type": "text",
"x": 133.5802739299707,
"y": -239.2023453522998,
"width": 194.06790161132812,
"height": 35,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1565779950,
"version": 108,
"versionNonce": 1132505966,
"isDeleted": false,
"boundElements": null,
"updated": 1712025942891,
"link": null,
"locked": false,
"text": "non-concurrent",
"rawText": "non-concurrent",
"fontSize": 28,
"fontFamily": 1,
"textAlign": "left",
"verticalAlign": "top",
"containerId": null,
"originalText": "non-concurrent",
"lineHeight": 1.25
},
{
"id": "Vftdkv64",
"type": "text",
"x": -308.86535186079834,
"y": -134.8410076475401,
"width": 119.58795166015625,
"height": 35,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1184386162,
"version": 59,
"versionNonce": 1860587758,
"isDeleted": false,
"boundElements": null,
"updated": 1712025951978,
"link": null,
"locked": false,
"text": "parallèle",
"rawText": "parallèle",
"fontSize": 28,
"fontFamily": 1,
"textAlign": "left",
"verticalAlign": "top",
"containerId": null,
"originalText": "parallèle",
"lineHeight": 1.25
},
{
"id": "YT8E0ZUd",
"type": "text",
"x": -362.0373184135327,
"y": -5.903707225731296,
"width": 172.75991821289062,
"height": 35,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 692941170,
"version": 79,
"versionNonce": 935657202,
"isDeleted": false,
"boundElements": null,
"updated": 1712025961231,
"link": null,
"locked": false,
"text": "non-parallèle",
"rawText": "non-parallèle",
"fontSize": 28,
"fontFamily": 1,
"textAlign": "left",
"verticalAlign": "top",
"containerId": null,
"originalText": "non-parallèle",
"lineHeight": 1.25
},
{
"id": "KdxA8ds3GnPzF_msPmALG",
"type": "rectangle",
"x": -159.6411957422672,
"y": -181.41442713006342,
"width": 260.675526547314,
"height": 128.14683896504664,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 188180718,
"version": 174,
"versionNonce": 2081030958,
"isDeleted": false,
"boundElements": [
{
"type": "text",
"id": "wU8oLvUN"
}
],
"updated": 1712025951978,
"link": null,
"locked": false
},
{
"id": "wU8oLvUN",
"type": "text",
"x": -147.3433265726141,
"y": -167.3410076475401,
"width": 236.0797882080078,
"height": 100,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1756100526,
"version": 90,
"versionNonce": 370539762,
"isDeleted": false,
"boundElements": null,
"updated": 1712025951978,
"link": null,
"locked": false,
"text": "exécution simultanée de\nplusieurs parties\nindépendantes du\nprogramme.",
"rawText": "exécution simultanée de plusieurs parties indépendantes du programme.",
"fontSize": 20,
"fontFamily": 1,
"textAlign": "center",
"verticalAlign": "middle",
"containerId": "KdxA8ds3GnPzF_msPmALG",
"originalText": "exécution simultanée de plusieurs parties indépendantes du programme.",
"lineHeight": 1.25
},
{
"id": "7iwUc2r9n0AhWptmTvtgV",
"type": "rectangle",
"x": 100.27646146197776,
"y": -181.41442713006342,
"width": 260.675526547314,
"height": 128.14683896504664,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1057950386,
"version": 254,
"versionNonce": 108883310,
"isDeleted": false,
"boundElements": [
{
"type": "text",
"id": "iBNxvWWH"
}
],
"updated": 1712025951978,
"link": null,
"locked": false
},
{
"id": "iBNxvWWH",
"type": "text",
"x": 122.34432727469726,
"y": -154.8410076475401,
"width": 216.539794921875,
"height": 75,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1044172082,
"version": 98,
"versionNonce": 602771122,
"isDeleted": false,
"boundElements": null,
"updated": 1712025951978,
"link": null,
"locked": false,
"text": "parallélisation des\ncalculs (et non des\nparties du programme)",
"rawText": "parallélisation des calculs (et non des parties du programme)",
"fontSize": 20,
"fontFamily": 1,
"textAlign": "center",
"verticalAlign": "middle",
"containerId": "7iwUc2r9n0AhWptmTvtgV",
"originalText": "parallélisation des calculs (et non des parties du programme)",
"lineHeight": 1.25
},
{
"id": "ZKj332bNwpWC7qNklyFdW",
"type": "rectangle",
"x": 100.27646146197776,
"y": -52.477126708254616,
"width": 260.675526547314,
"height": 128.14683896504664,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 709055086,
"version": 317,
"versionNonce": 1470186542,
"isDeleted": false,
"boundElements": [
{
"type": "text",
"id": "DPM29I4O"
}
],
"updated": 1712025823797,
"link": null,
"locked": false
},
{
"id": "DPM29I4O",
"type": "text",
"x": 108.36433917655273,
"y": -38.403707225731296,
"width": 244.49977111816406,
"height": 100,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 470625266,
"version": 118,
"versionNonce": 422512046,
"isDeleted": false,
"boundElements": null,
"updated": 1712025844671,
"link": null,
"locked": false,
"text": "programmation impérative\nstricte : un seul fil\nd'instructions qui\ns'exécute linéairement",
"rawText": "programmation impérative stricte : un seul fil d'instructions qui s'exécute linéairement",
"fontSize": 20,
"fontFamily": 1,
"textAlign": "center",
"verticalAlign": "middle",
"containerId": "ZKj332bNwpWC7qNklyFdW",
"originalText": "programmation impérative stricte : un seul fil d'instructions qui s'exécute linéairement",
"lineHeight": 1.25
},
{
"id": "bhSPYD-3hDCUJxpZ0F4g5",
"type": "rectangle",
"x": -159.6411957422672,
"y": -52.477126708254616,
"width": 260.675526547314,
"height": 128.14683896504664,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1596006254,
"version": 335,
"versionNonce": 272747506,
"isDeleted": false,
"boundElements": [
{
"type": "text",
"id": "a03Drs6K"
}
],
"updated": 1712025936057,
"link": null,
"locked": false
},
{
"id": "a03Drs6K",
"type": "text",
"x": -138.20331955357113,
"y": -25.903707225731296,
"width": 217.79977416992188,
"height": 75,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1135407406,
"version": 89,
"versionNonce": 1285755374,
"isDeleted": false,
"boundElements": null,
"updated": 1712025936057,
"link": null,
"locked": false,
"text": "exécution de plusieurs\nprocessus, un par un.\nordonnancement",
"rawText": "exécution de plusieurs processus, un par un.\nordonnancement",
"fontSize": 20,
"fontFamily": 1,
"textAlign": "center",
"verticalAlign": "middle",
"containerId": "bhSPYD-3hDCUJxpZ0F4g5",
"originalText": "exécution de plusieurs processus, un par un.\nordonnancement",
"lineHeight": 1.25
},
{
"id": "XdwFXk2B",
"type": "text",
"x": -34.470864934414124,
"y": -129.16482959521989,
"width": 10,
"height": 25,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 681709490,
"version": 2,
"versionNonce": 1193700142,
"isDeleted": true,
"boundElements": null,
"updated": 1712025862648,
"link": null,
"locked": false,
"text": "",
"rawText": "",
"fontSize": 20,
"fontFamily": 1,
"textAlign": "center",
"verticalAlign": "middle",
"containerId": "KdxA8ds3GnPzF_msPmALG",
"originalText": "",
"lineHeight": 1.25
},
{
"id": "1bu3Qvkr",
"type": "text",
"x": -34.470864934414124,
"y": -129.16482959521989,
"width": 10,
"height": 25,
"angle": 0,
"strokeColor": "#1e1e1e",
"backgroundColor": "transparent",
"fillStyle": "solid",
"strokeWidth": 2,
"strokeStyle": "solid",
"roughness": 1,
"opacity": 100,
"groupIds": [],
"frameId": null,
"roundness": null,
"seed": 1183338034,
"version": 2,
"versionNonce": 1955579054,
"isDeleted": true,
"boundElements": null,
"updated": 1712025742465,
"link": null,
"locked": false,
"text": "",
"rawText": "",
"fontSize": 20,
"fontFamily": 1,
"textAlign": "center",
"verticalAlign": "middle",
"containerId": "KdxA8ds3GnPzF_msPmALG",
"originalText": "",
"lineHeight": 1.25
}
],
"appState": {
"theme": "dark",
"viewBackgroundColor": "#ffffff",
"currentItemStrokeColor": "#1e1e1e",
"currentItemBackgroundColor": "transparent",
"currentItemFillStyle": "solid",
"currentItemStrokeWidth": 2,
"currentItemStrokeStyle": "solid",
"currentItemRoughness": 1,
"currentItemOpacity": 100,
"currentItemFontFamily": 1,
"currentItemFontSize": 28,
"currentItemTextAlign": "left",
"currentItemStartArrowhead": null,
"currentItemEndArrowhead": "arrow",
"scrollX": 629.3464105949569,
"scrollY": 444.3288476410011,
"zoom": {
"value": 1.1074602753841236
},
"currentItemRoundness": "sharp",
"gridSize": null,
"gridColor": {
"Bold": "#C9C9C9FF",
"Regular": "#EDEDEDFF"
},
"currentStrokeOptions": null,
"previousGridSize": null,
"frameRendering": {
"enabled": true,
"clip": true,
"name": true,
"outline": true
}
},
"files": {}
}
```
%%

107
Remplissage du plan de L3.md
View File

@ -13,16 +13,7 @@ Un paradigme de programmation est une façon d'approcher la programmation et de
La notion de paradigme est notamment à dissocier de celles de *méthode* ou bien de *design patterns*, qui décrivent comment traîter des problèmes spécifiques et reconnus, et comment aboutir à une solution conceptuelle [@ParadigmeProgrammation2023].
Un paradigme est un concept plus "haut niveau", c'est-à-dire plus abstrait : chaque paradigme supporte un ensemble particulier de concepts (cohérents entre eux), qui peuvent être hérités d'une théorie mathématique, de principes fondamentaux, ou bien d'une vision sur ce que doit être la programmation [^3].
> [!cite]- [Programming Paradigms for Dummies: What Every Programmer Should Know](zotero://select/groups/5383243/items/673TMQRT) - [Page 10](zotero://open-pdf/groups/5383243/items/P4L4LCJZ?page=2&annotation=4LQTA3Q8)
> Each paradigm supports a set of concepts that makes it the best for a certain kind of problem. For example, object-oriented programming is best for problems with a large number of related data abstractions organized in a hierarchy. Logic programming is best for transforming or navigating complex symbolic structures according to logical rules. Discrete synchronous programming is best for reactive problems, i.e., problems that consist of reactions to sequences of external events.
>
> > [!note] Notes
> > Les concepts supportés par les différents paradigmes les rendent adaptés pour la résolution de différents problèmes.
> ^4LQTA3Q8aP4L4LCJZg5383243p2
Un paradigme de programmation est souvent principalement décrit par les concepts qu'il implémente ou non [@royProgrammingParadigmsDummies, p.10].
Un paradigme de programmation est souvent principalement décrit par les concepts qu'il implémente ou non [^40].
C'est notamment cette approche qu'emploie la [[taxonomie des paradigmes de programmation]] (référence à une annexe) [@TaxonomiePrincipauxParadigmes].
@ -31,7 +22,8 @@ Cela est problématique car l'absence d'une fonctionnalité ne peut pas explique
C'est pour cette raison que, dans notre définition des différents paradigmes, nous chercherons à expliquer à la fois les principes fondamentaux de chaque paradigme, mais également à montrer brièvement pourquoi ceux-ci sont intéressants, c'est-à-dire répondre à la question "en quoi ce paradigme apporte-t-il quelque chose". Cela constituera une première partie de réponse à notre problématique.
## Définitions
## Définition de concepts fondamentaux
### état
@ -76,7 +68,7 @@ Du point de vue du développeur, cela signifie que l'exécution d'une fermeture
Un avantage considérable des fermetures est qu'elles permettent d'accéder aux valeurs et références d'un environnement local qui n'existe plus (car il à été libéré de la pile d'exécution) [^9].
## les principaux paradigmes
## Description de quelques paradigmes
[[taxonomie des paradigmes de programmation]]
@ -138,6 +130,14 @@ Une autre définition de la programmation structurée est une façon de concevoi
"The absence of **gotos** and so on, has very little to do with this [the advantages strutcured programming, especially modularity]. It helps with 'programming in the small', whereas modular design helps with 'programming in the large'. Thus one can enjoy the benefits of structured programming in FORTRAN or assembly language, even if it is a little more work." [@hughesWhyFunctionalProgramming1989, p.2]
### Programmation concurrente
La programmation concurente permet de gérer des programmes avec plusieurs ensembles d'instructions dont l'exécution doit être indépendante.
En programmation impérative stricte, l'ordre des instructions définit leur ordre d'exécution, ce qui les rend interdépendantes. On dit alors que ces instructions sont séquentielles.
La programmation concurrente indroduit le concept de concurrence, lorsque deux parties d'un programme n'ont pas de dépendance l'une avec l'autre [^41].
"Le monde réel est concurrent : il consiste en des activités qui évoluent indépendamment" ("The real world is concurrent: it consists of activities that evolve independently." [@royProgrammingParadigmsDummies, p.25]).
## les langages multi-paradigmes
Il existe beaucoup de langages qui implémentent plusieurs paradigmes de programmation [@ComparisonMultiparadigmProgramming2024]. Ces langages sotn appelés langages multi-paradigmes.
@ -168,29 +168,21 @@ Cependant, ces langages ne sont généralement pas qualifiés de "langages de pr
Il existe également des langages de programmation qui ne sont pas turing-complets (par exemple, le langage G-code, dans certaines implémentations [^28]), mais ces langages ne sont pas utilisés pour résoudre des problèmes de programmation : ils sont utilisés à des fins théoriques, ou pour des applications particulières (par exemple, le langage G-code est utilisé pour commander des machines à commande numérique [^27]).
### Au sens commun
### Expressivité au sens pratique
![[expressivité pratique#^definition]]
L'expressivité pratique est la diversidé et la quantité d'idées qu'un langage de programmation peut exprimer facilement.
Dans ce sens de l'expressivité, la facilité d'exprimer une idée est primordiale. Comme il est dit dans la section [[Remplissage du plan de L3#Expressivité au sens formel]], la plupart des langages de programmation ont la même expressivité théorique. Cependant, il n'est pas suffisant pour l'expressivité pratique qu'une idée soit théoriquement exprimable : il est nécessaire qu'il soit aisé de le faire, que le langage implémente des fonctionnalités directement. Il est, par exemple, possible de faire de la programmation structurée (voir : [[Remplissage du plan de L3#programmation structurée]]) ou de la programmation fonctionnelle (voir : [[Remplissage du plan de L3#programmation fonctionnelle]]) dans un langage qui ne supporte pas nativement ces paradigmes (par exemple le langage assembleur). En général, pour tout concept $x$ implémenté par un langage de programmation $A$, il sera toujours possible de créer un équivalent de $x$ dans un langage $B$ qui ne l'implémente pas nativement (à condition que $B$ soit Turing Complet). Cependant, l'expressivité au sens pratique ne prends pas en compte cette possibilité, et ne considère que les idées directement (ou presque directement) implémentées et exprimables dans un langage.
### compromis expressivité vs analysabilité
L'expressivité pratique d'un langage est donc très liée aux paradigmes qu'il implémente. On pourrait même définir l'expressivité au sens pratique d'un langage comme la quantité de paradigmes qu'il implémente.
### compromis entre expressivité et analysabilité
Plus un langage est expressif, plus il est complexe de l'analyser mathématiquement.
Plus un langage est puissant expressivement au sens formel, plus il devient difficile (et impossible) de démontrer certains théorèmes sur ce formalisme [^29].
Cela est vrai également pour l'expressivité au sens commun : "le fait d'éviter certaines techniques peut permettre de rendre plus aisée la démonstration de théorèmes sur la correction d'un programme -- ou simplement la compréhension de son fonctionnement -- sans limiter la généralité du langage de programmation." [@ParadigmeProgrammation2023].
On peut voir ce compromis dans le cadre
C'est pourquoi certaines fonctionnalités, certains paradigmes, devraient être utilisés uniquement si cela est nécessaire [^30].
Cela est vrai également pour l'expressivité au sens pratique : "le fait d'éviter certaines techniques peut permettre de rendre plus aisée la démonstration de théorèmes sur la correction d'un programme -- ou simplement la compréhension de son fonctionnement -- sans limiter la généralité du langage de programmation." [@ParadigmeProgrammation2023].
#### Exemple de compromis : automates et grammaires
- les automates à pile sont moins expressifs que les machines de Turing
- les automates à pile reconnaissent exactement les grammaires non-contextuelles
- les machines de Turing reconnaissent les langages récursivement énumérables
- les automates à pile ont un formalisme plus pratique (certains théorèmes sont plus définis)
- le problème qui demande si un mot est reconnu par un automate à pile est décidable
- le problème qui demande si un mot est reconnu par une machine de Turing est indécidable
Les automates à pile et les machines de Turing forment un exemple de compromis entre analysabilité et expressivité formelle.
Les automates à pile reconnaissent les langages non contextuels [^31]. Les machines de Turing reconnaissent les langages contextuels [^32].
Or, les langages non contextuels sont strictement inclus dans les langages récursivement énumérables [^33] .
@ -202,6 +194,13 @@ Pourtant, ce problème est indécidable pour les machines de Turing [^35].
On voit donc que les machines de Turing sont un formalisme plus expressif (certains concepts exprimés par des machines de Turing ne sont pas exprimables par des automates à pile) mais moins analysable (certains problèmes sont décidables sur les automates à pile, mais pas sur les machines de Turing).
#### Exemple de compromis : le non-déterminisme
Un langage de programmation est dit non déterministe lorsque son exécution ne dépend pas uniquement des spécifications du programme, c'est-à-dire que les spécifications laissent un choix lors de l'exécution du programme [^38]. Le non déterminisme est donc problématique, puisqu'il peut amener à créer des programmes dont le résultat est inattendu ou incertain.
Ce pendant, certains paradigmes qui peuvent exprimer du non déterminisme restent utiles pour modéliser cetains problèmes [^39].
C'est pourquoi certaines fonctionnalités, certains paradigmes, comme le non déterminisme et les paradigmes qui l'impliquent, devraient être utilisés uniquement si cela est nécessaire [^30].
# Paradigmes dans l'apprentissages
## avantages de la diversité
@ -250,26 +249,45 @@ On voit donc que les machines de Turing sont un formalisme plus expressif (certa
> > le transfert de connaissances d'un langage à un autre peut être avantageux, mais peut aussi créer de la connaissance fausse (si le transfert n'est pas pertinent à ce moment).
> ^588UCYYDaSQN4T6Z8g5383243p7
# Paradigmes pour la résolution de problèmes
## diversité des approches
- langages particuliers (comme abordés dans [[Remplissage du plan de L3#Expressivité au sens formel]])
- permettent de répondre à un besoin spécifique
> [!cite]+ [The paradigms of programming](zotero://select/groups/5383243/items/Y8NDFJ8W) - [Page 3](zotero://open-pdf/groups/5383243/items/WWITR642?page=3&annotation=R6BAAFNA)
> If the advancement of the general art of programming requires the continuing invention and elaboration of paradigms, advancement of the art of the individual programmer requires that he expand his repertory of paradigms.
> ^R6BAAFNAaWWITR642g5383243p3
La diversité est utile, de nouveaux paradigmes apportent de nouvelles façons de voir.
Langages multi-paradigmes
> [!cite] [Programming Paradigms for Dummies: What Every Programmer Should Know](zotero://select/groups/5383243/items/673TMQRT) - [Page 10](zotero://open-pdf/groups/5383243/items/P4L4LCJZ?page=2&annotation=4YR7745Q)
> A language should ideally support many concepts in a well-factored way, so that the programmer can choose the right concepts whenever they are needed without being encumbered by the others.
>
> > [!note] Notes
> > Les langages devraient tous être multiparadigmes, pour pouvoir choisir les bons concepts en fonction du problème.
> ^4YR7745QaP4L4LCJZg5383243p2
# Paradigmes pour la résolution de problèmes
## Les paradigmes fournissent un cadre pour la pensée
La définition même de paradigme explique déjà en partie l'existance des différents paradigmes : un paradigme donne une façon d'envisager la programmation. Comme il existe de nombreux types de problèmes, de nombreuses situations à modéliser, il semble normal que de nombreux paradigmes existent pour donner les concepts et outils nécessaires afin d'implémenter efficacement des solutions à ces problèmes.
L'existance de nombreux paradigmes de programmation peut donc être justifiée par diversité des problèmes rencontrés : chaque paradigme permet de répondre à une classe de problèmes précis. Par exemple, la programmation concurrente (voir : [[Remplissage du plan de L3#Programmation concurrente]])permet de modéliser des situations où deux événements indépendants évoluent en même temps et indépendamment.
L'efficacité peut ici avoir deux sens : l'efficacité pour l'humain, c'est-à-dire l'aisance avec laquelle le développeur pourra implémenter une solution à son problème; et l'efficacité lors de l'exécution (efficacité pour la machine), qui dépend du temps et de l'espace mémoire nécessaires à l'exécution du programme.
La nécessité de faire des compromis entre expressivité et analysabilité décris plus haut (voir [[Remplissage du plan de L3#compromis entre expressivité et analysabilité]]) peut avoir pour conséquence la nécessité de faire des compromis entre efficacité pour l'humain et efficacité pour la machine. En effet, une plus grande efficacité pour l'humain peut être atteinte par une plus grande expressivité (théorique, mais surtout pratique); or nous avons vu que cela pouvait mener à une moins grande analysabilité du langage, ce qui implique notamment que moins d'optimisation seront possibles lors de l'exécution d'un programme.
## avantages des langages multi-paradigme
Lors de la résolution de problèmes, il peut être utile d'avoir de nombreux modèles à disposition, afin de pouvoir choisir celui qui correspond le mieux au problème actuel. Si ces modèles sont directement implémentés dans notre langage de programmation (si il supporte les bons paradigmes), la résolution de notre problème sera beaucoup plus aisée. "A language should ideally support many concepts in a well-factored way, so that the programmer can choose the right concepts whenever they are needed without being encumbered by the others." : Un langage devrait, dans l'idéal, intégrer de manière cohérente un grand nombre de paradigmes, pour permettre au développeur de choisir quels concepts ils souhaite utiliser, sans être encombré par les autres [@royProgrammingParadigmsDummies p.10].
Certains langages ne nécessitent pas un grand pouvoir d'expression, cars ils répondent à un besoin spécifique (voir [[Remplissage du plan de L3#Expressivité au sens formel]]). Cependant, la plupart des langages ont pour but de pouvoir résoudre une grande diversité de problèmes, et il est donc nécessaire qu'ils permettent de décrire et manipuler aisément un grand nombre de concepts.
## créer un paradigme pour chaque type de problème
Le principe de l'extension créative (de l'anglais *creative extension principle*) est une méthode qui permet de créer de nouveaux paradigmes.
Elle permet de trouver et d'organiser des conepts utiles à la programmation, pour réellement former un paradigme [^42].
## avantages des langages multi-paradigme
L'extension créative part de la constatation qu'un problème nécessite des modifications envahissantes (des modifications dans l'ensemble des contextes du programme) pour être résolu.
Il est alors nécessaire de comprendre cette difficulté (pourquoi cette modification devient-t-elle envahissante ?), et de trouver un concept plus général, plus fondamental, qui résout cette difficulté, c'est-à-dire qui permet d'éliminer ces modification envahissantes pour retrouver un programme simple [^43].
Par exemple, si il l'on cherche à modéliser plusieurs activités indépendantes dans un langage purement impératif, il faut implémenter soi-même plusieurs piles d'exécution, ainsi qu'un ordonnanceur... Les modifications impliquées par ce problème sont envahissantes. Cette complexité peut être évitée si notre langage implémente un concept (et donc un paradigme) : la concurence (voir [[Remplissage du plan de L3#Programmation concurrente]]) [^44].
La même logique peut s'appliquer à la gestion d'erreurs dans un programme. Si l'on veut être capable de gérer les erreurs dans un programme, il faut ajouter des condition dans le corps de chaque fonction, pour que chacune retourne le code d'erreur jusqu'à l'appel initial. Les modifications impliquées par ce problèmes sont envahissantes. Cette complexité peut être évitée si notre langage implémente un concept (et donc un paradigme) : les exceptions [^45].
Floyd, dans son papier "The Paradigms of Programming", explique une méthode similaire qui lui permet de créer de nouveaux paradigmes : lorsqu'il résout un problème complexe, il essaie d'extraire l'essence de sa solution, de la simplifier pour obtenir une solution aussi directe que possible. Il cherche ensuite une règle générale qui lui permettrait de résoudre des problèmes similaires. Cette règle, si il la trouve, peut être le concept fondateur d'un nouveau paradigme [^46].
On peut donc voir chaque paradigme comme la réponse à un problème particulier, à une situation qui serait complexe à modéliser sans ce paradigme.
Il serait même pertinent, de ce point de vue, d'encourager la création de nouveaux paradigmes dès que l'on trouve des problèmes nouveaux qui sont complexes à résoudre avec les paradigmes existant. On peut
# Les paradigmes comme outil pour la pensée
@ -329,3 +347,12 @@ Greg Michaelson critique la distinction des paradigmes, en expliquant que, lorsq
[^35]: "Le problème de l'appartenance d'un mot à un langage de cette classe [la classe des langages récursivement énumérables] est indécidable." [@HierarchieChomsky2023]
[^36]: "In computer science, one sees several such communities, each speaking its own language and using its own paradigms. In fact, programming languages typically encourage use of some paradigms and discourage others." [@floydParadigmsProgramming1979a, p.2]
[^37]: "Furthermore, it is not at all clear how programming paradigms are to be characterised and differentiated. Indeed, on closer inspection, apparently disparate programming paradigms are very strongly connected. Rather, they should be viewed as different traditions of a unitary Computer Science paradigm composed of programming languages which are all Turing Complete, complemented by methodologies which may all be subsumed by Computational Thinking." [@michaelsonProgrammingParadigmsTuring2020, p.41]
[^38]: "nondeterminism is when the execution of a program is not completely determined by its specification, i.e., at some point during the execution the specification allows the program to choose what to do next. During the execution, this choice is made by a part of the run-time system called the scheduler" [@royProgrammingParadigmsDummies, p.14]
[^39]: "But paradigms that have the power to express observable nondeterminism can be used to model real-world situations and to program independent activities." [@royProgrammingParadigmsDummies, p.14]
[^40]: "Each paradigm supports a set of concepts that makes it the best for a certain kind of problem. For example, object-oriented programming is best for problems with a large number of related data abstractions organized in a hierarchy. Logic programming is best for transforming or navigating complex symbolic structures according to logical rules. Discrete synchronous programming is best for reactive problems, i.e., problems that consist of reactions to sequences of external events." [@royProgrammingParadigmsDummies, p.10]
[^41]: "For example, consider a program that consists of instructions executing one after the other. The instructions are not independent since they are ordered in time. To implement independence we need a new programming concept called concurrency. When two parts do not interact at all, we say they are concurrent.3 (When the order of execution of two parts is given, we say they are sequential.)" [@royProgrammingParadigmsDummies, p.25]
[^42]: "Concepts are not combined arbitrarily to form paradigms. They can be organized according to the creative extension principle." [@royProgrammingParadigmsDummies, p.16]
[^43]: "If the need for pervasive modifications manifests itself, we can take this as a sign that there is a new concept waiting to be discovered. By adding this concept to the language we no longer need these pervasive modifications and we recover the simplicity of the program" [@royProgrammingParadigmsDummies, p.17]
[^44]: "If we need to model several independent activities, then we will have to implement several execution stacks, a scheduler, and a mechanism for preempting execution from one activity to another. All this complexity is unnecessary if we add one concept to the language: concurrency." [@royProgrammingParadigmsDummies, p.17]
[^45]: "If we need to model error detection and correction, in which any function can detect an error at any time and transfer control to an error correction routine, then we need to add error codes to all function outputs and conditionals to test all function calls for returned error codes. All this complexity is unnecessary if we add one concept to the language: exceptions." [@royProgrammingParadigmsDummies, p.17]
[^46]: "After solving a challenging problem, ! solve it again from scratch, retracing only the insight of the earlier solution. I repeat this until the solution is as clear and direct as I can hope for. Then I look for a general rule for attacking similar problems, that would have led me to approach the given problem in the most efficient way the first time. Often, such a rule is of permanent value." [@floydParadigmsProgramming1979a, p.3]

9
concurrence vs parallélisme.md Normal file
View File

@ -0,0 +1,9 @@
up:: [[paradigme programmation concurrente]], [[parallélisme]]
#informatique
La concurrence et le parallélisme sont indépendants
- Le parallélisme à attrait au hardware : parallélisme = exécution simultanée
- La concurrence est conceptuelle : concurrence = parties indépendantes
![[concurrence vs parallélisme 2024-04-02 04.40.22.excalidraw|800]]

27
paradigme programmation concurrente.md
View File

@ -1,14 +1,31 @@
up:: [[paradigme de programmation]]
#informatique
> [!definition] programmation concurrente
> Lorsque plusieurs "fils d'exécution", plusieurs [[processus]], plusieurs
^definition
> Lorsque plusieurs "fils d'exécution", plusieurs [[processus]], plusieurs activités, sont indépendantes dans un programme (et peuvent donc être exécutée dans des périodes de temps qui se superposent)
> ^definition
> [!cite]- [Programming Paradigms for Dummies: What Every Programmer Should Know](zotero://select/groups/5383243/items/673TMQRT) - [Page 25](zotero://open-pdf/groups/5383243/items/P4L4LCJZ?page=17&annotation=FC4GVUSL)
> For example, consider a program that consists of instructions executing one after the other. The instructions are not independent since they are ordered in time. To implement independence we need a new programming concept called concurrency. When two parts do not interact at all, we say they are concurrent.3 (When the order of execution of two parts is given, we say they are sequential.)
> ^FC4GVUSLaP4L4LCJZg5383243p17
> [!cite] Définition wikipedia (en)
> [!cite]- Définition wikipedia (en)
> **Concurrent computing** is a form of [computing](https://www.wikiwand.com/en/Computing "Computing") in which several [computations](https://www.wikiwand.com/en/Computation "Computation") are executed _[concurrently](https://www.wikiwand.com/en/Concurrency_(computer_science) "Concurrency (computer science)")_—during overlapping time periods—instead of _sequentially—_with one completing before the next starts.
Il existe 3 types de concurrence :
- les [[programmation distribuée|systèmes distribués]], où une activité concurrente est appelée un ordinateur
- modèle d'internet
- les [[système d'exploitation|systèmes d'exploitation]], où une activité concurrente est appelée un [[processus]]
- les processus ont une mémoire indépendante
- le système d'exploitation gère l'exécution et la mémoire
- les activités au sein d'un [[processus]], où une activité concurrente est appelée un thread
- les processus s'exécutent indépendamment, mais partagent leur mémoire
- exemple : les onglets d'un navigateurs sont généralement des threads d'un même processus
> [!cite]- [Programming Paradigms for Dummies: What Every Programmer Should Know](zotero://select/groups/5383243/items/673TMQRT) - [Page 26](zotero://open-pdf/groups/5383243/items/P4L4LCJZ?page=18&annotation=WC8JF4D6)
> - Distributed system: a set of computers connected through a network. A concurrent activity is called a computer. This is the basic structure of the Internet.
>
> - Operating system: the software that manages a computer. A concurrent activity is called a process. Processes have independent memories. The operating system handles the task of mapping the process execution and memory to the computer. For example, each running application typically executes in one process.
>
> - Activities inside one process. A concurrent activity is called a thread. Threads execute independently but share the same memory space. For example, the different windows in a Web browser typically execute in separate threads.
> ^2ELQQWG3aP4L4LCJZg5383243p18

2
principe de l'extension créative.md
View File

@ -31,7 +31,7 @@ up:: [[paradigme de programmation]]
4. la simplicité est conservée / retrouvée (on évite les modifications envahissantes)
> [!cite]+ [The paradigms of programming](zotero://select/groups/5383243/items/Y8NDFJ8W) - [Page 3](zotero://open-pdf/groups/5383243/items/WWITR642?page=3&annotation=QWLFQ9JA)
> After solving a challenging problem, ! solve it again from scratch, retracing only the insight of the earlier solution. I repeat this until the solution is as clear and direct as I can hope for. Then I look for a general rule for attacking similar problems, that would have led me to approach the given problem in the most efficient way the first time. Often, such a rule is of permanent value.
> After solving a challenging problem, I solve it again from scratch, retracing only the insight of the earlier solution. I repeat this until the solution is as clear and direct as I can hope for. Then I look for a general rule for attacking similar problems, that would have led me to approach the given problem in the most efficient way the first time. Often, such a rule is of permanent value.
>
> > [!note] Notes
> > définition originale de l'extension créative

4
programmation distribuée.md Normal file
View File

@ -0,0 +1,4 @@
---
aliases:
- systèmes distribués
---