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 01:36:10 +02:00
parent 685160a5e5
commit 51d4d267c3
38 changed files with 7751 additions and 949 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.obsidian/community-plugins.json vendored
View File

@ -44,5 +44,9 @@
"quick-preview",
"obsidian42-brat",
"obsidian-vault-statistics-plugin",
"obsidian-plugin-toc"
"obsidian-plugin-toc",
"obsidian-pandoc-reference-list",
"obsidian-footnotes",
"better-fn",
"math-in-callout"
]

9
.obsidian/hotkeys.json vendored
View File

@ -766,5 +766,14 @@
],
"key": "A"
}
],
"obsidian-footnotes:insert-autonumbered-footnote": [
{
"modifiers": [
"Ctrl",
"Shift"
],
"key": "F"
}
]
}

4
.obsidian/plugins/better-fn/data.json vendored Normal file
View File

@ -0,0 +1,4 @@
{
"showFnRef": true,
"smooth": true
}

4138
.obsidian/plugins/better-fn/main.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

10
.obsidian/plugins/better-fn/manifest.json vendored Normal file
View File

@ -0,0 +1,10 @@
{
"id": "better-fn",
"name": "Better footnote",
"version": "1.0.1",
"minAppVersion": "0.12.4",
"description": "Footnote popover for Obsidian",
"author": "",
"authorUrl": "",
"isDesktopOnly": true
}

156
.obsidian/plugins/better-fn/styles.css vendored Normal file
View File

@ -0,0 +1,156 @@
sup.footnote-ref {
user-select: none;
cursor: pointer;
color: var(--text-accent);
}
.visuallyhidden:not(:focus):not(:active) {
position: absolute;
width: 1px;
height: 1px;
margin: -1px;
border: 0;
padding: 0;
white-space: nowrap;
clip-path: inset(100%);
overflow: hidden;
}
.markdown-preview-view .tippy-content > span.internal-embed {
min-width: 20em;
}
.markdown-preview-view .tippy-content {
max-height: 20em;
overflow-x: auto;
font-size: calc(var(--editor-font-size) * 0.9);
}
.markdown-preview-view .tippy-content a.footnote-backref {
display: none;
}
span > [data-tippy-root] {
display: inline;
}
section.footnotes li[data-footnote-id] {
transition: background-color 0.5s ease-in-out;
}
.tippy-box[data-theme~="obsidian"] {
background-color: var(--background-primary);
background-clip: padding-box;
border: 1px solid var(--background-modifier-border);
color: var(--text-normal);
box-shadow: 0 4px 14px -2px var(--background-modifier-box-shadow);
}
.tippy-box[data-theme~="obsidian"] > .tippy-backdrop {
background-color: var(--background-primary);
}
.tippy-box[data-theme~="obsidian"] > .tippy-arrow:after,
.tippy-box[data-theme~="obsidian"] > .tippy-svg-arrow:after {
content: "";
position: absolute;
z-index: -1;
}
.tippy-box[data-theme~="obsidian"] > .tippy-arrow:after {
border-color: transparent;
border-style: solid;
}
.tippy-box[data-theme~="obsidian"][data-placement^="top"]
> .tippy-arrow:before {
border-top-color: var(--background-primary);
}
.tippy-box[data-theme~="obsidian"][data-placement^="top"] > .tippy-arrow:after {
border-top-color: var(--background-modifier-border);
border-width: 7px 7px 0;
top: 17px;
left: 1px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="top"]
> .tippy-svg-arrow
> svg {
top: 16px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="top"]
> .tippy-svg-arrow:after {
top: 17px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="bottom"]
> .tippy-arrow:before {
border-bottom-color: var(--background-primary);
bottom: 16px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="bottom"]
> .tippy-arrow:after {
border-bottom-color: var(--background-modifier-border);
border-width: 0 7px 7px;
bottom: 17px;
left: 1px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="bottom"]
> .tippy-svg-arrow
> svg {
bottom: 16px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="bottom"]
> .tippy-svg-arrow:after {
bottom: 17px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="left"]
> .tippy-arrow:before {
border-left-color: var(--background-primary);
}
.tippy-box[data-theme~="obsidian"][data-placement^="left"]
> .tippy-arrow:after {
border-left-color: var(--background-modifier-border);
border-width: 7px 0 7px 7px;
left: 17px;
top: 1px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="left"]
> .tippy-svg-arrow
> svg {
left: 11px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="left"]
> .tippy-svg-arrow:after {
left: 12px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="right"]
> .tippy-arrow:before {
border-right-color: var(--background-primary);
right: 16px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="right"]
> .tippy-arrow:after {
border-width: 7px 7px 7px 0;
right: 17px;
top: 1px;
border-right-color: var(--background-modifier-border);
}
.tippy-box[data-theme~="obsidian"][data-placement^="right"]
> .tippy-svg-arrow
> svg {
right: 11px;
}
.tippy-box[data-theme~="obsidian"][data-placement^="right"]
> .tippy-svg-arrow:after {
right: 12px;
}
.tippy-box[data-theme~="obsidian"] > .tippy-svg-arrow {
fill: var(--background-primary);
}
.tippy-box[data-theme~="obsidian"] > .tippy-svg-arrow:after {
background-image: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMCA2czEuNzk2LS4wMTMgNC42Ny0zLjYxNUM1Ljg1MS45IDYuOTMuMDA2IDggMGMxLjA3LS4wMDYgMi4xNDguODg3IDMuMzQzIDIuMzg1QzE0LjIzMyA2LjAwNSAxNiA2IDE2IDZIMHoiIGZpbGw9InJnYmEoMCwgOCwgMTYsIDAuMikiLz48L3N2Zz4=);
background-size: 16px 6px;
width: 16px;
height: 6px;
}
.tippy-box[data-animation=fade][data-state=hidden]{opacity:0}[data-tippy-root]{max-width:calc(100vw - 10px)}.tippy-box{position:relative;background-color:#333;color:#fff;border-radius:4px;font-size:14px;line-height:1.4;outline:0;transition-property:transform,visibility,opacity}.tippy-box[data-placement^=top]>.tippy-arrow{bottom:0}.tippy-box[data-placement^=top]>.tippy-arrow:before{bottom:-7px;left:0;border-width:8px 8px 0;border-top-color:initial;transform-origin:center top}.tippy-box[data-placement^=bottom]>.tippy-arrow{top:0}.tippy-box[data-placement^=bottom]>.tippy-arrow:before{top:-7px;left:0;border-width:0 8px 8px;border-bottom-color:initial;transform-origin:center bottom}.tippy-box[data-placement^=left]>.tippy-arrow{right:0}.tippy-box[data-placement^=left]>.tippy-arrow:before{border-width:8px 0 8px 8px;border-left-color:initial;right:-7px;transform-origin:center left}.tippy-box[data-placement^=right]>.tippy-arrow{left:0}.tippy-box[data-placement^=right]>.tippy-arrow:before{left:-7px;border-width:8px 8px 8px 0;border-right-color:initial;transform-origin:center right}.tippy-box[data-inertia][data-state=visible]{transition-timing-function:cubic-bezier(.54,1.5,.38,1.11)}.tippy-arrow{width:16px;height:16px;color:#333}.tippy-arrow:before{content:"";position:absolute;border-color:transparent;border-style:solid}.tippy-content{position:relative;padding:5px 9px;z-index:1}
.tippy-box[data-animation=shift-toward-subtle][data-state=hidden]{opacity:0}.tippy-box[data-animation=shift-toward-subtle][data-state=hidden][data-placement^=top][data-state=hidden]{transform:translateY(-5px)}.tippy-box[data-animation=shift-toward-subtle][data-state=hidden][data-placement^=bottom][data-state=hidden]{transform:translateY(5px)}.tippy-box[data-animation=shift-toward-subtle][data-state=hidden][data-placement^=left][data-state=hidden]{transform:translateX(-5px)}.tippy-box[data-animation=shift-toward-subtle][data-state=hidden][data-placement^=right][data-state=hidden]{transform:translateX(5px)}

1
.obsidian/plugins/inline-math/data.json vendored
View File

@ -1,5 +1,6 @@
{
"disableInTable": false,
"disableOnIME": true,
"disableDecorations": false,
"disableAtomicRanges": false
}

28
.obsidian/plugins/inline-math/main.js vendored
View File

@ -27,12 +27,13 @@ __export(main_exports, {
default: () => NoMoreFlicker
});
module.exports = __toCommonJS(main_exports);
var import_obsidian2 = require("obsidian");
var import_obsidian3 = require("obsidian");
// src/settings.ts
var import_obsidian = require("obsidian");
var DEFAULT_SETTINGS = {
disableInTable: false,
disableOnIME: true,
disableDecorations: false,
disableAtomicRanges: false
};
@ -50,6 +51,12 @@ var NoMoreFlickerSettingTab = class extends import_obsidian.PluginSettingTab {
await this.plugin.saveSettings();
});
});
new import_obsidian.Setting(containerEl).setName("Disable when using IME input").setDesc("This option can be helpful for avoiding some strange behavior occurring when using IME inputs after escaping from a math block with the Latex Suite plugin's tabout feature.").addToggle((toggle) => {
toggle.setValue(this.plugin.settings.disableOnIME).onChange(async (disable) => {
this.plugin.settings.disableOnIME = disable;
await this.plugin.saveSettings();
});
});
containerEl.createEl("h4", { text: "Debug mode" });
new import_obsidian.Setting(containerEl).setName("Disable decorations").setDesc("If turned on, decorations to hide braces adjacent to dollar signs are disabled.").addToggle((toggle) => {
toggle.setValue(this.plugin.settings.disableDecorations).onChange(async (disable) => {
@ -100,7 +107,7 @@ function isInlineMathEnd(node, state) {
function selectionSatisfies(state, predicate) {
let ret = false;
const tree = (0, import_language.syntaxTree)(state);
for (const { from, to } of state.selection.ranges) {
for (const { from } of state.selection.ranges) {
const line = state.doc.lineAt(from);
tree.iterate({
from: line.from,
@ -234,8 +241,7 @@ function handleLatexSuiteTabout(state, newSelection) {
const tree = (0, import_language4.syntaxTree)(state);
const doc = state.doc.toString();
const newRanges = [];
for (let i = 0; i < newSelection.ranges.length; i++) {
const range = newSelection.ranges[i];
for (const range of newSelection.ranges) {
const indexNextDollar = doc.indexOf("$", range.to);
if (indexNextDollar >= 0) {
const node = tree.cursorAt(indexNextDollar, 1).node;
@ -266,6 +272,7 @@ function handleLatexSuiteBoxing(state, changes) {
}
// src/transaction-filter.ts
var import_obsidian2 = require("obsidian");
var makeTransactionFilter = (plugin) => {
return import_state3.EditorState.transactionFilter.of((tr) => {
var _a;
@ -273,6 +280,11 @@ var makeTransactionFilter = (plugin) => {
return tr;
const userEvent = (_a = tr.annotation(import_state3.Transaction.userEvent)) == null ? void 0 : _a.split(".")[0];
if (userEvent === "input") {
if (plugin.settings.disableOnIME) {
const view = tr.startState.field(import_obsidian2.editorEditorField);
if (view.composing)
return tr;
}
const changes = getChangesForInsertion(tr.startState, tr.changes);
return [tr, { changes }];
} else if (userEvent === "select" && tr.selection) {
@ -321,9 +333,9 @@ function getChangesForInsertion(state, changes) {
const tree = (0, import_language5.syntaxTree)(state);
const doc = state.doc.toString();
const changesToAdd = [];
const beginningOfChanges = /* @__PURE__ */ new Map();
const beginningOfChanges = /* @__PURE__ */ new Set();
changes.iterChangedRanges((fromA, toA, fromB, toB) => {
beginningOfChanges.set(fromA, true);
beginningOfChanges.add(fromA);
});
for (const range of state.selection.ranges) {
if (range.from >= 1) {
@ -390,7 +402,7 @@ function getChangesForSelection(state, newSelection) {
}
// src/main.ts
var NoMoreFlicker = class extends import_obsidian2.Plugin {
var NoMoreFlicker = class extends import_obsidian3.Plugin {
constructor() {
super(...arguments);
/**
@ -438,7 +450,7 @@ var NoMoreFlicker = class extends import_obsidian2.Plugin {
}
cleanAllMarkdownViews() {
this.app.workspace.iterateAllLeaves((leaf) => {
if (leaf.view instanceof import_obsidian2.MarkdownView) {
if (leaf.view instanceof import_obsidian3.MarkdownView) {
cleanerCallback(leaf.view.editor);
}
});

2
.obsidian/plugins/inline-math/manifest.json vendored
View File

@ -1,7 +1,7 @@
{
"id": "inline-math",
"name": "No more flickering inline math",
"version": "0.3.4",
"version": "0.3.5",
"minAppVersion": "1.3.0",
"description": "No longer disturbed by flickering inline math in Obsidian.",
"author": "Ryota Ushio",

3
.obsidian/plugins/math-in-callout/data.json vendored Normal file
View File

@ -0,0 +1,3 @@
{
"notification": true
}

24
.obsidian/plugins/obsidian-admonition/data.json vendored
View File

@ -1,24 +0,0 @@
{
"userAdmonitions": {},
"syntaxHighlight": false,
"copyButton": false,
"version": "10.0.1",
"autoCollapse": false,
"defaultCollapseType": "open",
"injectColor": true,
"parseTitles": true,
"dropShadow": true,
"hideEmpty": false,
"open": {
"admonitions": true,
"icons": true,
"other": true,
"advanced": false
},
"icons": [],
"useFontAwesome": true,
"rpgDownloadedOnce": false,
"msDocConverted": false,
"useSnippet": false,
"snippetPath": "custom-admonitions.1b06d8"
}

511
.obsidian/plugins/obsidian-admonition/main.js vendored
View File

File diff suppressed because one or more lines are too long

10
.obsidian/plugins/obsidian-admonition/manifest.json vendored
View File

@ -1,10 +0,0 @@
{
"id": "obsidian-admonition",
"name": "Admonition",
"version": "10.2.0",
"minAppVersion": "1.1.0",
"description": "Enhanced callouts for Obsidian.md",
"author": "Jeremy Valentine",
"authorUrl": "",
"isDesktopOnly": false
}

1
.obsidian/plugins/obsidian-admonition/styles.css vendored
View File

File diff suppressed because one or more lines are too long

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

@ -1,6 +1,7 @@
{
"folder": "Excalidraw",
"cropFolder": "",
"annotateFolder": "",
"embedUseExcalidrawFolder": true,
"templateFilePath": "Excalidraw/Template.excalidraw",
"scriptFolderPath": "Excalidraw/Scripts",
@ -15,6 +16,7 @@
"drawingFilenameDateTime": "YYYY-MM-DD HH.mm.ss",
"useExcalidrawExtension": true,
"cropPrefix": "cropped_",
"annotatePrefix": "annotated_",
"displaySVGInPreview": true,
"previewImageType": "SVGIMG",
"allowImageCache": true,
@ -30,6 +32,7 @@
"matchThemeTrigger": true,
"defaultMode": "normal",
"defaultPenMode": "mobile",
"penModeCrosshairVisible": false,
"allowPinchZoom": false,
"allowWheelZoom": false,
"zoomToFitOnOpen": true,
@ -69,6 +72,7 @@
"experimentalFileType": true,
"experimentalFileTag": "✏️",
"experimentalLivePreview": true,
"fadeOutExcalidrawMarkup": false,
"experimentalEnableFourthFont": true,
"experimantalFourthFont": "cmu-sans-serif/cmunss.ttf",
"fieldSuggester": true,
@ -73800,7 +73804,7 @@
}
},
"defaultTrayMode": false,
"previousRelease": "2.0.25",
"previousRelease": "2.1.1",
"showReleaseNotes": true,
"showNewVersionNotification": true,
"latexBoilerplate": "\\color{blue}",
@ -74445,5 +74449,7 @@
},
"slidingPanesSupport": false,
"areaZoomLimit": 1,
"longPressDesktop": 500,
"longPressMobile": 500,
"mathjaxSourceURL": "https://cdn.jsdelivr.net/npm/mathjax@3.2.1/es5/tex-svg.js"
}

18
.obsidian/plugins/obsidian-excalidraw-plugin/main.js vendored
View File

File diff suppressed because one or more lines are too long

2
.obsidian/plugins/obsidian-excalidraw-plugin/manifest.json vendored
View File

@ -1,7 +1,7 @@
{
"id": "obsidian-excalidraw-plugin",
"name": "Excalidraw",
"version": "2.0.25",
"version": "2.1.1",
"minAppVersion": "1.1.6",
"description": "An Obsidian plugin to edit and view Excalidraw drawings",
"author": "Zsolt Viczian",

2
.obsidian/plugins/obsidian-excalidraw-plugin/styles.css vendored
View File

File diff suppressed because one or more lines are too long

487
.obsidian/plugins/obsidian-footnotes/main.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

10
.obsidian/plugins/obsidian-footnotes/manifest.json vendored Normal file
View File

@ -0,0 +1,10 @@
{
"id": "obsidian-footnotes",
"name": "Footnote Shortcut",
"version": "0.1.3",
"minAppVersion": "0.12.0",
"description": "Insert and write footnotes faster",
"author": "Alexis Rondeau, Micha Brugger, Jason Qin",
"authorUrl": "https://publish.obsidian.md/alexisrondeau",
"isDesktopOnly": false
}

114
.obsidian/plugins/obsidian-outliner/main.js vendored
View File

File diff suppressed because one or more lines are too long

4
.obsidian/plugins/obsidian-outliner/manifest.json vendored
View File

@ -1,8 +1,8 @@
{
"id": "obsidian-outliner",
"name": "Outliner",
"version": "4.8.0",
"minAppVersion": "1.1.16",
"version": "4.8.1",
"minAppVersion": "1.5.11",
"description": "Work with your lists like in Workflowy or RoamResearch.",
"author": "Viacheslav Slinko",
"authorUrl": "https://github.com/vslinko",

25
.obsidian/plugins/obsidian-pandoc-reference-list/data.json vendored Normal file
View File

@ -0,0 +1,25 @@
{
"pathToPandoc": "/opt/homebrew/bin/pandoc",
"tooltipDelay": 400,
"zoteroGroups": [
{
"id": 2,
"name": "memoire-L3",
"lastUpdate": 1712011619721
},
{
"id": 1,
"name": "Ma bibliothèque",
"lastUpdate": 1712011619734
}
],
"renderCitations": true,
"renderCitationsReadingMode": true,
"renderLinkCitations": true,
"pullFromZotero": true,
"cslStyleURL": "https://raw.githubusercontent.com/citation-style-language/styles/master/apa.csl",
"enableCiteKeyCompletion": true,
"pathToBibliography": "/Users/oscarplaisant/devoirs/cours/bibliography/pandoc_reference_list.bib",
"hideLinks": false,
"showCitekeyTooltips": true
}

2
.obsidian/plugins/obsidian-spaced-repetition/data.json vendored
View File

@ -43,7 +43,7 @@
"singlelineCardSeparator": "::",
"singlelineReversedCardSeparator": ":::"
},
"buryDate": "2024-04-01",
"buryDate": "2024-04-02",
"buryList": [],
"historyDeck": ""
}

30
.obsidian/plugins/obsidian-spaced-repetition/main.js vendored
View File

File diff suppressed because one or more lines are too long

2
.obsidian/plugins/obsidian-spaced-repetition/manifest.json vendored
View File

@ -1,7 +1,7 @@
{
"id": "obsidian-spaced-repetition",
"name": "Spaced Repetition",
"version": "1.12.1",
"version": "1.12.2",
"minAppVersion": "0.15.4",
"description": "Fight the forgetting curve by reviewing flashcards & entire notes.",
"author": "Stephen Mwangi",

66
.obsidian/plugins/supercharged-links-obsidian/main.js vendored
View File

File diff suppressed because one or more lines are too long

5
.obsidian/plugins/supercharged-links-obsidian/manifest.json vendored
View File

@ -1,10 +1,11 @@
{
"id": "supercharged-links-obsidian",
"name": "Supercharged Links",
"version": "0.11.1",
"minAppVersion": "1.4.0",
"version": "0.12.1",
"minAppVersion": "1.5.11",
"description": "Add properties and menu options to links and style them!",
"author": "mdelobelle & Emile",
"authorUrl": "https://github.com/mdelobelle/mdelobelle/tree/main",
"helpUrl": "https://github.com/mdelobelle/obsidian_supercharged_links#readme",
"isDesktopOnly": false
}

4
.obsidian/plugins/supercharged-links-obsidian/styles.css vendored
View File

@ -9,3 +9,7 @@ div.supercharged-modal {
div.supercharged-modal h4 {
margin: 0;
}
span.data-link-text > a.cm-underline {
color: inherit;
}

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}}}}
{"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}}}}

5
.obsidian/types.json vendored
View File

@ -20,7 +20,8 @@
"excalidraw-font-color": "text",
"excalidraw-border-color": "text",
"excalidraw-css": "text",
"excalidraw-autoexport": "checkbox",
"excalidraw-iframe-theme": "text"
"excalidraw-autoexport": "text",
"excalidraw-iframe-theme": "text",
"excalidraw-open-md": "checkbox"
}
}

1859
.pandoc/apa.csl Normal file
View File

File diff suppressed because it is too large Load Diff

774
.pandoc/locales-en-US.xml Normal file
View File

@ -0,0 +1,774 @@
<?xml version="1.0" encoding="utf-8"?>
<locale xmlns="http://purl.org/net/xbiblio/csl" version="1.0" xml:lang="en-US">
<info>
<translator>
<name>Andrew Dunning</name>
</translator>
<translator>
<name>Sebastian Karcher</name>
</translator>
<translator>
<name>Rintze M. Zelle</name>
</translator>
<translator>
<name>Denis Meier</name>
</translator>
<translator>
<name>Brenton M. Wiernik</name>
</translator>
<rights license="http://creativecommons.org/licenses/by-sa/3.0/">This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 License</rights>
<updated>2024-03-12T13:41:31+00:00</updated>
</info>
<style-options punctuation-in-quote="true"/>
<date form="text">
<date-part name="month" suffix=" "/>
<date-part name="day" suffix=", "/>
<date-part name="year"/>
</date>
<date form="numeric">
<date-part name="month" form="numeric-leading-zeros" suffix="/"/>
<date-part name="day" form="numeric-leading-zeros" suffix="/"/>
<date-part name="year"/>
</date>
<terms>
<!-- GENERAL TERMS -->
<term name="accessed">accessed</term>
<term name="advance-online-publication">advance online publication</term>
<term name="album">album</term>
<term name="and">and</term>
<term name="and others">and others</term>
<term name="anonymous">anonymous</term>
<term name="anonymous" form="short">anon.</term>
<term name="at">at</term>
<term name="audio-recording">audio recording</term>
<term name="available at">available at</term>
<term name="by">by</term>
<term name="circa">circa</term>
<term name="circa" form="short">c.</term>
<term name="cited">cited</term>
<term name="et-al">et al.</term>
<term name="film">film</term>
<term name="forthcoming">forthcoming</term>
<term name="from">from</term>
<term name="henceforth">henceforth</term>
<term name="ibid">ibid.</term>
<term name="in">in</term>
<term name="in press">in press</term>
<term name="internet">internet</term>
<term name="letter">letter</term>
<term name="loc-cit">loc. cit.</term> <!-- like ibid., the abbreviated form is the regular form -->
<term name="no date">no date</term>
<term name="no date" form="short">n.d.</term>
<term name="no-place">no place</term>
<term name="no-place" form="short">n.p.</term>
<term name="no-publisher">no publisher</term> <!-- sine nomine -->
<term name="no-publisher" form="short">n.p.</term>
<term name="on">on</term>
<term name="online">online</term>
<term name="op-cit">op. cit.</term> <!-- like ibid., the abbreviated form is the regular form -->
<term name="original-work-published">original work published</term>
<term name="personal-communication">personal communication</term>
<term name="podcast">podcast</term>
<term name="podcast-episode">podcast episode</term>
<term name="preprint">preprint</term>
<term name="presented at">presented at the</term>
<term name="radio-broadcast">radio broadcast</term>
<term name="radio-series">radio series</term>
<term name="radio-series-episode">radio series episode</term>
<term name="reference">
<single>reference</single>
<multiple>references</multiple>
</term>
<term name="reference" form="short">
<single>ref.</single>
<multiple>refs.</multiple>
</term>
<term name="retrieved">retrieved</term>
<term name="review-of">review of</term>
<term name="review-of" form="short">rev. of</term>
<term name="scale">scale</term>
<term name="special-issue">special issue</term>
<term name="special-section">special section</term>
<term name="television-broadcast">television broadcast</term>
<term name="television-series">television series</term>
<term name="television-series-episode">television series episode</term>
<term name="video">video</term>
<term name="working-paper">working paper</term>
<!-- LONG ITEM TYPE FORMS -->
<term name="article">preprint</term>
<term name="article-journal">journal article</term>
<term name="article-magazine">magazine article</term>
<term name="article-newspaper">newspaper article</term>
<term name="bill">bill</term>
<!-- book is in the list of locator terms -->
<term name="broadcast">broadcast</term>
<!-- chapter is in the list of locator terms -->
<term name="classic">classic</term>
<term name="collection">collection</term>
<term name="dataset">dataset</term>
<term name="document">document</term>
<term name="entry">entry</term>
<term name="entry-dictionary">dictionary entry</term>
<term name="entry-encyclopedia">encyclopedia entry</term>
<term name="event">event</term>
<!-- figure is in the list of locator terms -->
<term name="graphic">graphic</term>
<term name="hearing">hearing</term>
<term name="interview">interview</term>
<term name="legal_case">legal case</term>
<term name="legislation">legislation</term>
<term name="manuscript">manuscript</term>
<term name="map">map</term>
<term name="motion_picture">video recording</term>
<term name="musical_score">musical score</term>
<term name="pamphlet">pamphlet</term>
<term name="paper-conference">conference paper</term>
<term name="patent">patent</term>
<term name="performance">performance</term>
<term name="periodical">periodical</term>
<term name="personal_communication">personal communication</term>
<term name="post">post</term>
<term name="post-weblog">blog post</term>
<term name="regulation">regulation</term>
<term name="report">report</term>
<term name="review">review</term>
<term name="review-book">book review</term>
<term name="software">software</term>
<term name="song">audio recording</term>
<term name="speech">presentation</term>
<term name="standard">standard</term>
<term name="thesis">thesis</term>
<term name="treaty">treaty</term>
<term name="webpage">webpage</term>
<!-- SHORT ITEM TYPE FORMS -->
<term name="article-journal" form="short">journal art.</term>
<term name="article-magazine" form="short">mag. art.</term>
<term name="article-newspaper" form="short">newspaper art.</term>
<!-- book is in the list of locator terms -->
<!-- chapter is in the list of locator terms -->
<term name="document" form="short">doc.</term>
<!-- figure is in the list of locator terms -->
<term name="graphic" form="short">graph.</term>
<term name="interview" form="short">interv.</term>
<term name="manuscript" form="short">MS</term>
<term name="motion_picture" form="short">video rec.</term>
<term name="report" form="short">rep.</term>
<term name="review" form="short">rev.</term>
<term name="review-book" form="short">bk. rev.</term>
<term name="song" form="short">audio rec.</term>
<!-- VERB ITEM TYPE FORMS -->
<!-- Only where applicable -->
<term name="hearing" form="verb">testimony of</term>
<term name="review" form="verb">review of</term>
<term name="review-book" form="verb">review of the book</term>
<!-- HISTORICAL ERA TERMS -->
<term name="ad">AD</term>
<term name="bc">BC</term>
<term name="bce">BCE</term>
<term name="ce">CE</term>
<!-- PUNCTUATION -->
<term name="open-quote">“</term>
<term name="close-quote">”</term>
<term name="open-inner-quote">‘</term>
<term name="close-inner-quote">’</term>
<term name="page-range-delimiter">–</term>
<term name="colon">:</term>
<term name="comma">,</term>
<term name="semicolon">;</term>
<!-- ORDINALS -->
<term name="ordinal">th</term>
<term name="ordinal-01">st</term>
<term name="ordinal-02">nd</term>
<term name="ordinal-03">rd</term>
<term name="ordinal-11">th</term>
<term name="ordinal-12">th</term>
<term name="ordinal-13">th</term>
<!-- LONG ORDINALS -->
<term name="long-ordinal-01">first</term>
<term name="long-ordinal-02">second</term>
<term name="long-ordinal-03">third</term>
<term name="long-ordinal-04">fourth</term>
<term name="long-ordinal-05">fifth</term>
<term name="long-ordinal-06">sixth</term>
<term name="long-ordinal-07">seventh</term>
<term name="long-ordinal-08">eighth</term>
<term name="long-ordinal-09">ninth</term>
<term name="long-ordinal-10">tenth</term>
<!-- LONG LOCATOR FORMS -->
<term name="act">
<single>act</single>
<multiple>acts</multiple>
</term>
<term name="appendix">
<single>appendix</single>
<multiple>appendices</multiple>
</term>
<term name="article-locator">
<single>article</single>
<multiple>articles</multiple>
</term>
<term name="book">
<single>book</single>
<multiple>books</multiple>
</term>
<term name="canon">
<single>canon</single>
<multiple>canons</multiple>
</term>
<term name="chapter">
<single>chapter</single>
<multiple>chapters</multiple>
</term>
<term name="column">
<single>column</single>
<multiple>columns</multiple>
</term>
<term name="elocation">
<single>location</single>
<multiple>locations</multiple>
</term>
<term name="equation">
<single>equation</single>
<multiple>equations</multiple>
</term>
<term name="figure">
<single>figure</single>
<multiple>figures</multiple>
</term>
<term name="folio">
<single>folio</single>
<multiple>folios</multiple>
</term>
<term name="issue">
<single>number</single>
<multiple>numbers</multiple>
</term>
<term name="line">
<single>line</single>
<multiple>lines</multiple>
</term>
<term name="note">
<single>note</single>
<multiple>notes</multiple>
</term>
<term name="opus">
<single>opus</single>
<multiple>opera</multiple>
</term>
<term name="page">
<single>page</single>
<multiple>pages</multiple>
</term>
<term name="paragraph">
<single>paragraph</single>
<multiple>paragraphs</multiple>
</term>
<term name="part">
<single>part</single>
<multiple>parts</multiple>
</term>
<term name="rule">
<single>rule</single>
<multiple>rules</multiple>
</term>
<term name="scene">
<single>scene</single>
<multiple>scenes</multiple>
</term>
<term name="section">
<single>section</single>
<multiple>sections</multiple>
</term>
<term name="sub-verbo">
<single>sub verbo</single>
<multiple>sub verbis</multiple>
</term>
<term name="supplement">
<single>supplement</single>
<multiple>supplements</multiple>
</term>
<term name="table">
<single>table</single>
<multiple>tables</multiple>
</term>
<term name="timestamp"> <!-- generally blank -->
<single></single>
<multiple></multiple>
</term>
<term name="title-locator">
<single>title</single>
<multiple>titles</multiple>
</term>
<term name="verse">
<single>verse</single>
<multiple>verses</multiple>
</term>
<term name="version">
<single>version</single>
<multiple>versions</multiple>
</term>
<term name="volume">
<single>volume</single>
<multiple>volumes</multiple>
</term>
<!-- SHORT LOCATOR FORMS -->
<!-- Omitted short forms: act, timestamp -->
<term name="appendix" form="short">
<single>app.</single>
<multiple>apps.</multiple>
</term>
<term name="article-locator" form="short">
<single>art.</single>
<multiple>arts.</multiple>
</term>
<term name="book" form="short">
<single>bk.</single>
<multiple>bks.</multiple>
</term>
<term name="canon" form="short">
<single>c.</single>
<multiple>cc.</multiple>
</term>
<term name="chapter" form="short">
<single>chap.</single>
<multiple>chaps.</multiple>
</term>
<term name="column" form="short">
<single>col.</single>
<multiple>cols.</multiple>
</term>
<term name="elocation" form="short">
<single>loc.</single>
<multiple>locs.</multiple>
</term>
<term name="equation" form="short">
<single>eq.</single>
<multiple>eqs.</multiple>
</term>
<term name="figure" form="short">
<single>fig.</single>
<multiple>figs.</multiple>
</term>
<term name="folio" form="short">
<single>fol.</single>
<multiple>fols.</multiple>
</term>
<term name="issue" form="short">
<single>no.</single>
<multiple>nos.</multiple>
</term>
<term name="line" form="short">
<single>l.</single>
<multiple>ll.</multiple>
</term>
<term name="note" form="short">
<single>n.</single>
<multiple>nn.</multiple>
</term>
<term name="opus" form="short">
<single>op.</single>
<multiple>opp.</multiple>
</term>
<term name="page" form="short">
<single>p.</single>
<multiple>pp.</multiple>
</term>
<term name="paragraph" form="short">
<single>para.</single>
<multiple>paras.</multiple>
</term>
<term name="part" form="short">
<single>pt.</single>
<multiple>pts.</multiple>
</term>
<term name="rule" form="short">
<single>r.</single>
<multiple>rr.</multiple>
</term>
<term name="scene" form="short">
<single>sc.</single>
<multiple>scs.</multiple>
</term>
<term name="section" form="short">
<single>sec.</single>
<multiple>secs.</multiple>
</term>
<term name="sub-verbo" form="short">
<single>s.v.</single>
<multiple>s.vv.</multiple>
</term>
<term name="supplement" form="short">
<single>supp.</single>
<multiple>supps.</multiple>
</term>
<term name="table" form="short">
<single>tbl.</single>
<multiple>tbls.</multiple>
</term>
<term name="title-locator" form="short">
<single>tit.</single>
<multiple>tits.</multiple>
</term>
<term name="verse" form="short">
<single>v.</single>
<multiple>vv.</multiple>
</term>
<term name="version" form="short">
<single>v.</single>
<multiple>v.</multiple>
</term>
<term name="volume" form="short">
<single>vol.</single>
<multiple>vols.</multiple>
</term>
<!-- SYMBOL LOCATOR FORMS -->
<term name="paragraph" form="symbol">
<single></single>
<multiple>¶¶</multiple>
</term>
<term name="section" form="symbol">
<single>§</single>
<multiple>§§</multiple>
</term>
<!-- LONG NUMBER VARIABLE FORMS -->
<term name="chapter-number">
<single>chapter</single>
<multiple>chapters</multiple>
</term>
<term name="citation-number">
<single>citation</single>
<multiple>citations</multiple>
</term>
<term name="collection-number">
<single>number</single>
<multiple>numbers</multiple>
</term>
<term name="edition">
<single>edition</single>
<multiple>editions</multiple>
</term>
<term name="first-reference-note-number">
<single>reference</single>
<multiple>references</multiple>
</term>
<term name="number">
<single>number</single>
<multiple>numbers</multiple>
</term>
<term name="number-of-pages">
<single>page</single>
<multiple>pages</multiple>
</term>
<term name="number-of-volumes">
<single>volume</single>
<multiple>volumes</multiple>
</term>
<term name="page-first">
<single>page</single>
<multiple>pages</multiple>
</term>
<term name="printing">
<single>printing</single>
<multiple>printings</multiple>
</term>
<!-- SHORT NUMBER VARIABLE FORMS -->
<term name="chapter-number" form="short">
<single>chap.</single>
<multiple>chaps.</multiple>
</term>
<term name="citation-number" form="short">
<single>cit.</single>
<multiple>cits.</multiple>
</term>
<term name="collection-number" form="short">
<single>no.</single>
<multiple>nos.</multiple>
</term>
<term name="edition" form="short">
<single>ed.</single>
<multiple>eds.</multiple>
</term>
<term name="first-reference-note-number" form="short">
<single>ref.</single>
<multiple>refs.</multiple>
</term>
<term name="number" form="short">
<single>no.</single>
<multiple>nos.</multiple>
</term>
<term name="number-of-pages" form="short">
<single>p.</single>
<multiple>pp.</multiple>
</term>
<term name="number-of-volumes" form="short">
<single>vol.</single>
<multiple>vols.</multiple>
</term>
<term name="page-first" form="short">
<single>p.</single>
<multiple>pp.</multiple>
</term>
<term name="printing" form="short">
<single>print.</single>
<multiple>prints.</multiple>
</term>
<!-- LONG ROLE FORMS -->
<!-- Omitted roles:
author, composer, container-author, interviewer, original-author, recipient, reviewed-author
-->
<term name="chair">
<single>chair</single>
<multiple>chairs</multiple>
</term>
<term name="collection-editor">
<single>editor</single>
<multiple>editors</multiple>
</term>
<term name="compiler">
<single>compiler</single>
<multiple>compilers</multiple>
</term>
<term name="contributor">
<single>contributor</single>
<multiple>contributors</multiple>
</term>
<term name="curator">
<single>curator</single>
<multiple>curators</multiple>
</term>
<term name="director">
<single>director</single>
<multiple>directors</multiple>
</term>
<term name="editor">
<single>editor</single>
<multiple>editors</multiple>
</term>
<term name="editortranslator">
<single>editor &amp; translator</single>
<multiple>editors &amp; translators</multiple>
</term>
<term name="editorial-director">
<single>editor</single>
<multiple>editors</multiple>
</term>
<term name="executive-producer">
<single>executive producer</single>
<multiple>executive producers</multiple>
</term>
<term name="guest">
<single>guest</single>
<multiple>guests</multiple>
</term>
<term name="host">
<single>host</single>
<multiple>hosts</multiple>
</term>
<term name="illustrator">
<single>illustrator</single>
<multiple>illustrators</multiple>
</term>
<term name="narrator">
<single>narrator</single>
<multiple>narrators</multiple>
</term>
<term name="organizer">
<single>organizer</single>
<multiple>organizers</multiple>
</term>
<term name="performer">
<single>performer</single>
<multiple>performers</multiple>
</term>
<term name="producer">
<single>producer</single>
<multiple>producers</multiple>
</term>
<term name="script-writer">
<single>writer</single>
<multiple>writers</multiple>
</term>
<term name="series-creator">
<single>series creator</single>
<multiple>series creators</multiple>
</term>
<term name="translator">
<single>translator</single>
<multiple>translators</multiple>
</term>
<!-- SHORT ROLE FORMS -->
<!-- Omitted roles:
author, chair, composer, container-author, guest, host, interviewer, original-author, recipient, reviewed-author
-->
<term name="collection-editor" form="short">
<single>ed.</single>
<multiple>eds.</multiple>
</term>
<term name="compiler" form="short">
<single>comp.</single>
<multiple>comps.</multiple>
</term>
<term name="contributor" form="short">
<single>contrib.</single>
<multiple>contribs.</multiple>
</term>
<term name="curator" form="short">
<single>cur.</single>
<multiple>curs.</multiple>
</term>
<term name="director" form="short">
<single>dir.</single>
<multiple>dirs.</multiple>
</term>
<term name="editor" form="short">
<single>ed.</single>
<multiple>eds.</multiple>
</term>
<term name="editortranslator" form="short">
<single>ed. &amp; tran.</single>
<multiple>eds. &amp; trans.</multiple>
</term>
<term name="editorial-director" form="short">
<single>ed.</single>
<multiple>eds.</multiple>
</term>
<term name="executive-producer" form="short">
<single>exec. prod.</single>
<multiple>exec. prods.</multiple>
</term>
<term name="illustrator" form="short">
<single>ill.</single>
<multiple>ills.</multiple>
</term>
<term name="narrator" form="short">
<single>narr.</single>
<multiple>narrs.</multiple>
</term>
<term name="organizer" form="short">
<single>org.</single>
<multiple>orgs.</multiple>
</term>
<term name="performer" form="short">
<single>perf.</single>
<multiple>perfs.</multiple>
</term>
<term name="producer" form="short">
<single>prod.</single>
<multiple>prods.</multiple>
</term>
<term name="script-writer" form="short">
<single>writ.</single>
<multiple>writs.</multiple>
</term>
<term name="series-creator" form="short">
<single>cre.</single>
<multiple>cres.</multiple>
</term>
<term name="translator" form="short">
<single>tran.</single>
<multiple>trans.</multiple>
</term>
<!-- VERB ROLE FORMS -->
<term name="author" form="verb">by</term>
<term name="chair" form="verb">chaired by</term>
<term name="collection-editor" form="verb">edited by</term>
<term name="compiler" form="verb">compiled by</term>
<term name="composer" form="verb">composed by</term>
<term name="container-author" form="verb">by</term>
<term name="contributor" form="verb">with</term>
<term name="curator" form="verb">curated by</term>
<term name="director" form="verb">directed by</term>
<term name="editor" form="verb">edited by</term>
<term name="editortranslator" form="verb">edited &amp; translated by</term>
<term name="editorial-director" form="verb">edited by</term>
<term name="executive-producer" form="verb">executive produced by</term>
<term name="guest" form="verb">with guest</term>
<term name="host" form="verb">hosted by</term>
<term name="illustrator" form="verb">illustrated by</term>
<term name="interviewer" form="verb">interview by</term>
<term name="narrator" form="verb">narrated by</term>
<term name="organizer" form="verb">organized by</term>
<term name="original-author" form="verb">by</term>
<term name="performer" form="verb">performed by</term>
<term name="producer" form="verb">produced by</term>
<term name="recipient" form="verb">to</term>
<term name="reviewed-author" form="verb">by</term>
<term name="script-writer" form="verb">written by</term>
<term name="series-creator" form="verb">created by</term>
<term name="translator" form="verb">translated by</term>
<!-- SHORT VERB ROLE FORMS -->
<!-- Omitted roles:
author, chair, container-author, host, interviewer, original-author, recipient, reviewed-author
-->
<term name="collection-editor" form="verb-short">ed. by</term>
<term name="compiler" form="verb-short">comp. by</term>
<term name="composer" form="verb-short">comp. by</term>
<term name="contributor" form="verb-short">w.</term>
<term name="curator" form="verb-short">cur. by</term>
<term name="director" form="verb-short">dir. by</term>
<term name="editor" form="verb-short">ed. by</term>
<term name="editortranslator" form="verb-short">ed. &amp; trans. by</term>
<term name="editorial-director" form="verb-short">ed. by</term>
<term name="executive-producer" form="verb-short">exec. prod. by</term>
<term name="guest" form="verb-short">w. guest</term>
<term name="illustrator" form="verb-short">illus. by</term>
<term name="narrator" form="verb-short">narr. by</term>
<term name="organizer" form="verb-short">org. by</term>
<term name="performer" form="verb-short">perf. by</term>
<term name="producer" form="verb-short">prod. by</term>
<term name="script-writer" form="verb-short">writ. by</term>
<term name="series-creator" form="verb-short">cre. by</term>
<term name="translator" form="verb-short">trans. by</term>
<!-- LONG MONTH FORMS -->
<term name="month-01">January</term>
<term name="month-02">February</term>
<term name="month-03">March</term>
<term name="month-04">April</term>
<term name="month-05">May</term>
<term name="month-06">June</term>
<term name="month-07">July</term>
<term name="month-08">August</term>
<term name="month-09">September</term>
<term name="month-10">October</term>
<term name="month-11">November</term>
<term name="month-12">December</term>
<!-- SHORT MONTH FORMS -->
<term name="month-01" form="short">Jan.</term>
<term name="month-02" form="short">Feb.</term>
<term name="month-03" form="short">Mar.</term>
<term name="month-04" form="short">Apr.</term>
<term name="month-05" form="short">May</term>
<term name="month-06" form="short">Jun.</term>
<term name="month-07" form="short">Jul.</term>
<term name="month-08" form="short">Aug.</term>
<term name="month-09" form="short">Sep.</term>
<term name="month-10" form="short">Oct.</term>
<term name="month-11" form="short">Nov.</term>
<term name="month-12" form="short">Dec.</term>
<!-- SEASONS -->
<term name="season-01">Spring</term>
<term name="season-02">Summer</term>
<term name="season-03">Autumn</term>
<term name="season-04">Winter</term>
</terms>
</locale>

3
.pandoc/zotero-library-1.json Normal file
View File

@ -0,0 +1,3 @@
[
{"id":"floydParadigmsProgramming1979","author":[{"family":"Floyd","given":"Robert W."}],"citation-key":"floydParadigmsProgramming1979","container-title":"Communication of the ACM","DOI":"10.1145/359138.359140","issue":"8","issued":{"date-parts":[["1979",8,1]]},"language":"English","page":"455-460","title":"The paradigms of programming","type":"article-journal","URL":"https://dl.acm.org/doi/10.1145/359138.359140","volume":"22"}
]

35
.pandoc/zotero-library-2.json Normal file
View File

@ -0,0 +1,35 @@
[
{"id":"abelsonStructureInterpretationComputer1996","accessed":{"date-parts":[["2024",3,29]]},"author":[{"family":"Abelson","given":"Harold"},{"family":"Sussman","given":"Gerald Jay"},{"family":"Sussman","given":"Julie"}],"citation-key":"abelsonStructureInterpretationComputer1996","edition":"2","event-place":"Cambridge, Massachusetts, London, England","issued":{"date-parts":[["1996"]]},"language":"en","publisher":"MIT Press","publisher-place":"Cambridge, Massachusetts, London, England","source":"Zotero","title":"Structure and Interpretation of Computer Programs","type":"book","URL":"http://mitpress.mit.edu/sicp"},
{"id":"AutomatePile2021","abstract":"Un automate à pile est une machine abstraite utilisée en informatique théorique et, plus précisément, en théorie des automates.\nUn automate à pile est une généralisation des automates finis : il dispose en plus d'une mémoire infinie organisée en pile (last-in/first-out ou LIFO). Un automate à pile prend en entrée un mot et réalise une série de transitions. Il effectue pour chaque lettre du mot une transition, dont le choix dépend de la lettre, de l'état de l'automate et du sommet de la pile ; il peut aussi modifier le contenu de la pile. Selon l'état de l'automate et de la pile à la fin du calcul, le mot est accepté ou refusé.\nLes langages reconnus par les automates à piles sont exactement les langages algébriques, c'est-à-dire ceux engendrés par une grammaire algébrique.\nL'importance des automates à pile vient de leur emploi en analyse syntaxique des langages de programmation, et plus généralement dans la transformation de définitions ou d'algorithmes récursifs en leurs analogues itératifs.","accessed":{"date-parts":[["2024",3,31]]},"citation-key":"AutomatePile2021","container-title":"Wikipédia","issued":{"date-parts":[["2021",10,29]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 187552887","source":"Wikipedia","title":"Automate à pile","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Automate_%C3%A0_pile&oldid=187552887"},
{"id":"billaudProgrammationFonctionnelleSymbolique1989","accessed":{"date-parts":[["2024",3,28]]},"author":[{"family":"Billaud","given":"Michel"}],"citation-key":"billaudProgrammationFonctionnelleSymbolique1989","container-title":"Page personnelle de Michel Billaud","issued":{"date-parts":[["1989"]]},"title":"Programmation Fonctionnelle et Symbolique - Introduction","type":"webpage","URL":"https://www.mbillaud.fr/SITE-PERSO-LABRI/travaux/lisp89/1intro.html"},
{"id":"brown10ThingsSoftware2023","abstract":"Understanding how human memory and learning works, the differences between beginners and experts, and practical steps developers can take to improve their learning, training, and recruitment.","accessed":{"date-parts":[["2024",3,14]]},"author":[{"family":"Brown","given":"Neil C. C."},{"family":"Hermans","given":"Felienne F. J."},{"family":"Margulieux","given":"Lauren E."}],"citation-key":"brown10ThingsSoftware2023","container-title":"Communications of the ACM","container-title-short":"Commun. ACM","DOI":"10.1145/3584859","ISSN":"0001-0782","issue":"1","issued":{"date-parts":[["2023",12,21]]},"page":"78–87","source":"ACM Digital Library","title":"10 Things Software Developers Should Learn about Learning","type":"article-journal","URL":"https://dl.acm.org/doi/10.1145/3584859","volume":"67"},
{"id":"cainLectureProgrammingParadigms2018","accessed":{"date-parts":[["2024",2,20]]},"author":[{"family":"Cain","given":"Jerry"}],"citation-key":"cainLectureProgrammingParadigms2018","event-place":"Stanford","issued":{"date-parts":[["2018",7,19]]},"language":"English","publisher-place":"Stanford","title":"Lecture 1 | Programming Paradigms","type":"speech","URL":"https://www.youtube.com/watch?v=Ps8jOj7diA0&list=PL9D558D49CA734A02"},
{"id":"ComparisonMultiparadigmProgramming2024","abstract":"Programming languages can be grouped by the number and types of paradigms supported.","accessed":{"date-parts":[["2024",2,20]]},"citation-key":"ComparisonMultiparadigmProgramming2024","container-title":"Wikipedia","issued":{"date-parts":[["2024",2,1]]},"language":"en","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 1202029082","source":"Wikipedia","title":"Comparison of multi-paradigm programming languages","type":"entry-encyclopedia","URL":"https://en.wikipedia.org/w/index.php?title=Comparison_of_multi-paradigm_programming_languages&oldid=1202029082"},
{"id":"ComparisonProgrammingParadigms2024","abstract":"This article attempts to set out the various similarities and differences between the various programming paradigms as a summary in both graphical and tabular format with links to the separate discussions concerning these similarities and differences in extant Wikipedia articles.","accessed":{"date-parts":[["2024",2,26]]},"citation-key":"ComparisonProgrammingParadigms2024","container-title":"Wikipedia","issued":{"date-parts":[["2024",2,1]]},"language":"en","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 1202049782","source":"Wikipedia","title":"Comparison of programming paradigms","type":"entry-encyclopedia","URL":"https://en.wikipedia.org/w/index.php?title=Comparison_of_programming_paradigms&oldid=1202049782"},
{"id":"dijkstraChapterNotesStructured1972","accessed":{"date-parts":[["2024",4,1]]},"author":[{"family":"Dijkstra","given":"Edsger W."}],"citation-key":"dijkstraChapterNotesStructured1972","container-title":"Structured programming","event-place":"GBR","ISBN":"978-0-12-200550-3","issued":{"date-parts":[["1972",1,1]]},"page":"1–82","publisher":"Academic Press Ltd.","publisher-place":"GBR","source":"ACM Digital Library","title":"Chapter I: Notes on structured programming","title-short":"Chapter I","type":"chapter"},
{"id":"EffetBordInformatique2023","abstract":"En informatique, une fonction est dite à effet de bord (traduction mot à mot de l'anglais side effect, dont le sens est plus proche d'effet secondaire) si elle modifie un état en dehors de son environnement local, c'est-à-dire a une interaction observable avec le monde extérieur autre que retourner une valeur. Par exemple, les fonctions qui modifient une variable locale statique, une variable non locale ou un argument mutable passé par référence, les fonctions qui effectuent des opérations d'entrées-sorties ou les fonctions appelant d'autres fonctions à effet de bord. Souvent, ces effets compliquent la lisibilité du comportement des programmes et/ou nuisent à la réutilisabilité des fonctions et procédures. Un langage comme Haskell les restreint délibérément dans des composants nommés monades.\nPlus communément, un effet de bord apparaît la plupart du temps lorsqu'une modification d'un programme cohérent (valeurs et états pris conformes aux spécifications) aboutit à des valeurs ou des comportements non prévus, à cause de la non prise en compte de la portée, de l'ensemble de définition de variables, ou du contrat des fonctions.","accessed":{"date-parts":[["2024",3,28]]},"citation-key":"EffetBordInformatique2023","container-title":"Wikipédia","issued":{"date-parts":[["2023",8,30]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 207397507","source":"Wikipedia","title":"Effet de bord (informatique)","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Effet_de_bord_(informatique)&oldid=207397507"},
{"id":"EnregistrementStructureDonnees2023","abstract":"En programmation, un enregistrement est une structure de données qui rassemble plusieurs champs, ceux-ci contenant des valeurs qui peuvent être de types différents. Typiquement, le nombre de champ et leur séquence sont fixés. Les champs d'un enregistrement peuvent aussi être nommés \"membres\", en particulier dans la programmation orientée objet. Les champs peuvent encore être appelés \"éléments\", mais cela entraîne un risque de confusion avec les éléments d'une collection.\nPar exemple, une date peut être stockée en mémoire comme un enregistrement avec un champ numérique année, le mois représenté comme une chaîne de caractères, et un champ numérique pour le jour-du-mois.\nLes enregistrements se distinguent des tableaux (arrays) par le fait que le nombre de leurs champs est généralement fixé, que chaque champ a un nom et que chaque champ peut être de type différent.\nUn type enregistrement est un type de donnée qui décrit de telles variables. La majorité des langages de programmation utilisés aujourd'hui donne au programmeur la capacité de définir de nouveaux types d'enregistrements. La définition comprend la spécification du type de données de chaque champ et un identifiant (nom ou étiquette) par lequel on peut y accéder.\nLes enregistrements peuvent exister dans n'importe quelle forme de stockage de données (mémoire vive, bandes magnétiques, disques durs...). Les enregistrements sont fondamentaux pour la majorité des structures de données, en particulier les structures de données liées.\nUn objet dans la programmation orientée objet est essentiellement un enregistrement qui contient les procédures spécialisées pour cet enregistrement. Dans la majorité des langages orientés objet, les enregistrements sont des cas spécifiques des objets, et sont nommés plain old data structures, ou passive data structures.\nUn enregistrement peut être considéré comme l'équivalent informatique d'un n-uplet mathématique. Dans la même veine, il peut aussi être vu comme une version technologique d'un produit cartésien de deux ou plusieurs ensembles mathématiques.","accessed":{"date-parts":[["2024",3,28]]},"citation-key":"EnregistrementStructureDonnees2023","container-title":"Wikipédia","issued":{"date-parts":[["2023",9,12]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 207783466","source":"Wikipedia","title":"Enregistrement (structure de données)","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Enregistrement_(structure_de_donn%C3%A9es)&oldid=207783466"},
{"id":"ExpressivePowerComputer2023","abstract":"In computer science, the expressive power (also called expressiveness or expressivity) of a language is the breadth of ideas that can be represented and communicated in that language. The more expressive a language is, the greater the variety and quantity of ideas it can be used to represent.\nFor example, the Web Ontology Language expression language profile (OWL2 EL) lacks ideas (such as negation) that can be expressed in OWL2 RL (rule language). OWL2 EL may therefore be said to have less expressive power than OWL2 RL. These restrictions allow for more efficient (polynomial time) reasoning in OWL2 EL than in OWL2 RL. So OWL2 EL trades some expressive power for more efficient reasoning (processing of the knowledge representation language).","accessed":{"date-parts":[["2024",3,28]]},"citation-key":"ExpressivePowerComputer2023","container-title":"Wikipedia","issued":{"date-parts":[["2023",8,26]]},"language":"en","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 1172391643","source":"Wikipedia","title":"Expressive power (computer science)","type":"entry-encyclopedia","URL":"https://en.wikipedia.org/w/index.php?title=Expressive_power_(computer_science)&oldid=1172391643"},
{"id":"felleisenExpressivePowerProgramming1990","accessed":{"date-parts":[["2024",2,20]]},"author":[{"family":"Felleisen","given":"Matthias"}],"citation-key":"felleisenExpressivePowerProgramming1990","collection-editor":[{"family":"Goos","given":"G."},{"family":"Hartmanis","given":"J."},{"family":"Barstow","given":"D."},{"family":"Brauer","given":"W."},{"family":"Brinch Hansen","given":"P."},{"family":"Gries","given":"D."},{"family":"Luckham","given":"D."},{"family":"Moler","given":"C."},{"family":"Pnueli","given":"A."},{"family":"Seegmüller","given":"G."},{"family":"Stoer","given":"J."},{"family":"Wirth","given":"N."}],"container-title":"ESOP '90","DOI":"10.1007/3-540-52592-0_60","editor":[{"family":"Jones","given":"Neil"}],"event-place":"Berlin, Heidelberg","ISBN":"978-3-540-52592-9 978-3-540-47045-8","issued":{"date-parts":[["1990"]]},"page":"134-151","publisher":"Springer Berlin Heidelberg","publisher-place":"Berlin, Heidelberg","source":"DOI.org (Crossref)","title":"On the expressive power of programming languages","type":"chapter","URL":"http://link.springer.com/10.1007/3-540-52592-0_60","volume":"432"},
{"id":"felleisenProgrammableProgrammingLanguage2018","abstract":"As the software industry enters the era of language-oriented programming, it needs programmable programming languages.","accessed":{"date-parts":[["2024",2,26]]},"author":[{"family":"Felleisen","given":"Matthias"},{"family":"Findler","given":"Robert Bruce"},{"family":"Flatt","given":"Matthew"},{"family":"Krishnamurthi","given":"Shriram"},{"family":"Barzilay","given":"Eli"},{"family":"McCarthy","given":"Jay"},{"family":"Tobin-Hochstadt","given":"Sam"}],"citation-key":"felleisenProgrammableProgrammingLanguage2018","container-title":"Communications of the ACM","container-title-short":"Commun. ACM","DOI":"10.1145/3127323","ISSN":"0001-0782, 1557-7317","issue":"3","issued":{"date-parts":[["2018",2,21]]},"language":"en","page":"62-71","source":"DOI.org (Crossref)","title":"A programmable programming language","type":"article-journal","URL":"https://dl.acm.org/doi/10.1145/3127323","volume":"61"},
{"id":"FermetureInformatique2024","abstract":"Dans un langage de programmation, une fermeture ou clôture (en anglais : closure) est une fonction accompagnée de son environnement lexical. L'environnement lexical d'une fonction est l'ensemble des variables non locales qu'elle a capturées, soit par valeur (c'est-à-dire par copie des valeurs des variables), soit par référence (c'est-à-dire par copie des adresses mémoires des variables). Une fermeture est donc créée, entre autres, lorsqu'une fonction est définie dans le corps d'une autre fonction et utilise des paramètres ou des variables locales de cette dernière.\nUne fermeture peut être passée en argument d'une fonction dans l'environnement où elle a été créée (passée vers le bas) ou renvoyée comme valeur de retour (passée vers le haut). Dans ce cas, le problème posé alors par la fermeture est qu'elle fait référence à des données qui auraient typiquement été allouées sur la pile d'exécution et libérées à la sortie de l'environnement. Hors optimisations par le compilateur, le problème est généralement résolu par une allocation sur le tas de l'environnement.","accessed":{"date-parts":[["2024",3,31]]},"citation-key":"FermetureInformatique2024","container-title":"Wikipédia","issued":{"date-parts":[["2024",2,26]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 212836844","source":"Wikipedia","title":"Fermeture (informatique)","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Fermeture_(informatique)&oldid=212836844"},
{"id":"floydParadigmsProgramming1979a","author":[{"family":"Floyd","given":"Robert W"}],"citation-key":"floydParadigmsProgramming1979a","issue":"8","issued":{"date-parts":[["1979"]]},"language":"en","source":"Zotero","title":"The paradigms of programming","type":"article-journal","volume":"22"},
{"id":"FonctionOrdreSuperieur2023","abstract":"En mathématiques et en informatique, les fonctions d'ordre supérieur sont des fonctions qui ont au moins une des propriétés suivantes :\n\nelles prennent une ou plusieurs fonctions en entrée ;\nelles renvoient une fonction.En mathématiques, on les appelle des opérateurs ou des fonctionnelles.\nL'opérateur de dérivation en calcul infinitésimal est un exemple classique, car elle associe une fonction (la dérivée) à une autre fonction (la fonction que l'on dérive).\nDans le lambda-calcul non typé, toutes les fonctions sont d'ordre supérieur. Dans le lambda-calcul typé, dont la plupart des langages de programmation fonctionnels sont issus, les fonctions d'ordre supérieur sont généralement celles dont le type contient\nplus d'une flèche (Flèches dans la programmation fonctionnelle).\nEn programmation fonctionnelle, les fonctions d'ordre supérieur qui retournent d'autres fonctions sont dites curryfiées.\nLa fonction map présente dans de nombreux langages de programmation fonctionnelle est un exemple de fonction d'ordre supérieur. Elle prend une fonction f comme argument, et retourne une nouvelle fonction qui prend une liste comme argument et applique f à chaque élément. Un autre exemple très courant est celui d'une fonction de tri qui prend en argument une fonction de comparaison ; on sépare ainsi l'algorithme de tri de la comparaison des éléments à trier.\nD'autres exemples de fonction d'ordre supérieur sont la composition de fonctions et l'intégration.","accessed":{"date-parts":[["2024",3,31]]},"citation-key":"FonctionOrdreSuperieur2023","container-title":"Wikipédia","issued":{"date-parts":[["2023",6,22]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 205383055","source":"Wikipedia","title":"Fonction d'ordre supérieur","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Fonction_d%27ordre_sup%C3%A9rieur&oldid=205383055"},
{"id":"FunctionComputerProgramming2024","abstract":"In computer programming, a function, subprogram, procedure, method, routine or subroutine is a callable unit that has a well-defined behavior and can be invoked by other software units to exhibit that behavior.\nCallable units provide a powerful programming tool. The primary purpose is to allow for the decomposition of a large and/or complicated problem into chunks that have relatively low cognitive load and to assign the chunks meaningful names (unless they are anonymous). Judicious application can reduce the cost of developing and maintaining software, while increasing its quality and reliability.Callable units are present at multiple levels of abstraction in the programming environment. For example, a programmer may write a function in source code that is compiled to machine code that implements similar semantics. There is a callable unit in the source code and an associated one in the machine code, but they are different kinds of callable units – with different implications and features.","accessed":{"date-parts":[["2024",4,1]]},"citation-key":"FunctionComputerProgramming2024","container-title":"Wikipedia","issued":{"date-parts":[["2024",2,26]]},"language":"en","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 1210403496","source":"Wikipedia","title":"Function (computer programming)","type":"entry-encyclopedia","URL":"https://en.wikipedia.org/w/index.php?title=Function_(computer_programming)&oldid=1210403496"},
{"id":"GrammaireNonContextuelle2023","abstract":"En linguistique et en informatique théorique, une grammaire algébrique, ou grammaire non contextuelle, aussi appelée grammaire hors-contexte ou grammaire « context-free » est une grammaire formelle dans laquelle chaque règle de production est de la forme\n\nX→α{\\displaystyle X\\to \\alpha }où X{\\displaystyle X} est un symbole non terminal et α{\\displaystyle \\alpha } est une chaîne composée de terminaux et/ou de non-terminaux. Le terme « non contextuel » provient du fait qu'un non terminal X{\\displaystyle X} peut être remplacé par α{\\displaystyle \\alpha }, sans tenir compte du contexte où il apparaît. Un langage formel est non contextuel (ou hors contexte, ou encore algébrique) s'il existe une grammaire non contextuelle qui l'engendre.\nPar opposition est contextuelle une règle de la forme\nc +X→c+α{\\displaystyle c~+X\\to c+\\alpha }\nen raison de la partie gauche de la règle qui stipule un contexte pour X. Une telle règle signifie que X, dans le cas (contexte) où il est précédé du symbole terminal c{\\displaystyle c} et du littéral +{\\displaystyle +}, peut être remplacé par α{\\displaystyle \\alpha }.\nAinsi, dans une grammaire non contextuelle, un symbole non terminal est toujours seul dans la partie gauche de toute règle, ce qui signifie que son environnement syntaxique (ou contexte) n'est pas considéré.\nLes grammaires algébriques sont suffisamment puissantes pour décrire la partie principale de la syntaxe de la plupart des langages de programmation, avec au besoin quelques extensions. La forme de Backus-Naur est la notation la plus communément utilisée pour décrire une grammaire non contextuelle décrivant un langage de programmation. Dans la hiérarchie de Chomsky, ces grammaires sont de type 2.\nSi on trouve plusieurs termes pour nommer une grammaire algébrique, c'est que le terme anglais « context-free » est malcommode à traduire. Tous les termes donnés plus haut sont employés et équivalents.","accessed":{"date-parts":[["2024",3,31]]},"citation-key":"GrammaireNonContextuelle2023","container-title":"Wikipédia","issued":{"date-parts":[["2023",12,11]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 210452959","source":"Wikipedia","title":"Grammaire non contextuelle","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Grammaire_non_contextuelle&oldid=210452959"},
{"id":"HierarchieChomsky2023","abstract":"En informatique théorique, en théorie des langages, et en calculabilité, la hiérarchie de Chomsky (parfois appelée hiérarchie de Chomsky-Schützenberger) est une classification des grammaires formelles (et par extension, des langages formels respectifs engendrés par les grammaires), esquissée par Noam Chomsky en 1956, et décrite de façon formelle en 1959.","accessed":{"date-parts":[["2024",3,31]]},"citation-key":"HierarchieChomsky2023","container-title":"Wikipédia","issued":{"date-parts":[["2023",12,7]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 210331079","source":"Wikipedia","title":"Hiérarchie de Chomsky","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Hi%C3%A9rarchie_de_Chomsky&oldid=210331079"},
{"id":"hofmannWhatPureFunctional2010","abstract":"Given an ML function f : (int->int)->int how can we rigorously specify that f is pure, i.e., produces no side-effects other than those arising from calling its functional argument? We show that existing methods based on preservation of invariants and relational parametricity are insufficient for this purpose and thus define a new notion that captures purity in the sense that for any functional F that is pure in this sense there exists a corresponding question-answer strategy. This research is motivated by an attempt to prove algorithms correct that take such supposedly pure functionals as input and apply them to stateful arguments in order to inspect intensional aspects of their behaviour.","author":[{"family":"Hofmann","given":"Martin"},{"family":"Karbyshev","given":"Aleksandr"},{"family":"Seidl","given":"Helmut"}],"citation-key":"hofmannWhatPureFunctional2010","container-title":"Automata, Languages and Programming","DOI":"10.1007/978-3-642-14162-1_17","editor":[{"family":"Abramsky","given":"Samson"},{"family":"Gavoille","given":"Cyril"},{"family":"Kirchner","given":"Claude"},{"family":"Meyer auf der Heide","given":"Friedhelm"},{"family":"Spirakis","given":"Paul G."}],"event-place":"Berlin, Heidelberg","ISBN":"978-3-642-14162-1","issued":{"date-parts":[["2010"]]},"language":"en","page":"199-210","publisher":"Springer","publisher-place":"Berlin, Heidelberg","source":"Springer Link","title":"What Is a Pure Functional?","type":"paper-conference"},
{"id":"hughesWhyFunctionalProgramming1989","abstract":"As software becomes more and more complex, it is more and more important to structure it well. Well-structured software is easy to write, easy to debug, and provides a collection of modules that can be re-used to reduce future programming costs. Conventional languages place conceptual limits on the way problems can be modularised. Functional languages push those limits back. In this paper we show that two features of functional languages in particular, higher-order functions and lazy evaluation, can contribute greatly to modularity. As examples, we manipulate lists and trees, program several numerical algorithms, and implement the alpha-beta heuristics (an Artificial Intelligence algorithm used in game-playing programs). Since modularity is the key to successful programming, functional languages are vitally important to the real world.","accessed":{"date-parts":[["2024",3,30]]},"author":[{"family":"Hughes","given":"J."}],"citation-key":"hughesWhyFunctionalProgramming1989","container-title":"The Computer Journal","container-title-short":"The Computer Journal","DOI":"10.1093/comjnl/32.2.98","ISSN":"0010-4620","issue":"2","issued":{"date-parts":[["1989",1,1]]},"page":"98-107","source":"Silverchair","title":"Why Functional Programming Matters","type":"article-journal","URL":"https://doi.org/10.1093/comjnl/32.2.98","volume":"32"},
{"id":"iversonNotationToolThought1980","accessed":{"date-parts":[["2024",2,20]]},"author":[{"family":"Iverson","given":"Kenneth E."}],"citation-key":"iversonNotationToolThought1980","container-title":"Communications of the ACM","container-title-short":"Commun. ACM","DOI":"10.1145/358896.358899","ISSN":"0001-0782, 1557-7317","issue":"8","issued":{"date-parts":[["1980",8]]},"language":"en","page":"444-465","source":"DOI.org (Crossref)","title":"Notation as a tool of thought","type":"article-journal","URL":"https://dl.acm.org/doi/10.1145/358896.358899","volume":"23"},
{"id":"jenkisWhatFunctionalProgramming2015","abstract":"The personal blog of Kris Jenkins, geek.","accessed":{"date-parts":[["2024",3,29]]},"author":[{"family":"Jenkis","given":"Kris"}],"citation-key":"jenkisWhatFunctionalProgramming2015","container-title":"Kris Jenkins' Blog","issued":{"date-parts":[["2015",12,29]]},"language":"en","title":"What Is Functional Programming?","type":"webpage","URL":"http://blog.jenkster.com/2015/12/what-is-functional-programming.html#fnref-1"},
{"id":"LogiqueCombinatoire2023","abstract":"En logique mathématique, la logique combinatoire est une théorie logique introduite par Moses Schönfinkel en 1920 lors d'une conférence[Laquelle ?] et développée dès 1929 par Haskell Brooks Curry pour supprimer le besoin de variables en mathématiques, pour formaliser rigoureusement la notion de fonction et pour minimiser le nombre d'opérateurs nécessaires pour définir le calcul des prédicats à la suite de Henry M. Sheffer. Plus récemment, elle a été utilisée en informatique comme modèle théorique de calcul et comme base pour la conception de langages de programmation fonctionnels.\nLe concept de base de la logique combinatoire est celui de combinateur qui est une fonction d'ordre supérieur ; elle utilise uniquement l'application de fonctions et éventuellement d'autres combinateurs pour définir de nouvelles fonctions d'ordre supérieur. Chaque combinateur simplement typable est une démonstration à la Hilbert en logique intuitionniste et vice-versa . On appelle ceci la correspondance de Curry-Howard","accessed":{"date-parts":[["2024",4,1]]},"citation-key":"LogiqueCombinatoire2023","container-title":"Wikipédia","issued":{"date-parts":[["2023",6,5]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 204935023","source":"Wikipedia","title":"Logique combinatoire","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Logique_combinatoire&oldid=204935023"},
{"id":"michaelsonProgrammingParadigmsTuring2020","abstract":"The notion of programming paradigms, with associated programming languages and methodologies, is a well established tenet of Computer Science pedagogy, enshrined in international curricula. However, this notion sits ill with Kuhn's classic conceptualisation of a scientific paradigm as a dominant world view, which supersedes its predecessors through superior explanatory power. 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 of Turing complete computation complemented by Computational Thinking.","accessed":{"date-parts":[["2024",2,26]]},"author":[{"family":"Michaelson","given":"Greg"}],"citation-key":"michaelsonProgrammingParadigmsTuring2020","container-title":"The Art, Science, and Engineering of Programming","container-title-short":"Programming","DOI":"10.22152/programming-journal.org/2020/4/4","ISSN":"2473-7321","issue":"3","issued":{"date-parts":[["2020",2,14]]},"page":"4","source":"arXiv.org","title":"Programming Paradigms, Turing Completeness and Computational Thinking","type":"article-journal","URL":"http://arxiv.org/abs/2002.06178","volume":"4"},
{"id":"minskyFormContentComputer1970","accessed":{"date-parts":[["2024",3,30]]},"author":[{"family":"Minsky","given":"Marvin"}],"citation-key":"minskyFormContentComputer1970","container-title":"Journal of the ACM","container-title-short":"J. ACM","DOI":"10.1145/321574.321575","ISSN":"0004-5411","issue":"2","issued":{"date-parts":[["1970",4,1]]},"page":"197–215","source":"ACM Digital Library","title":"Form and Content in Computer Science (1970 ACM turing lecture)","type":"article-journal","URL":"https://dl.acm.org/doi/10.1145/321574.321575","volume":"17"},
{"id":"okasakiPurelyFunctionalData1999","abstract":"Most books on data structures assume an imperative language such as C or C++. However, data structures for these languages do not always translate well to functional languages such as Standard ML, Haskell, or Scheme. This book describes data structures from the point of view of functional languages, with examples, and presents design techniques that allow programmers to develop their own functional data structures. The author includes both classical data structures, such as red-black trees and binomial queues, and a host of new data structures developed exclusively for functional languages. All source code is given in Standard ML and Haskell, and most of the programs are easily adaptable to other functional languages. This handy reference for professional programmers working with functional languages can also be used as a tutorial or for self-study.","author":[{"family":"Okasaki","given":"Chris"}],"citation-key":"okasakiPurelyFunctionalData1999","ISBN":"978-0-521-66350-2","issued":{"date-parts":[["1999",6,13]]},"language":"en","number-of-pages":"236","publisher":"Cambridge University Press","source":"Google Books","title":"Purely Functional Data Structures","type":"book"},
{"id":"ParadigmeProgrammation2023","abstract":"Le paradigme de programmation est la façon (parmi d'autres) d'approcher la programmation informatique et de formuler les solutions aux problèmes et leur formalisation dans un langage de programmation approprié. Ce n'est pas de la méthodologie contenant une méthode ; cette dernière organise le traitement des problèmes reconnus dans l'écosystème concerné pour aboutir à la solution conceptuelle et programme exécutable.","accessed":{"date-parts":[["2024",2,24]]},"citation-key":"ParadigmeProgrammation2023","container-title":"Wikipédia","issued":{"date-parts":[["2023",7,11]]},"language":"fr","license":"Creative Commons Attribution-ShareAlike License","note":"Page Version ID: 205915300","source":"Wikipedia","title":"Paradigme (programmation)","type":"entry-encyclopedia","URL":"https://fr.wikipedia.org/w/index.php?title=Paradigme_(programmation)&oldid=205915300"},
{"id":"royProgrammingParadigmsDummies","author":[{"family":"Roy","given":"Peter Van"}],"citation-key":"royProgrammingParadigmsDummies","language":"en","source":"Zotero","title":"Programming Paradigms for Dummies: What Every Programmer Should Know","type":"article-journal"},
{"id":"StructuredProgrammingWikipedia","accessed":{"date-parts":[["2024",4,1]]},"citation-key":"StructuredProgrammingWikipedia","title":"Structured programming - Wikipedia","type":"webpage","URL":"https://en.wikipedia.org/wiki/Structured_programming?oldformat=true"},
{"id":"StructuresDonneesEnregistrements","accessed":{"date-parts":[["2024",3,28]]},"citation-key":"StructuresDonneesEnregistrements","language":"fr","title":"Structures de données/Enregistrements — Wikilivres","type":"webpage","URL":"https://fr.wikibooks.org/wiki/Structures_de_donn%C3%A9es/Enregistrements"},
{"id":"TaxonomiePrincipauxParadigmes","accessed":{"date-parts":[["2024",4,1]]},"citation-key":"TaxonomiePrincipauxParadigmes","title":"Une taxonomie des principaux paradigmes de programmation","type":"webpage","URL":"https://www.info.ucl.ac.be/~pvr/paradigmes.html"},
{"id":"toalProgrammingParadigms","accessed":{"date-parts":[["2024",3,29]]},"author":[{"family":"Toal","given":"Ray"}],"citation-key":"toalProgrammingParadigms","title":"Programming Paradigms","type":"webpage","URL":"https://cs.lmu.edu/~ray/notes/paradigms/"}
]

318
Remplissage du plan de L3.md
View File

@ -6,52 +6,13 @@ up:: [[plan du mémoire de L3]]
![[mémoire de L3#^abstract]]
# Sommaire
- [[#qu'est-ce qu'un paradigme|qu'est-ce qu'un paradigme]]
- [[#Concepts importants|Concepts importants]]
- [[#Concepts importants#Fonction et procédure|Fonction et procédure]]
- [[#Concepts importants#Fermeture|Fermeture]]
- [[#les principaux paradigmes|les principaux paradigmes]]
- [[#les principaux paradigmes#programmation déclarative|programmation déclarative]]
- [[#les principaux paradigmes#programmation fonctionnelle|programmation fonctionnelle]]
- [[#les langages multi-paradigmes|les langages multi-paradigmes]]
- [[#Définition de la puissance d'expression|Définition de la puissance d'expression]]
- [[#Définition de la puissance d'expression#Au sens formel|Au sens formel]]
- [[#Définition de la puissance d'expression#Au sens commun|Au sens commun]]
- [[#Définition de la puissance d'expression#compromis expressivité vs analysabilité|compromis expressivité vs analysabilité]]
- [[#compromis expressivité vs analysabilité#Exemple de compromis : automates et grammaires|Exemple de compromis : automates et grammaires]]
- [[#contre la distinction entre les paradigmes|contre la distinction entre les paradigmes]]
- [[#contre la distinction entre les paradigmes#Les paradigmes sont des courants de pensée|Les paradigmes sont des courants de pensée]]
- [[#contre la distinction entre les paradigmes#Les paradigmes sont tous équivalents|Les paradigmes sont tous équivalents]]
- [[#avantages de la diversité|avantages de la diversité]]
- [[#problèmes de la diversité|problèmes de la diversité]]
- [[#diversité des approches|diversité des approches]]
- [[#créer un paradigme pour chaque type de problème|créer un paradigme pour chaque type de problème]]
- [[#avantages des langages multi-paradigme|avantages des langages multi-paradigme]]
# Définition et concepts importants
## qu'est-ce qu'un paradigme
Un paradigme de programmation est une façon d'approcher la programmation et de formuler les problèmes et leurs formalisation dans un langage de programmation. En particulier, un paradigme fournit et détermine comment un développeur doit voir un programme.
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.
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.
Un paradigme de programmation est une façon d'approcher la programmation et de formuler les problèmes et leurs formalisation dans un langage de programmation [@ParadigmeProgrammation2023]. En particulier, un paradigme fournit et détermine comment un développeur doit voir un programme.
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].
![[paradigme de programmation#^definition|paradigme]]
> [!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=2294PTUD)
> A programming paradigm is an approach to programming a computer based on a mathematical theory or a coherent set of principles.
>
> > [!note] Notes
> > Paradigme: approche (éventuellement mathématique) de la programmation
> >
> > - chaque paradigme est défini à partir de principes de base (éventuellement une théorie mathématique)
> ^2294PTUDaP4L4LCJZg5383243p2
> [!cite]- [Paradigme (programmation)](zotero://select/groups/5383243/items/U2XUNF8V) - [Page ](zotero://open-pdf/groups/5383243/items/PYQD2DCX?annotation=FZJDRZRQ)
> Le paradigme de programmation est la façon (parmi d'autres) d'approcher la programmation informatique et de formuler les solutions aux problèmes et leur formalisation dans un langage de programmation approprié[1]. Ce n'est pas de la méthodologie contenant une méthode ; cette dernière organise le traitement des problèmes reconnus dans l'écosystème concerné pour aboutir à la solution conceptuelle et programme exécutable.
> ^FZJDRZRQaPYQD2DCXg5383243
> [!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.
@ -61,70 +22,38 @@ Un paradigme est un concept plus "haut niveau", c'est-à-dire plus abstrait : ch
> ^4LQTA3Q8aP4L4LCJZg5383243p2
Un paradigme de programmation est souvent principalement décrit par les concepts qu'il implémente ou non.
C'est notamment cette approche qu'emploie la [[taxonomie des paradigmes de programmation]] présentée dans l'article [[royProgrammingParadigmsDummies]] (faire une référence à une annexe).
Un paradigme de programmation est souvent principalement décrit par les concepts qu'il implémente ou non [@royProgrammingParadigmsDummies, p.10].
C'est notamment cette approche qu'emploie la [[taxonomie des paradigmes de programmation]] (référence à une annexe) [@TaxonomiePrincipauxParadigmes].
> [!cite]+ [Une taxonomie des principaux paradigmes de programmation](zotero://select/groups/5383243/items/JS99BNS3) - [Page ](zotero://open-pdf/groups/5383243/items/TFPQ3W8G?annotation=KP3KB62E)
> Une taxonomie des principaux paradigmes de programmation
>
> > [!note] Notes
> > taxonomie des langages de programmation (poster en français)
> ^KP3KB62EaTFPQ3W8Gg5383243
Cependant, J.Huges, dans son article "Why Functional Programming Matters", fustige le fait que certains paradigmes (notamment la programmation fonctionnelle *ref* et la programmation structurée *ref*) sont trop souvent définis en termes des fonctionnalités qu'il n'implémentent pas, ou des contraintes qu'il posent ("It says a lot about what functional programming is _not_ [...] but not much about what it is.").
Cela est problématique car l'absence d'une fonctionnalité ne peut pas expliquer pourquoi un paradigme serait plus intéressant dans certains cas ("It is a logical impossibility to make a language more powerful by ommitting features, no matter how bad they may be"). L'auteur insiste donc sur le fait que les paradigmes devraient être définis en fonction des avantages structurels qu'il apportent pour résolution de certains types de problèmes.
Cependant, J.Huges, dans son article "Why Functional Programming Matters" [@hughesWhyFunctionalProgramming1989, p.1], fustige le fait que certains paradigmes (notamment la programmation fonctionnelle *ref* et la programmation structurée *ref*) sont trop souvent définis en termes des fonctionnalités qu'il n'implémentent pas, ou des contraintes qu'il posent [^4].
Cela est problématique car l'absence d'une fonctionnalité ne peut pas expliquer pourquoi un paradigme serait plus intéressant dans certains cas [^5]. L'auteur insiste donc sur le fait que les paradigmes devraient être définis en fonction des avantages structurels qu'il apportent pour résolution de certains types de problèmes.
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
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.
> [!cite]- [Why Functional Programming Matters](zotero://select/groups/5383243/items/6RZUZSFR) - [Page 1](zotero://open-pdf/groups/5383243/items/H9SGRTMQ?page=1&annotation=2QS3SA82)
> Such a catalogue of 'advantages' is all very#ell, but one must not be surprised if outsiders don't take it too seriously. It says a lot about what functional programming is *not* (it has no assignment, no side-effects, no flow of control) but not much about what it is. The functional programmer sounds rather like a medieval monk, denying himself the pleasures of life in the hope that it will make him virtuous.
> ^2QS3SA82aH9SGRTMQg5383243p1
> [!cite]- [Why Functional Programming Matters](zotero://select/groups/5383243/items/6RZUZSFR) - [Page 1](zotero://open-pdf/groups/5383243/items/H9SGRTMQ?page=1&annotation=INFAECYD)
> Functional programmers argue that there *are* great material benefits - that a functional programmer is an order of magnitude more productive than his conventional counterpart, because functional programs are an order of magnitude shorter. Yet why should this be? The only faintly plausible reason one can suggest on the basis of these 'advantages' is that conventional programs consist of 90% assignment statements, and in functional programs these can be omitted! This is plainly ridiculous. If omittin assignment statements brought such enormous benefits then FORTRAN programmers would have been doing it for twenty years. It is a logical impossibility to make a language more powerful by omittion features, no matter how bad they may be.
> ^INFAECYDaH9SGRTMQg5383243p1
## Définitions préliminaires
## Définitions
### état
L'état est la capacité, pour un programme, à retenir de l'information.
"State is the ability to remember information, or more precisely, to store a sequence of values in time." (L'état est la capacité à retenir de l'information, ou, plus précisément, à stocker une séquence de valeurs dans le temps) (*ref*).
> [!cite]- [Programming Paradigms for Dummies: What Every Programmer Should Know](zotero://select/groups/5383243/items/673TMQRT) - [Page 14](zotero://open-pdf/groups/5383243/items/P4L4LCJZ?page=6&annotation=RSLMGUYK)
> State is the ability to remember information, or more precisely, to store a sequence of values in time.
> ^RSLMGUYKaP4L4LCJZg5383243p6
"State is the ability to remember information, or more precisely, to store a sequence of values in time." (L'état est la capacité à retenir de l'information, ou, plus précisément, à stocker une séquence de valeurs dans le temps) [@royProgrammingParadigmsDummies, p.14].
Il est important de noter que la présence de variables n'implique pas toujours la présence d'état. En effet, une fonction peut avoir un paramètre sans avoir nécessairement d'état. Les variables des fonctions, si elles constituent une référence à une valeur, n'impliquent pas la présence d'état.
Note: la logique combinatoire fournit la preuve qu'il est possible d'établir un système de calcul sans aucune variable ni référence, ce qui rend l'absence d'état évidente (*ref*).
> [!cite]+ [Logique combinatoire](zotero://select/groups/5383243/items/9RYAKXF2) - [Page ](zotero://open-pdf/groups/5383243/items/5ZRIGAB3?annotation=6UG45AG4)
> En logique mathématique, la logique combinatoire est une théorie logique[1] introduite par Moses Schönfinkel[2] en 1920 lors d'une conférence[Laquelle ?] et développée dès 1929 par Haskell Brooks Curry[3] pour supprimer le besoin de variables en mathématiques, pour formaliser rigoureusement la notion de fonction et pour minimiser le nombre d'opérateurs nécessaires pour définir le calcul des prédicats à la suite de Henry M. Sheffer. Plus récemment, elle a été utilisée en informatique comme modèle théorique de calcul et comme base pour la conception de langages de programmation fonctionnels.
> ^6UG45AG4a5ZRIGAB3g5383243
Note: la logique combinatoire fournit la preuve qu'il est possible d'établir un système de calcul sans aucune variable ni référence, ce qui rend l'absence d'état évidente [@LogiqueCombinatoire2023].
### Fonction et procédure
Les termes "fonction" et "procédure" sont, selon les contextes et les auteurs, utilisés pour désigner différentes choses, ou bien la même chose.
Les termes "fonction" et "procédure" sont, selon les contextes et les auteurs, utilisés pour désigner différentes choses.
Par exemple, le livre [[abelsonStructureInterpretationComputer1996]] fournit la distinction suivante : Les fonctions sont l'aspect mathématique du concept et sont définies en déclarant "ce qu'elle est" , en donnant des propiétés de cette fonction (une définition déclarative, voir [[Remplissage du plan de L3#programmation déclarative]]).
Les procédures sont l'aspect programmatique du concept, et sont définies en déclarant "comment elle doit faire", en décrivant comment elle doit s'exécuter.
> [!cite]+ [Function (computer programming)](zotero://select/groups/5383243/items/FDB7GED2) - [Page ](zotero://open-pdf/groups/5383243/items/RIAPAJ6E?annotation=GNQR9GC2)
> In computer programming, a function, subprogram, procedure, method, routine or subroutine is a callable unit[1] that has a well-defined behavior and can be invoked by other software units to exhibit that behavior.
> ^GNQR9GC2aRIAPAJ6Eg5383243
> [!cite]+ [Structure and Interpretation of Computer Programs](zotero://select/groups/5383243/items/BKPQ7QSM) - [Page 28](zotero://open-pdf/groups/5383243/items/KNH433ZX?page=56&annotation=88QKQ5JP)
> The contrast between function and procedure is a reflection of the general distinction between describing properties of things and describing how to do things, or, as it is sometimes referred to, the distinction between declarative knowledge and imperative knowledge. In mathematics we are usually concerned with declarative (what is) descriptions, whereas in computer science we are usually concerned with imperative (how to) descriptions.
>
> > [!note] Notes
> > fonction : connaissance déclarative
> > procédure : connaissance impérative
> ^88QKQ5JPaKNH433ZXg5383243p56
Cependant, certains auteurs utilisent le terme *procedure* même pour parler du concept théorique et mathématique (qui se rapproche du lambda-calcul) (par exemple Fellesein dans "On the expressive power of programming languages" *ref*).
> [!cite]+ [On the expressive power of programming languages](zotero://select/groups/5383243/items/CNP9I827) - [Page 135](zotero://open-pdf/groups/5383243/items/TY878EW8?page=2&annotation=SRALKQCM)
> (let x be v in e) is expressible as (apply (procedure x e) v).
> ^SRALKQCMaTY878EW8g5383243p2
Par exemple, le livre "Structure and interpretation of computer programs" [@abelsonStructureInterpretationComputer1996] fournit la distinction suivante : les fonctions sont l'aspect mathématique du concept et sont définies en déclarant "ce qu'elle est" , en donnant des propiétés de cette fonction (une définition déclarative, voir [[Remplissage du plan de L3#programmation déclarative]]).
Les procédures sont l'aspect programmatique du concept, et sont définies en déclarant "comment elle doit faire", en décrivant comment elle doit s'exécuter [^1].
Cependant, certains auteurs utilisent le terme *procedure* même pour parler du concept théorique et mathématique (qui se rapproche du lambda-calcul) [^2].
Nous utiliserons donc principalement le terme fonction, avec les définitions suivantes :
@ -132,212 +61,103 @@ Nous utiliserons donc principalement le terme fonction, avec les définitions su
> Une fonction est l'encapsulation d'un ensemble d'instructions.
> Une fonction peut posséder des paramètres qui peuvent influencer son exécution. Ces paramètres sont des valeurs ou des références qui sont données ("passées en argument") lors de l'appel de cette fonction.
> Une fonction peut retourner une valeur.
> Une fonction peut être appelée plusieurs fois et à plusieurs endroits, ce qui la rend réutilisable dans plusieurs contextes.
> [!definition] fonction pure
> Une fonction pure est une fonction déterministe, c'est-à-dire que les mêmes arguments donnent toujours la même valeur de retour.
> Une fonction pure est une fonction sans effet de bord, c'est-à-dire qu'elle ne modifie pas l'état du système (en dehors de son champ local propre, dont la durée de vie est limitée).
> [!cite]+ [Function (computer programming)](zotero://select/groups/5383243/items/FDB7GED2) - [Page ](zotero://open-pdf/groups/5383243/items/RIAPAJ6E?annotation=GNQR9GC2)
> In computer programming, a function, subprogram, procedure, method, routine or subroutine is a callable unit[1] that has a well-defined behavior and can be invoked by other software units to exhibit that behavior.
> ^GNQR9GC2aRIAPAJ6Eg5383243
### Fermeture
Une fermeture (de l'anglais *closure*) est une fonction à laquelle on attache l'environnement local de l'endroit où elle à été définie.
Cela permet à cette fonction d'accéder aux valeurs et aux références de cet environnement local, même si elle est appelée depuis un autre contexte (dans un autre champ local).
Du point de vue du développeur, cela signifie que l'exécution d'une fermeture soit le même que si les instructions étaient exécutées "à l'endroit" (dans le contexte où) la fermeture à été créée.
Une fermeture (de l'anglais *closure*) est une fonction à laquelle on attache l'environnement local de l'endroit où elle à été définie [^7] [^8].
Cela permet à cette fonction d'accéder aux valeurs et aux références de cet environnement local, même si elle est appelée depuis un autre contexte (dans un autre champ local) [^8].
Du point de vue du développeur, cela signifie que l'exécution d'une fermeture soit le même que si les instructions étaient exécutées "à l'endroit" (dans le contexte où) la fermeture à été créée [^6].
> [!cite]- [Programming Paradigms for Dummies: What Every Programmer Should Know](zotero://select/groups/5383243/items/673TMQRT) - [Page 24](zotero://open-pdf/groups/5383243/items/P4L4LCJZ?page=16&annotation=6H6T7X9L)
> From the programmer’s viewpoint, a closure is a “packet of work”: a program can transform any instructions into a closure at one point in the program, pass it to another point, and decide to execute it at that point. The result of its execution is the same as if the instructions were executed at the point the closure was created.
>
> > [!note] Notes
> > fermeture := permet que le résultat soit le même que si les instructions étaient éxécutées à l'endroit où la fermeture à été créée.
> ^6H6T7X9LaP4L4LCJZg5383243p16
> [!cite]- [Programming Paradigms for Dummies: What Every Programmer Should Know](zotero://select/groups/5383243/items/673TMQRT) - [Page 24](zotero://open-pdf/groups/5383243/items/P4L4LCJZ?page=16&annotation=BRVCUS8M)
> From an implementation viewpoint, a closure combines a procedure with its external references (the references it uses at its definition).
>
> > [!note] Notes
> > fermeture = combiner une fonction avec ses références externes
> ^BRVCUS8MaP4L4LCJZg5383243p16
> [!cite]- [Fermeture (informatique)](zotero://select/groups/5383243/items/ZKL3R2ZE) - [Page ](zotero://open-pdf/groups/5383243/items/JNZ49HIA?annotation=P8UFCIK5)
> Dans un langage de programmation, une fermeture ou clôture (en anglais : closure) est une fonction accompagnée de son environnement lexical. L'environnement lexical d'une fonction est l'ensemble des variables non locales qu'elle a capturées, soit par valeur (c'est-à-dire par copie des valeurs des variables), soit par référence (c'est-à-dire par copie des adresses mémoires des variables)[1]. Une fermeture est donc créée, entre autres, lorsqu'une fonction est définie dans le corps d'une autre fonction et utilise des paramètres ou des variables locales de cette dernière.
> ^P8UFCIK5aJNZ49HIAg5383243
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) : "Dans ce cas, le problème posé alors par la fermeture est qu'elle fait référence à des données qui auraient typiquement été allouées sur la pile d'exécution et libérées à la sortie de l'environnement." (*ref [[FermetureInformatique2024]]*).
> [!cite]- [Fermeture (informatique)](zotero://select/groups/5383243/items/ZKL3R2ZE) - [Page ](zotero://open-pdf/groups/5383243/items/JNZ49HIA?annotation=N5UF45WT)
> Une fermeture peut être passée en argument d'une fonction dans l'environnement où elle a été créée (passée vers le bas) ou renvoyée comme valeur de retour (passée vers le haut). Dans ce cas, le problème posé alors par la fermeture est qu'elle fait référence à des données qui auraient typiquement été allouées sur la pile d'exécution et libérées à la sortie de l'environnement. Hors optimisations par le compilateur, le problème est généralement résolu par une allocation sur le tas de l'environnement.
>
> > [!note] Notes
> > Le passage *vers le haut* d'une fermeture demande l'accès à des données qui sont libéréres de la pile d'exécution.
> > Cela est résolu par une allocation sur le tas.
> ^N5UF45WTaJNZ49HIAg5383243
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
[[taxonomie des paradigmes de programmation]]
### programmation impérative
La programmation impérative est un paradigme de programmation dans lequel le contrôle de flot d'exécution est explicite.
Cela signifique que le programme spécifie pas à pas la marche à suivre pour obtenir le bon résultat.
En programmation impérative, chaque étape modifie l'état global du système.
> [!cite]+ [Programming Paradigms](zotero://select/groups/5383243/items/XUWRH447) - [Page ](zotero://open-pdf/groups/5383243/items/LQGLTH3D?annotation=QVDN27WM)
> Control flow in imperative programming is explicit: commands show how the computation takes place, step by step. Each step affects the global state of the
> computation.
>
> > [!note] Notes
> > impératif :
> >
> > - flot de contrôle explicite: explication pas-à-pas de ce qui doit être fait
> > - chaque pas affecte l'état global du calcul
> ^QVDN27WMaLQGLTH3Dg5383243
En programmation impérative, chaque étape modifie l'état global du système [^10].
### programmation déclarative
La programmation déclarative est un paradigme de programmation dans lequel la définition des programme se fait en déclarant la forme du résultat plutôt que la manière l'obtenir (comme en [[paradigme programmation impérative|programmation impérative]]).
La programmation déclarative est un paradigme de programmation dans lequel la définition des programme se fait en déclarant la forme du résultat plutôt que la manière l'obtenir (comme on le fait en [[Remplissage du plan de L3#programmation impérative]])
Le développeur ne s'occupe donc pas de l'exécution, mais plutôt de comment spécifier le résultat.
Le contrôle du flot d'exécution est implicite. En cela, la programmation déclarative s'oppose à la programmation impérative.
> [!cite]- [Programming Paradigms](zotero://select/groups/5383243/items/XUWRH447) - [Page ](zotero://open-pdf/groups/5383243/items/LQGLTH3D?annotation=3SBD24AE)
> Control flow in declarative programming is implicit: the programmer states only what the result should look like,
> not how to obtain it.
>
> > [!note] Notes
> > déclaratif :
> > le flot de contrôle est implicite.
> > on déclare ce que le résultat doit être plutôt que comment l'obtenir.
> ^3SBD24AEaLQGLTH3Dg5383243
Le contrôle du flot d'exécution est implicite. En cela, la programmation déclarative s'oppose à la programmation impérative [^11].
<!-- La programmation déclarative est un paradigme très général (qui englobe beaucoup de langages différents), et peut même être vue comme un spectre : certains languages étant plus ou moins déclaratifs ([[taxonomie des paradigmes de programmation]] *ref*). -->
### programmation fonctionnelle
La programmation fonctionnelle est un paradigme de programmation dans lequel les programmes sont exprimés comme des arbres d'expressions.
Le contrôle du flot d'exécution est donc fait en combinant des fonctions : la fonction principale prends en argument l'entrée du problème, puis elle est définit a partir d'autres fonctions, qui sont elles-même définies à partir de fonctions, et ce jusqu'à ce que les fonctions à la base de la définition (les feuilles de l'arbre d'expressions) soient des primitives du langages, ou bien des constantes.
Le contrôle du flot d'exécution est donc fait en combinant des fonctions [^12]: la fonction principale prends en argument l'entrée du problème, puis elle est définit a partir d'autres fonctions, qui sont elles-même définies à partir de fonctions, et ce jusqu'à ce que les fonctions à la base de la définition (les feuilles de l'arbre d'expressions) soient des primitives du langages, ou bien des constantes [^13].
Cela distingue la programmation fonctionnelle d'autres paradigmes, notamment en programmation impérative, où l'état est beaucoup plus utilisé, notamment pour le contrôle du flot d'exécution.
Ces propriétés rapprochent beaucoup la programmation fonctionnelle des mathématiques.
Ces propriétés rapprochent beaucoup la programmation fonctionnelle des mathématiques [^13].
> [!cite]- [Programming Paradigms](zotero://select/groups/5383243/items/XUWRH447) - [Page ](zotero://open-pdf/groups/5383243/items/LQGLTH3D?annotation=8L7P34B2)
> In functional programming, control flow is expressed by combining function calls, rather than by assigning values to variables:
> ^8L7P34B2aLQGLTH3Dg5383243
> [!cite]- [What Is Functional Programming?](zotero://select/groups/5383243/items/TLUTFXJ8) - [Page ](zotero://open-pdf/groups/5383243/items/8P4TX53J?annotation=IU2KWY7L)
> [!cite]+ [What Is Functional Programming?](zotero://select/groups/5383243/items/TLUTFXJ8) - [Page ](zotero://open-pdf/groups/5383243/items/8P4TX53J?annotation=IU2KWY7L)
> Functional programming is about writing pure functions, about removing
> hidden inputs and outputs as far as we can, so that as much of our
> code as possible just describes a relationship between inputs and
> outputs.
> ^IU2KWY7La8P4TX53Jg5383243
> [!cite]- [Why Functional Programming Matters](zotero://select/groups/5383243/items/6RZUZSFR) - [Page 1](zotero://open-pdf/groups/5383243/items/H9SGRTMQ?page=1&annotation=WSXGN3RM)
> ![[images/zotero/5383243WSXGN3RM.png|500]]
>
> > [!note] Notes
> > programme écrit comme des fonctions qui reçoivent l'entrée en argument et renvoie le résultat.
> ^WSXGN3RMaH9SGRTMQg5383243p1
Les fonction d'ordre supérieur sont centrales en programmation fonctionnelle. Les fonctions d'ordre supérieur sont des fonctions qui prennent en argument, ou renvoient d'autres fonctions.
Ces fonctions d'ordre supérieur (aussi appelées "fonctionnelles") permettent donc de modifier ou combiner entre elles d'autres fonctions.
> [!cite]- [Fonction d'ordre supérieur](zotero://select/groups/5383243/items/NPLAN6RU) - [Page ](zotero://open-pdf/groups/5383243/items/94RE4PDX?annotation=YZKT9G5G)
> En mathématiques et en informatique, les fonctions d'ordre supérieur sont des fonctions qui ont au moins une des propriétés suivantes :
>
> elles prennent une ou plusieurs fonctions en entrée ;
> elles renvoient une fonction.
> ^YZKT9G5Ga94RE4PDXg5383243
Ces fonctions d'ordre supérieur (aussi appelées "fonctionnelles") permettent donc de modifier ou combiner entre elles d'autres fonctions [^14].
Pour que les fonctions d'ordre supérieur existent, il est nécessaire que les fonctions soient des citoyens de première classe, c'est-à-dire des entités traitées comme des valeurs du langage.
Il est également nécessaire que le langage implémente les fermetures, le cas échéant il serait impossible d'implémenter certaines fonctions d'ordre supérieur.
La programmation fonctionnelle privée des fermetures (et donc des fonction d'ordre supérieur) s'appelle la programmation fonctionnelle de premier ordre (*ref* [[taxonomie des paradigmes de programmation]] ).
Il est également nécessaire que le langage implémente les [[Remplissage du plan de L3#Fermeture|fermetures]], le cas échéant il serait impossible d'implémenter certaines fonctions d'ordre supérieur.
La programmation fonctionnelle privée des fermetures (et donc des fonction d'ordre supérieur) s'appelle la programmation fonctionnelle de premier ordre (ref à la taxonomie en annexe)
#### Programmation fonctionnelle pure
La programmation fonctionnelle pure (parfois appelée simplement programmation fonctionnelle) est un paradigme dans lequel toutes les fonctions sont pures, c'est-à-dire qu'il n'existe pas d'état.
La logique combinatoire est un système de calcul dans lequel toutes les fonctions sont pures (il n'y a que des fonctions d'ordre supérieur dans ce système) (*ref* [[LogiqueCombinatoire2023]]).
La programmation fonctionnelle pure (parfois appelée simplement programmation fonctionnelle) est un paradigme dans lequel toutes les fonctions sont pures, c'est-à-dire qu'il n'existe pas d'état [^15].
### programmation structurée
La programmation structurée peut être définie, du point du vue théorique, comme un paradigme dans lequel le contrôle du flot se fait en utilisant des instructions de contrôle du flot d'exécution particulières (des structures de sélection et d'itération), et qui sont sous la forme de blocks.
La programmation structurée peut être définie, du point du vue théorique, comme un paradigme dans lequel le contrôle du flot se fait en utilisant des instructions de contrôle du flot d'exécution particulières (des structures de sélection et d'itération), et qui sont sous la forme de blocks [^16].
Les structures de sélection sont des structures particulières qui permettent de choisir quel groupe d'instruction sera exécuté en fonction de l'état du programme [^17].
Les structures d'itération sont des instructions qui exécutent répétitivement un block jusqu'à ce que le programme atteigne un certain état, ou bien que certaines opérations aient été appliquées sur chaque élément d'une collection [^18].
Il est important de voir que le but de la programmation structurée est de produire des programmes plus clairs et de meilleure qualité, de par la modularité induite par la structuration du programme [^19].
Une autre définition de la programmation structurée est une façon de concevoir les programmes
> [!cite]+ [Structured programming - Wikipedia](zotero://select/groups/5383243/items/LGC6RCX5) - [Page ](zotero://open-pdf/groups/5383243/items/7KR7GM4L?annotation=MF24SBCD)
> Structured programming is a programming paradigm aimed at improving the clarity, quality, and development time of a computer program by making extensive use of the structured control flow constructs of selection (if/then/else) and repetition (while and for), block structures, and subroutines.
> ^MF24SBCDa7KR7GM4Lg5383243
"In the first phase, that of top-down design, or stepwise refinement, the problem is decomposed into a very small number of simpler subproblems." [@floydParadigmsProgramming1979a, p.1]
Les structures de sélection sont des structures particulières qui permettent de choisir quel groupe d'instruction sera exécuté en fonction de l'état du programme.
> [!cite]- [Structured programming - Wikipedia](zotero://select/groups/5383243/items/LGC6RCX5) - [Page ](zotero://open-pdf/groups/5383243/items/7KR7GM4L?annotation=2YR6SG87)
> "Selection"; one or a number of statements is executed depending on the state of the program. This is usually expressed with keywords such as if..then..else..endif. The conditional statement should have at least one true condition and each condition should have one exit point at max.
> ^2YR6SG87a7KR7GM4Lg5383243
Les structures d'itération sont des instructions qui exécutent répétitivement un block jusqu'à ce que le programme atteigne un certain état, ou bien que certaines opérations aient été appliquées sur chaque élément d'une collection.
> [!cite]+ [Structured programming - Wikipedia](zotero://select/groups/5383243/items/LGC6RCX5) - [Page ](zotero://open-pdf/groups/5383243/items/7KR7GM4L?annotation=BBWVNENQ)
> "Iteration"; a statement or block is executed until the program reaches a certain state, or operations have been applied to every element of a collection. This is usually expressed with keywords such as while, repeat, for or do..until. Often it is recommended that each loop should only have one entry point (and in the original structural programming, also only one exit point, and a few languages enforce this).
> ^BBWVNENQa7KR7GM4Lg5383243
Il est important de voir que le but de la programmation structurée est de produire des programmes plus clairs et de meilleure qualité (*ref*)
> [!cite]+ [Why Functional Programming Matters](zotero://select/groups/5383243/items/6RZUZSFR) - [Page 2](zotero://open-pdf/groups/5383243/items/H9SGRTMQ?page=2&annotation=3TVGD5RH)
> ![[images/zotero/53832433TVGD5RH.png]]
> ^3TVGD5RHaH9SGRTMQg5383243p2
"The second phase of the structured programming paradigm entails working upward from the concrete objects and functions of the underlying machine to the more abstract objects and functions used throughout the modules produced by the top-down design. [...] This approach is reffered to as the method of levels of abstraction, or of information hiding." [@floydParadigmsProgramming1979a, pp. 1-2]
"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]
## les 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
Il existe beaucoup de langages qui implémentent plusieurs paradigmes de programmation [@ComparisonMultiparadigmProgramming2024]. Ces langages sotn appelés langages multi-paradigmes.
Par exemple, le langage prolog implémente à la fois la programmation logique et la programmation impérative [^20].
Un autre exemple peut être trouvé lorsque l'on ajoute une librairie de résolution de contraintes à un langage de programmation. Le paradigme de programmation par contraintes est alors ajouté au langage hôte, qui peut, par exemple, être un langage orienté objet [^21].
Nous verrons l'avantage des langages de programmation multi-paradigmes dans la section [[Remplissage du plan de L3#diversité des approches]]
## Définition de la puissance d'expression
La puissance d'expression (ou expressivité) d'un langage est la quantité d'idées qu'il peut représenter ou communiquer (*ref*).
"The more expressive a language is, the greater the variety and quantity of ideas it can be used to represent" (Plus un langage est expressiv, il peut exprimer une grande variété et un grande quantité d'idées) (*ref*).
La puissance d'expression (ou expressivité) d'un langage est la quantité et la diversité d'idées qu'il peut représenter ou communiquer [^22][^23].
On distingue deux sens du terme. D'un côté, l'expressivité théorique, qui se concentre sur la possibilité théorique d'exprimer une idée dans un langage, indépendamment de la difficulté pour exprimer cette idée. De l'autre côté, l'expressivité pratique, qui se concentre sur la concision et la facilité d'expression de ces idées.
> [!cite]+ [Expressive power (computer science)](zotero://select/groups/5383243/items/L9WYV33P) - [Page ](zotero://open-pdf/groups/5383243/items/Q9KCGU98?annotation=4FGMWNP7)
> In computer science, the expressive power (also called expressiveness or expressivity) of a language is the breadth of ideas that can be represented and communicated in that language.
>
> > [!note] Notes
> > expressivité := étendue des idées qui peuvent être représentées par un langage
> ^4FGMWNP7aQ9KCGU98g5383243
> [!cite]+ [Expressive power (computer science)](zotero://select/groups/5383243/items/L9WYV33P) - [Page ](zotero://open-pdf/groups/5383243/items/Q9KCGU98?annotation=ENM5Z4IE)
> The more expressive a language is, the greater the variety and quantity of ideas it can be used to represent.
> ^ENM5Z4IEaQ9KCGU98g5383243
> [!cite]+ [Expressive power (computer science)](zotero://select/groups/5383243/items/L9WYV33P) - [Page ](zotero://open-pdf/groups/5383243/items/Q9KCGU98?annotation=UL4ZYIV6)
> The term expressive power may be used with a range of meaning. It may mean a measure of the ideas expressible in that language:[2]
>
> regardless of ease (theoretical expressivity)
> concisely and readily (practical expressivity)
>
> ^UL4ZYIV6aQ9KCGU98g5383243
On distingue deux sens du terme. D'un côté, l'expressivité théorique, qui se concentre sur la possibilité théorique d'exprimer une idée dans un langage, indépendamment de la difficulté pour exprimer cette idée. De l'autre côté, l'expressivité pratique, qui se concentre sur la concision et la facilité d'expression de ces idées [^24].
### Au sens formel
La puissance d'expression au sens formel (ou expressivité formelle) est mesurée en regardant l'ensemble des idées qu'un langage peut exprimer.
Ce concept d'expressivité formelle est surtout utile en mathématiques ou en informatique théorique (notamment dans la théorie des langages formels) (*ref*)
> [!cite]- [Expressive power (computer science)](zotero://select/groups/5383243/items/L9WYV33P) - [Page ](zotero://open-pdf/groups/5383243/items/Q9KCGU98?annotation=8W7EHIJN)
> The first sense dominates in areas of mathematics and logic that deal with the formal description of languages and their meaning, such as formal language theory, mathematical logic and process algebra
>
> > [!note] Notes
> > expressivité théorique :
> > mathématique / logique.
> > en rapport avec la description formelle d'un langage.
> ^8W7EHIJNaQ9KCGU98g5383243
Ce concept d'expressivité formelle est surtout utile en mathématiques ou en informatique théorique (notamment dans la théorie des langages formels) [^25]
Pour un langage de programmation,
@ -488,6 +308,12 @@ Greg Michaelson critique la distinction des paradigmes, en expliquant que, lorsq
## diversité des approches
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
## créer un paradigme pour chaque type de problème
@ -507,3 +333,29 @@ Notamment :
De la même manière, connaître un langage de programmation ne permet pas de savoir immédiatement résoudre tous les problèmes que l'on peut rencontrer. Par exemple, la syntaxe des langages similaires à LISP est très simple et peut être apprise en quelques heures pour certains dialectes. Cependant, connaître la syntaxe complête et le fonctionnement de LISP ne permettra pas de résoudre tout problème : il est également nécessaire d'être capable de "faire le lien" entre un problème et un langage. C'est ce lien que les paradigmes de programmation permettent de faire, soit en donnant explicitement une méthode pour le faire (comme la [[paradigme programmation structurée|programmation structurée]]), soit en définissant comment le programmeur doit voir les programmes, soit en implémentant certaines fonctionnalités utiles pour gérer certains problèmes.
[^1]: "The contrast between function and procedure is a reflection of the general distinction between describing properties of things and describing how to do things, or, as it is sometimes referred to, the distinction between declarative knowledge and imperative knowledge. In mathematics we are usually concerned with declarative (what is) descriptions, whereas in computer science we are usually concerned with imperative (how to) descriptions." [@abelsonStructureInterpretationComputer1996, p.28]
[^2]: par exemple, Fellesein dans cette expression : "(let x be v in e) is expressible as (apply (procedure x e) v)" [@felleisenExpressivePowerProgramming1990, p.135]
[^3]: "A programming paradigm is an approach to programming a computer based on a mathematical theory or a coherent set of principles." [@royProgrammingParadigmsDummies]
[^4]: "It says a lot about what functional programming is _not_ [...] but not much about what it is." [@hughesWhyFunctionalProgramming1989, p.1]
[^5]: "It is a logical impossibility to make a language more powerful by ommitting features, no matter how bad they may be" [@hughesWhyFunctionalProgramming1989, p.1]
[^6]: From the programmer’s viewpoint, a closure is a “packet of work”: a program can transform any instructions into a closure at one point in the program, pass it to another point, and decide to execute it at that point. The result of its execution is the same as if the instructions were executed at the point the closure was created. [@royProgrammingParadigmsDummies, p.24]
[^7]: "From an implementation viewpoint, a closure combines a procedure with its external references (the references it uses at its definition)." [@royProgrammingParadigmsDummies, p.24]
[^8]: "Dans un langage de programmation, une fermeture ou clôture (en anglais : closure) est une fonction accompagnée de son environnement lexical. L'environnement lexical d'une fonction est l'ensemble des variables non locales qu'elle a capturées, soit par valeur (c'est-à-dire par copie des valeurs des variables), soit par référence (c'est-à-dire par copie des adresses mémoires des variables)[1]. Une fermeture est donc créée, entre autres, lorsqu'une fonction est définie dans le corps d'une autre fonction et utilise des paramètres ou des variables locales de cette dernière." [@FermetureInformatique2024]
[^9]: "Une fermeture peut être passée en argument d'une fonction dans l'environnement où elle a été créée (passée vers le bas) ou renvoyée comme valeur de retour (passée vers le haut). Dans ce cas, le problème posé alors par la fermeture est qu'elle fait référence à des données qui auraient typiquement été allouées sur la pile d'exécution et libérées à la sortie de l'environnement. Hors optimisations par le compilateur, le problème est généralement résolu par une allocation sur le tas de l'environnement." [@FermetureInformatique2024]
[^10]: "Control flow in imperative programming is explicit: commands show how the computation takes place, step by step. Each step affects the global state of the computation." [@toalProgrammingParadigms]
[^11]: "Control flow in declarative programming is implicit: the programmer states only what the result should look like, not how to obtain it." [@toalProgrammingParadigms]
[^12]: "In functional programming, control flow is expressed by combining function calls, rather than by assigning values to variables" [@toalProgrammingParadigms]
[^13]: "Functional programming is so called because a program consists entirely of functions. The main program itself is written as a function which recieves the program's input as its argument and delivers the program's output as its result. Typically the main function is defined in terms of other functions, which in turn are defined in terms of still more functions, until at the bottom level the functions are language primitives. These functions are much like ordinary mathematical functions, and in this paper will be defined by ordinary equations." [@hughesWhyFunctionalProgramming1989, p.1]
[^14]: "En mathématiques et en informatique, les fonctions d'ordre supérieur sont des fonctions qui ont au moins une des propriétés suivantes : elles prennent une ou plusieurs fonctions en entrée ; elles renvoient une fonction." [@FonctionOrdreSuperieur2023]
[^15]: La logique combinatoire est un système de calcul dans lequel toutes les fonctions sont pures (il n'y a que des fonctions d'ordre supérieur dans ce système) [@LogiqueCombinatoire2023]
[^16]: "Structured programming is a programming paradigm aimed at improving the clarity, quality, and development time of a computer program by making extensive use of the structured control flow constructs of selection (if/then/else) and repetition (while and for), block structures, and subroutines." [@StructuredProgrammingWikipedia]
[^17]: "'Selection'; one or a number of statements is executed depending on the state of the program. This is usually expressed with keywords such as if..then..else..endif. The conditional statement should have at least one true condition and each condition should have one exit point at max." [@StructuredProgrammingWikipedia]
[^18]: "'Iteration'; a statement or block is executed until the program reaches a certain state, or operations have been applied to every element of a collection. This is usually expressed with keywords such as while, repeat, for or do..until. Often it is recommended that each loop should only have one entry point (and in the original structural programming, also only one exit point, and a few languages enforce this)." [@StructuredProgrammingWikipedia]
[^19]: "The most important difference between structured and unstructured programs is that the former are designed in a modular way. Modular design brings great productivity improvements. First of all, small modules can be coded quickly and easily. Secondly, general purpose modules can be reused, leading to faster development of subsequent programs. Thirdly, the modules of a program can be tested independently, helping to reduce the time spent debugging." [@hughesWhyFunctionalProgramming1989, p.2]
[^20]: "Prolog: The first paradigm is a logic programming engine based on unification and depth-first search. The second paradigm is imperative: the assert and retract operations which allow a program to add and remove program clauses." [@royProgrammingParadigmsDummies, p.18]
[^21]: "Solving libraries (e.g., Gecode): The first paradigm is a solver library based on advanced search algorithms, such as Gecode. The second paradigm is added by the host language, e.g., C++ and Java support object-oriented programming." [@royProgrammingParadigmsDummies, p.18]
[^22]: "In computer science, the expressive power (also called expressiveness or expressivity) of a language is the breadth of ideas that can be represented and communicated in that language." [@ExpressivePowerComputer2023]
[^23]: "The more expressive a language is, the greater the variety and quantity of ideas it can be used to represent" [@ExpressivePowerComputer2023]
[^24]: "The term expressive power may be used with a range of meaning. It may mean a measure of the ideas expressible in that language: regardless of ease (theoretical expressivity); concisely and readily (practical expressivity)" [@ExpressivePowerComputer2023]
[^25]: "The first sense dominates in areas of mathematics and logic that deal with the formal description of languages and their meaning, such as formal language theory, mathematical logic and process algebra" [@ExpressivePowerComputer2023]

14
sources/zotero/LogiqueCombinatoire2023.md Normal file
View File

@ -0,0 +1,14 @@
---
zotero-key: 9RYAKXF2g5383243
zt-attachments:
- "266"
citekey: LogiqueCombinatoire2023
---
up:: [[zotero literature notes]]
link:: [Zotero](zotero://select/groups/5383243/items/9RYAKXF2) [attachment](file:///Users/oscarplaisant/Zotero/storage/5ZRIGAB3/Logique_combinatoire.html)
#pkm #zotero
> [!cite]+ [Logique combinatoire](zotero://select/groups/5383243/items/9RYAKXF2) - [Page ](zotero://open-pdf/groups/5383243/items/5ZRIGAB3?annotation=6UG45AG4)
> En logique mathématique, la logique combinatoire est une théorie logique[1] introduite par Moses Schönfinkel[2] en 1920 lors d'une conférence[Laquelle ?] et développée dès 1929 par Haskell Brooks Curry[3] pour supprimer le besoin de variables en mathématiques, pour formaliser rigoureusement la notion de fonction et pour minimiser le nombre d'opérateurs nécessaires pour définir le calcul des prédicats à la suite de Henry M. Sheffer. Plus récemment, elle a été utilisée en informatique comme modèle théorique de calcul et comme base pour la conception de langages de programmation fonctionnels.
> ^6UG45AG4a5ZRIGAB3g5383243

2
templates/zotero/zt-cite.eta.md
View File

@ -1 +1 @@
[[<%= it.map(lit => `${lit.citekey ?? lit.DOI ?? lit.title ?? lit.key}`).join("; ") %>]]
[<%= it.map(lit => `@${lit.citekey}`).join("; ") %>]