The `$:/gf-preconnect` tiddler contains the pre connect logic. Then choose a tiddler and add things like: ```html
```
This
TiddlyWiki
contains the following tiddlers:
$:/build
$:/config/AnimationDuration
$:/config/AutoFocus
$:/config/AutoSave
$:/config/codemirror-6/autocompleteIcons
$:/config/codemirror-6/fontsize
$:/config/codemirror-6/lineNumbers
$:/config/codemirror-6/snippetPreview
$:/config/codemirror-6/vimJK
$:/config/codemirror-6/vimmode
$:/config/DownloadSaver/AutoSave
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/bold
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/clear
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/heading-1
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/heading-2
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/heading-3
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/italic
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/line-width
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/mono-block
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/mono-line
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/opacity
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/paint
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/quote
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/rotate-left
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/size
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/stamp
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/subscript
$:/config/EditorToolbarButtons/Visibility/$:/core/ui/EditorToolbar/superscript
$:/config/EditorToolbarButtons/Visibility/$:/plugins/bimlas/asciidoctor/EditorToolbar/heading-2
$:/config/EditorToolbarButtons/Visibility/$:/plugins/bimlas/asciidoctor/EditorToolbar/heading-3
$:/config/EditorToolbarButtons/Visibility/$:/plugins/bimlas/asciidoctor/EditorToolbar/heading-4
$:/config/EditorToolbarButtons/Visibility/$:/plugins/bimlas/asciidoctor/EditorToolbar/heading-5
$:/config/EditorToolbarButtons/Visibility/$:/plugins/bimlas/asciidoctor/EditorToolbar/heading-6
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/bold
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/heading-1
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/heading-2
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/heading-3
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/heading-4
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/heading-5
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/heading-6
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/italic
$:/config/EditorToolbarButtons/Visibility/$:/plugins/tiddlywiki/markdown/EditorToolbar/mono-line
$:/config/Navigation/openLinkFromInsideRiver
$:/config/Navigation/openLinkFromOutsideRiver
$:/config/Navigation/Permalinkview/UpdateAddressBar
$:/config/Navigation/UpdateAddressBar
$:/config/Navigation/UpdateHistory
$:/config/NewJournal/Tags
$:/config/NewJournal/Text
$:/config/NewJournal/Title
$:/config/NewTiddler/Tags
$:/config/PageControlButtons/Visibility/$:/core/ui/Buttons/new-journal
$:/config/PageControlButtons/Visibility/$:/plugins/bimlas/asciidoctor/new-asciidoctor-button
$:/config/PageControlButtons/Visibility/$:/plugins/tiddlywiki/markdown/new-markdown-button
$:/config/Plugins/Disabled/$:/plugins/snowgoon88/edit-comptext
$:/config/RelinkOnRename
$:/config/section-editor/config-editor-type
$:/config/section-editor/hlevel
$:/config/shortcuts-linux/bold
$:/config/shortcuts-not-mac/italic
$:/config/shortcuts/bold
$:/config/shortcuts/cancel-edit-tiddler
$:/config/shortcuts/layout-switcher
$:/config/shortcuts/list-bullet
$:/config/shortcuts/toggle-sidebar
$:/config/TextEditor/EditorHeight/Height
$:/config/TextEditor/EditorHeight/Mode
$:/config/TiddlyTools/CenterStory
$:/config/ViewToolbarButtons/Visibility/$:/core/ui/Buttons/close-others
$:/config/ViewToolbarButtons/Visibility/$:/core/ui/Buttons/info
$:/config/WikiParserRules/Inline/wikilink
$:/core
$:/core/ui/EditorToolbar/preview
$:/core/ui/EditTemplate
$:/DefaultTiddlers
$:/enotes/macros
$:/EvidentlyCube/Trigger/1
$:/EvidentlyCube/Trigger/2
$:/EvidentlyCube/Trigger/3
$:/gf-preconnect
$:/GitHub/Branch
$:/GitHub/Filename
$:/GitHub/Path
$:/GitHub/Repo
$:/GitHub/ServerURL
$:/GitHub/Username
$:/Import
$:/isEncrypted
$:/layout
$:/palette
$:/plugins/bimlas/asciidoctor
$:/plugins/EvidentlyCube/AutoComplete
$:/plugins/EvidentlyCube/AutoComplete/Config
$:/plugins/felixhayashi/tiddlymap/graph/nodeTypes/tmap:central-topic
$:/plugins/felixhayashi/tiddlymap/graph/nodeTypes/tmap:neighbour
$:/plugins/felixhayashi/tiddlymap/graph/views/Default/filter/edges
$:/plugins/felixhayashi/tiddlymap/graph/views/Default/filter/nodes
$:/plugins/felixhayashi/tiddlymap/graph/views/Default/map
$:/plugins/felixhayashi/tiddlymap/graph/views/Live View
$:/plugins/felixhayashi/tiddlymap/graph/views/Live View/filter/edges
$:/plugins/felixhayashi/tiddlymap/misc/meta
$:/plugins/flibbles/relink
$:/plugins/hoelzro/full-text-search
$:/plugins/hoelzro/full-text-search/auto-index
$:/plugins/hoelzro/progress-bar
$:/plugins/kookma/commander
$:/plugins/kookma/refnotes
$:/plugins/kookma/section
$:/plugins/kookma/section/viewtemplates/sections
$:/plugins/kookma/shiraz
$:/plugins/kookma/shiraz/styles/multicols/storyriver
$:/plugins/kookma/shiraz/styles/ui/colorify-buttons
$:/plugins/kookma/shiraz/styles/ui/edit-toolbar-buttons
$:/plugins/kookma/shiraz/styles/ui/view-toolbar-button-visibility
$:/plugins/kookma/shiraz/ui/Buttons/SwitchPalette
$:/plugins/kookma/todolist
$:/plugins/oeyoews/tiddlywiki-codemirror-6
$:/plugins/sukima/reveal-js
$:/plugins/tiddlywiki/bibtex
$:/plugins/tiddlywiki/highlight
$:/plugins/tiddlywiki/katex
$:/plugins/tiddlywiki/markdown
$:/section-editor/state/2024-03-22
$:/section-editor/state/Cargo-spec-for-documentation
$:/section-editor/state/TypeScript-language
$:/SiteSubtitle
$:/SiteTitle
$:/state/advancedsearch/currentTab
$:/state/codemirror-6/settings/search
$:/state/commander/reveal/$:/plugins/kookma/commander/log/ui--23637530
$:/state/dropdown/keyboardshortcut/cancel-edit-tiddler--502179266
$:/state/edit/references--1364968853
$:/state/edit/references--190860990
$:/state/Excise/--1174324712/type
$:/state/Excise/--1833380378/type
$:/state/Excise/-583106134/type
$:/state/http-requests
$:/state/oeyoews/codemirror6/status/save
$:/state/search/currentTab
$:/state/tab--1498284803
$:/state/tab--1963855381
$:/state/tab--23637530
$:/state/tab--255477469
$:/state/tab-1749438307
$:/state/tab-1912911341
$:/state/tab-2065006209
$:/state/tab/moresidebar-1850697562
$:/state/tab/search-results/sidebar
$:/state/tab/sidebar--595412856
$:/status/RequireReloadDueToPluginChange
$:/StoryList
$:/theme
$:/themes/tiddlywiki/snowwhite
$:/themes/tiddlywiki/vanilla
$:/themes/tiddlywiki/vanilla/metrics/bodyfontsize
$:/themes/tiddlywiki/vanilla/metrics/bodylineheight
$:/themes/tiddlywiki/vanilla/metrics/fontsize
$:/themes/tiddlywiki/vanilla/metrics/lineheight
$:/themes/tiddlywiki/vanilla/metrics/sidebarbreakpoint
$:/themes/tiddlywiki/vanilla/metrics/sidebarwidth
$:/themes/tiddlywiki/vanilla/metrics/storyleft
$:/themes/tiddlywiki/vanilla/metrics/storyright
$:/themes/tiddlywiki/vanilla/metrics/storywidth
$:/themes/tiddlywiki/vanilla/metrics/tiddlerwidth
$:/themes/tiddlywiki/vanilla/options/codewrapping
$:/themes/tiddlywiki/vanilla/options/sidebarlayout
$:/themes/tiddlywiki/vanilla/settings/codefontfamily
$:/themes/tiddlywiki/vanilla/settings/editorfontfamily
$:/themes/tiddlywiki/vanilla/settings/fontfamily
$:/todolist/data/done/Simple
$:/todolist/data/priority/Simple
$:/todolist/data/state/<<currentTiddler>>
$:/todolist/data/state/$(currentTiddler
$:/todolist/data/state/$(currentTiddler)
$:/todolist/data/state/2022-05-24
$:/todolist/data/state/2022-05-25
$:/todolist/data/state/2022-05-31
$:/todolist/data/state/2022-07-06
$:/todolist/data/state/2022-07-14
$:/todolist/data/state/2022-07-26
$:/todolist/data/state/2022-08-01
$:/todolist/data/state/2022-10-19
$:/todolist/data/state/2023-02-20
$:/todolist/data/state/2023-03-29
$:/todolist/data/state/2023-10-31
$:/todolist/data/state/base
$:/todolist/data/state/Draft of '2022-05-25'
$:/todolist/data/state/Draft of '2022-07-06'
$:/todolist/data/state/Draft of '2023-03-29'
$:/todolist/data/state/journal
$:/todolist/data/state/Simple
$:/todolist/data/status/Simple
$:/todolist/data/tasks/2022-05-23
$:/todolist/data/tasks/2022-05-24
$:/todolist/data/tasks/2022-05-25
$:/todolist/data/tasks/2022-05-31
$:/todolist/data/tasks/2022-07-06
$:/todolist/data/tasks/2022-07-14
$:/todolist/data/tasks/2022-07-26
$:/todolist/data/tasks/2022-08-01
$:/todolist/data/tasks/2022-10-19
$:/todolist/data/tasks/2023-02-20
$:/todolist/data/tasks/2023-03-29
$:/todolist/data/tasks/2023-10-31
$:/todolist/data/tasks/base
$:/todolist/data/tasks/journal
$:/todolist/data/tasks/Simple
$:/view
2019-01-08 My Eureka Moment with the TiddlyWiki
2022-02-02
2022-02-03
2022-02-04
2022-02-07
2022-02-08
2022-02-09
2022-02-10
2022-02-11
2022-02-15
2022-02-16
2022-02-17
2022-02-23
2022-02-24
2022-02-25
2022-03-15
2022-03-17
2022-03-18
2022-03-22
2022-03-23
2022-03-24
2022-03-29
2022-03-30
2022-04-04
2022-04-06
2022-04-13
2022-04-28
2022-04-29
2022-05-02
2022-05-03
2022-05-11
2022-05-12
2022-05-13
2022-05-17
2022-05-18
2022-05-19
2022-05-20
2022-05-23
2022-05-24
2022-05-25
2022-05-26
2022-05-28
2022-05-30
2022-05-31
2022-06-01
2022-06-02
2022-06-03
2022-06-05
2022-06-07
2022-06-09
2022-06-10
2022-06-11
2022-06-13
2022-06-16
2022-06-17
2022-06-21
2022-06-28
2022-06-30
2022-07-06
2022-07-07
2022-07-14
2022-07-23
2022-07-26
2022-07-27
2022-08-01
2022-08-05
2022-08-17
2022-08-18
2022-10-08
2022-10-10
2022-10-18
2022-10-19
2022-10-20
2022-10-28
2022-10-31
2022-11-15
2023-02-20
2023-03-15
2023-03-16
2023-03-27
2023-03-28
2023-03-29
2023-04-12
2023-05-01
2023-06-24
2023-07-13
2023-07-15
2023-07-26
2023-08-08
2023-08-09
2023-08-14
2023-08-15
2023-08-18
2023-08-20
2023-08-23
2023-08-28
2023-08-29
2023-09-05
2023-09-14
2023-10-16
2023-10-17
2023-10-24
2023-10-26 clojure koans
2023-10-26 Clojure-reagent
2023-11-01
2023-11-08
2023-11-11
2023-11-14
2023-11-17
2023-12-04
2023-12-06
2023-12-11
2023-12-12
2023-12-13 simplicity for a computing system
2023-12-17
2023-12-18 reading out-of-the-tar-pit
2023-12-24 Kanran reasoning over knowledge to make relations apparent
2024-03-19 Temporal visualization needs
2024-03-21 Web interactive visualizations
2024-03-22 GoJS and JointJS are not sufficient
2024-03-23 Thoughts on structural behavioral modularity and atomicity
2024-03-25 modularity and type systems
2024-03-27
2024-03-31
2024-04-02
2024-04-07 Looking at graphics and drawing APIs
2024-04-13 web layouts feel static and isolated
2024-04-20-Web-is-a-document-focused-medium
2024-04-24 Doing some EverGreen notes curation
2024-04-25
2024-04-27 Clojure editor and sussman propagator
2024-07-12
2024-07-28
2024-09-03
2024-09-21 Messaging and Serialization
2024-12-01 Mojo uses python frontend to compiler infrastructure
2024-12-22
2024-12-23
2025-05-01: the Erlang story
2025-05-03: testing message passing systems
2025-05-04: making tiddly wiki web application
2025-05-17: AI and configuration as code
2025-06-03
2025-06-04: Application structure
A-language-must-be-designed-to-grow
A-note-on-CLU
Aadl-in-practice
AADL-modeling
About-these-notes
Academic-searching-tools
Access-control-is-not-unique-to-OS-kernels
Achieving-several-goals-simultaneously
Active-learning
Active-object-for-concurrent-execution
actor
Actor-behavior
Actor-mail-system
Actor-model-enables-local-verification
Actor-model-enables-scaling-and-extensibility
Actor-model-of-computation
Actor-model-vs-lambda-model
Actor-naming-implies-rights
Actor-programming-kernel
Actor-tasks
Actors-a-model-of-concurrent-computation-in-distributed-systems
Actors-general-design-decisions
Actors-general-expressions
Actors-Hewitt
AES-key-wrap-rational
Agha-actors-a-model-of-concurrent-computation-in-distributed-systems
Agha1985-actors-a-model-of-concurrent-computation-in-distributed-systems
Agile-describes-rapid-iterative-development
AI-as-our-way-to-leverage-our-experts
AI-can-transform-education-and-learning
Alan-kay
Alan-kay-definition-of-object-oriented
Algol-language
AlgolSixty-syndrome
Alphard-forms
ARINC653
Asciidoc-for-writing-content
Asciidoc-one-sentence-per-line
ashrafian2010-how-to-read-a-paper
ASN1-encoding
Asynchronous-communication-is-foundation-for-synchronous
atkinson-hewitt-1977-synchronization-in-actor-systems
Atomic-habits-focus-on-systems-for-continual-improvement
Attitude-control
Attitude-kinematics-and-dynamics
Automated-layout-algorithms
Automated-upgrades-should-be-a-primary-principle
Awesome-talks
Backus
baker-hewitt-incremental-garbage-collection-1977
Balance-reusing-existing-approaches-and-innovation
Barrelfish-distributed-os
Beating-the-averages
Beating-the-averages-summary
Beautiful-racket-notes
Bret-victor-humane-representation-of-thoughts
Bret-victor-inventing-on-principle
Buddy-allocator
Buffered-communication-assumption-allows-reasoning-about-correctness
Buffering-is-required-for-atomic-communication
Bump-allocator
Cal-tss-naming-and-access-rights
Cal-tss-operations-are-extension-points-and-specifications
Cal-tss-resource-accounting
Cal-tss-system-extendability
Caliptra-root-of-trust-for-socs
Call-by-future
Call-by-name
Call-by-reference
Call-by-sharing
Call-by-value
Can-programming-be-liberated-from-the-von-neumann-style
Cantrill-use-visualizations-and-queries-to-understand-system
Capabilities-are-actors
Capabilities-for-isolation-and-authorization
Capabilities-vs-access-control-lists
Capability-based-system-structure
Capn-proto
Cargo-spec-for-documentation
Channel-primitive-apis
Checkpoint-and-recovery-mechanism
Chisel-language
Clans-and-chiefs-approach-for-message-control-mechanism
Classes-simula
Clojure-getting-started
Clojure-language
Clojure-notes
Clojure-pathom
Clojure-references
Clojure-spec-WIP
Clojure-structural-editing
Close-open-loops
Closure-made-simple
CLU-abstract-type-creation
CLU-approach-to-safety
CLU-design-principles
CLU-design-principles-snippet
CLU-design-process
CLU-design-process-snippet
CLU-error-model
CLU-implementing-abstract-types
CLU-iterators-as-new-control-structure
CLU-language-goals
CLU-language-goals-snippet
CLU-object-universe-is-independent-from-programs
CLU-operation-naming-and-uniformity
CLU-parameter-passing
CLU-parametric-polymorphism
CLU-programming-methodology
CLU-programming-methodology-snippet
CLU-related-work
CLU-related-work-snippet
CLU-semantic-model
Clusters-CLU
Codd
Code-inflation-for-true-command
Collectors-fallacy
Combinatorial-explosion-as-more-parties-communicate
Command-query-response-pattern
Common-trace-format
Communicate-asynchronously-for-deep-work
Communicate-with-messages
Communicating-sequential-processes
Communicating-sequential-processes-approach
Communicating-sequential-processes-comparison-with-subroutines
Communicating-sequential-processes-coroutines
Communicating-sequential-processes-introduction
Communicating-sequential-processes-motivation
Communicating-sequential-processes-naming
Communicating-sequential-processes-notation
Communication-modularity-and-extensibility
Comparison-of-approaches-that-won
Compile-time-concurrency-correctness
Compiler-as-copilot-helps-catch-mistakes
Complecting-things-is-source-of-complexity
Complex-ideas-may-be-hard-to-learn-because-their-components-overflow-working-memory
Complex-system
Complex-systems-are-composed-of-disjoint-ideas
Complexity-caused-by-control
Complexity-caused-by-large-volumes
Complexity-caused-by-state
Complexity-growth-and-correctness-are-tied
Composition-algebra-for-computing
Composition-is-required-for-optimization
Computation-in-actor-systems
Computation-sequence-is-erroneously-forced-in-many-languages
Concurrency-algorithms
Concurrency-cost-hierarchy
Concurrent systems reading
Concurrent-pascal
Configuration-as-code
Continuous-change-decentralization-and-negotiation-are-required-system-properties
Conway-says-designs-copy-their-organizations-communication-structure
Cooperative-task
Coordinated-and-efficient-huge-page-management-with-ingens
Coroutine
Coroutines-unix
Costs-of-collaboration
Create-better-specifications-by-keeping-implementations-in-mind
Crimson Pro
Criticisms-of-object-oriented-design
Cryptographic-protocol-verification
CSS is an underpowered description language
Curry-howard-isomorphism-between-logic-and-types
Custom-Tiddler-stylesheet
Daley-dennis-1968-Virtual-memory-processes-and-sharing-in-multics
Data-abstraction
Data-representation-failure-of-xml
Dataflow
Dataspaces-as-abstraction-for-managing-resources
Datomic
Decentralization-removes-simultaneity-and-consistency
Deep-understanding-requires-detailed-knowledge-of-fundamentals
Dependent-types
Dependent-types-in-typescript
Design-for-continual-improvement
Design-issues-in-parallel-architectures-for-artificial-intelligence
Design-of-a-separable-transition-diagram-compiler
Design-patterns-should-be-automated
design-philosophy
Device-identifier-composition-engine
DICE-measured-boot
Dijkstra
Dijkstra-make-linear-text-describe-temporal-behavior
Distill-projects-to-their-essentials
Distilling-knowledge-procedure
Distributed-systems-required-properties
Distributed-systems-required-properties-bullets
Distributed-systems-required-properties-first-pass
Distributed-systems-required-properties-second-pass
Domain-name-system-as-runtime-resource-lookup
Dont-communicate-by-sharing-memory-share-memory-by-communicating.
Doug-McIlroy
DSLs-lose-tooling-for-mainstream-language
Dynamic-dispatch
Dynamic-partitioning
E-Prime-for-clear-writing
Early-binding
economics
EDay
Effective-engineer-notes
Efficiency-through-identifying-least-amount-of-computation
elphinstone2013-what-have-we-learned-in-20-years-of-l4-microkernels
Endpoint-discovery-versus-introduction
Endpoints-instead-of-threads-for-communication
ENight
Entries-PLI
EPaper
EQL-describes-information-requirements
Eric-Normand
Erlang
Erlang-behaviors-and-callback-modules
Erlang-out-of-order-receive
Erlang-process-registration-for-naming
Erlang-runtime-updates
Eros-space-bank
Esterel-as-a-language-for-control
Evaluation-strategy-for-evaluating-expressions
Event-sourcing-pattern-for-state-updates
Eventcount
EvergreenNotes
EverParse-3d-dependent-data-description
Everything-is-a-Tiddler
Everything-is-asynchronous
Excalidraw-vs-tldraw
Executable-specifications
Executable-specifications-needs
experiences-using-lightweight-formal-methods-for-requirements-modeling-easterbrook1998
Extensibility-ensures-applicability-to-future-problems
Fail-fast-and-noisily
Favor-composition-over-inheritance
Ferros-for-language-assisted-sel4-development
FidlProtocolGenerator
FidlTraits
Finding-a-way-out-review
First-class-properties-are-extendable-and-composable
fonts
ford1994-migrating-thread-model
Formal-specification
forms
Fred-brooks
Fred-brooks-on-state-complexity
Fstar-notation-for-dependent-types
Fuchsia-OS
Fulcro-clojure-graph-ui-and-data-framework
Fully-custom-approaches-across-independent-areas-is-failure-prone
Functional-programming
Functional-reactive-programming
FunctionalLanguage
Functions-transform-values
Futures-as-exact-sized-stacks
Garbage-collection
Genode-operating-system-framework
Getting-things-done
Git-is-log-based-data-structure-for-events
Globally-asynchronous-locally-synchronous
Go-concurrency-patterns
Go-concurrent-service-with-cancel-cmd
Go-language
Go-select-statement-concurrently-waits-on-multiple-channels
Go-statement-considered-harmful
Goals
Goto-statement-considered-harmful
Gradual-type-system
Gray-using-temporal-logic-to-specify-and-verify-cryptographic-protocols
Great-speeches
Greenspuns-tenth-rule-on-complex-systems-reinvent-lisp
Groovy notes
Guarded-atomic-actions
Guarded-commands
Guarded-commands-enable-specifications-without-erroneously-forcing-order
Guarded-page-tables
Halide-language-for-scheduling-computations
Hand-written-assembly-kernels-dont-scale
hansen1976-concurrent-pascal
Haskell-applicative-functor
Haskell-functors
Haskell-type-newtype-vs-data
Haskell-typeclass
Heap-allocation
Heilmeier-catechism-for-evaluating-approaches
Hepta Slab
Heterogeneous-computation
Hewitt
Hewitt-activation-frame
Hewitt-packagers
Hewitt-paper-summaries
hewitt1973
hewitt1977
hewitt1977-laws-for-communicating-parallel-processes
hewitt1984-design-issues-in-parallel-architectures
Hexagonal-architecture
Higher-order-virtual-machine
History-of-clu
hoare1969-axiomatic-basis-for-computer-programming
hoare1972-proof-of-correctness-of-data-representations
hoare1974-monitors-an-operating-system-concept
hoare1978-communicating-sequential-processes
Hours-arent-equal
How-things-get-stuck-and-how-to-get-moving-again
How-to-collect-notes-while-reading
How-to-embrace-asynchronous-communication-for-remote-work
How-to-make-ad-hoc-polymorphism-less-add-hoc
How-to-read-a-paper
Hubris-operating-system
Hubris-os-configuration-as-code
Hubris-panic-instead-of-recoverable-error
Hubris-supervisor-can-restart-tasks
Hunam-chapter-3-versioning-and-persistence
Hunam-chapter-3-versioning-and-persistence-snippet
Hunam-chapter-4-turtling-down-the-tower-of-babel
Hunam-chapter-4-turtling-down-the-tower-of-babel-snippet
Hunam-chapter-5-non-stop-change
Hunam-chapter-5-non-stop-change-snippet
Hunam-chapter-6-kernels
Hunam-chapter-6-kernels-snippet
Hunam-computing-chapter-11-a-workhorse-and-its-tools
Hunam-computing-chapter-11-a-workhorse-and-its-tools-snippet
Hunam-computing-chapter-7-platforms-not-applications
Hunam-computing-chapter-7-platforms-not-applications-snippet
Hunam-computing-chapter-8-interprocess-communication
Hunam-computing-chapter-8-interprocess-communication-snippet
Hunam-computing-chapter-9-build-systems
Hunam-computing-chapter-9-build-systems-snippet
Hunam-computing-point-of-view
Hunams-chapter-1-computing-simplicity
Hunams-chapter-1-computing-simplicity-snippet
Hunams-chapter-2-saving
Hunams-chapter-2-saving-snippet
Iceoryx-for-zero-copy-ipc
Ideas
ideas-about-knowledge
If-youre-not-writing-a-program-dont-use-a-programming-language
Img-Futures-with-inprocess-channels
img-init-mem-data-structures.svg
img-qnx-send-reply-recv
img-segments-fragmentation
Immediate-connection-to-what-your-create
Import Bibtex
Incidental-complexity
Incremental-garbage-collection-of-processes
Incremental-program-specification-is-the-only-feasible-approach
industry-approach
Inferno-operating-system
Integrating-concepts-across-papers
Intentional-work
Interactive-visualization-approaches
Interprocess-Communication
Intrinsic-motivation-is-required-for-improvement
Intrusive-data-structures
Investor-funded-compensation-vs-customer-funded-compensation
Iterators-as-control-structure
JavaScript-language
Javascript-plugins-and-security
JetBrains Mono
JoeArmstrong
Knowledge-requires-ability-to-generalize-and-make-connections
Kry10-secure-platform
kwon2016-huge-page-management-with-ingens
L3-a-persistent-system-in-real-use
Lamport-on-specifications-clear-sloppy-thinking
lamport-specifying-concurrent-program-modules
Lampson
lampson1969
lampson1979-experience-with-processes-and-monitors-in-mesa
Language-as-law-enforcement
language-design
Language-server-protocol
Language-virtual-machine
Language-vs-library-for-design
Language-we-use-for-ideas-shapes-our-ideas
Late-binding
Laws-for-communicating-parallel-processes
Layered-construction-for-reliability-and-flexibility
Lazy-execution
Learn-you-a-haskell-fistfull-of-monads
learning
learning-system
learning-technique
learning-wisdom
Leslie-lamport
Less-is-more-philosophy
Let-it-crash-and-code-for-the-happy-path
Liedtke_1993-L3-a-persistent-system-in-real-use
Liedtke-papers-and-ideas
liedtke1994-page-table-structures-tr
liedtke1994-sparse-address-spaces
Limbo-language
Linear-text-obscures-simple-concurrent-structures
Linux-documentation
Linux-memory-management
Linux-tracing-toolkit
Liskov
liskov_design_1972
liskov1996-a-history-of-clu
LISP-a-language-for-stratified-design-sussman_lisp_1987
Lisp-form
Lisp-language
lister1977-problem-of-nested-monitor-calls
Literature-notes-are-secondary-and-separate
LLVM-intermediate-representation-for-abstraction
Machine-checked-properties
Machine-parseable-security-requirements
Macro-systems-for-growing-a-language
Manual-processes-are-not-scalable-and-are-error-prone
Manycore-processing
Markley2014-fundamentals-of-spacecraft-attitude-determination-and-control
Markup-languages-focus-on-documents-not-meaning
Meetings-arent-free
Melvin-conway
Memory-heap
Merkle-tree-hashes-with-hierarchy
Message-passing
Message-passing-for-procedure-invocation
Message-queues-enable-decoupling
Messaging-passing-and-actor-composition-challenge
Meta-modeling-decribes-model-construction-approaches
Metacommentary
Microkernel-debate
Microkernels-enable-closed-source-barriers
Migrating-thread-model
MILS
Mind-sized-bites
MLIR-a-compiler-infrastructure-for-the-end-of-moores-law
Mnemonic-medium
Modality-for-causal-event-tracing
Model-view-controller-thing
Modularity-and-specifications-are-coupled
Modularity-is-what-program-components-should-look-like
Mojo-programming-language
Moldable-development
Moldable-ideas
Monad
Monitors-an-operating-system-structuring-concept
Monomorphism-generates-specific-code-from-generic-description
Moose-analysis-platform
Mosely
Multi-kernel
Multi-process-communication
Mutex-for-concurrent-sharing
Name-resolution-in-rust
Naming-and-discovery
Naming-of-processes
NASA-study-on-flight-software-complexity
NEAT-principle
Nested-locks-problem
Nix-related
No-ghosts-design-principle-for-components-in-complex-software-systems
No-silver-bullet-essence-and-accidents-of-software-engineering
Node-red-design-choices-for-visual-environment
Non-linear-note-taking-is-more-effective
Notebook-based-interface
Object-oriented
Object-oriented-considered-harmful
Observability-enables-understanding-a-system-from-the-outside
On-reliable-and-extendable-operating-systems
On-the-criteria-to-be-used-in-decomposing-systems-into-modules
Open-telemetry
operating-system
Operating-system-history
Out-of-the-tar-pit
Out-of-the-tar-pit-with-functional-programming-and-relational-data
Out-of-the-tar-pit: accidents-and-essence
Out-of-the-tar-pit: causes-of-complexity
Out-of-the-tar-pit: classical-approaches-to-managing-complexity
Out-of-the-tar-pit: recommended-approach
papert-mindstorms-children-computers-and-powerful-ideas
Parnas
parnas_criteria_1972
Passive-procedure
Pattern-matching
People-to-follow
Pete-Worden
Pharo-language
Piqi-data-model-and-serialization
Polymorphism
Pomodoro-technique
Poor-tooling-affects-our-ability-to-solve-problems
Power-of-simplicity
Presentation-on-early-programming-languages-evolution
Presentations-are-a-roadmap-of-ideas-and-their-relationships
Problems-with-inheritance
Procedures-Algol60
Process-has-internal-state
Process-isolation-enables-robust-integration
Program-verification-is-secondary-to-specification
Programming-in-the-small
Programming-languages-are-identical-but-shape-your-thought
Programs-as-data
Prolog-language
Protocol-buffers
Protocol-oriented-programming-in-swift
Protocol-oriented-programming-in-swift-takeaways
Protocol-oriented-programming-in-swift-transcript
Protocol-ossification
Pull based semantics
Purpose-of-any-language-is-to-communicate
Purpose-of-type-systems
Python-subclassing-approaches
QNX-based-message-passing
QNX-tracing-approach
Quotes-on-complexity
Racket-language
Racket-language-references
RDF-for-expressing-information
Re-use-is-knowledge-leverage
React-functions-and-components
React-language
Reactive-demand-programming
Reader-application-for-papers
Reader-expander-approach-for-language-design
Reading-a-water-meter
Reading-lists
Real-time-operating-system-types-and-libraries
Reference-on-cost-of-code-reading-and-understanding
References-footer
Relationships-are-structural-and-temporal
Reliability-requires-isolated-modules
Removing-capabilities-can-add-functionality
RenameTags
Rendezvous-channel-for-communication-and-synchronization
REPL-driven-development-for-immediate-feedback
Replace-your-to-do-list-with-interstitial-journaling-to-increase-productivity
Requirements-should-be-verifiable
Resolute-language-for-architectural-models
Resource-accounting
Resource-cleanup
RESTCONF - RFC 8040
Reuse-is-required-for-productivity
Reveal-js-test
Review-of-actors-in-clojure-why-not
RFC 7030 - Enrollment over Secure Transport
RFC 8572 - Secure Zero Touch Provisioning
RFC-executable-specifications-related-ideas
RFC-standard-executable-specification
RFC5652 - Cryptographic Message Syntax
Rich-hickey
Riscv-bootflow
Robust-ipc-with-send-recv-reply
Runtime-extendability
Runtime-reflection-is-important-for-communication
Rushby-partitioning-in-avionics-architectures
Rust-async-await
Rust-async-cancellation
Rust-box-type
Rust-channel
Rust-circular-buffers
Rust-closures
Rust-concurrency-primitives
Rust-dispatch
Rust-error-handling
Rust-event-loop
Rust-executor
Rust-future
Rust-futures-vs-javascript-promises
Rust-is-a-composable-language
Rust-language
Rust-lifetimes-describe-reference-validity
Rust-mutex-is-different
Rust-parameterized-types
Rust-pattern-matching-for-destructring-data
Rust-pinning
Rust-question-mark-operator
Rust-read-trait
Rust-requires-initialized-types-for-correctness
Rust-serde
Rust-single-ownership-for-resource-accounting
Rust-single-threaded-shared-mutability
Rust-struct-as-abstract-type
Rust-task
Rust-trait
Rust-trait-object
Rust-transparent-representation
Rust-unsafe
Rust-waker
Same-language-provides-familiarity-and-interoperability
sbensu
schmidt1994
Scoping-for-named-expression-reuse-and-composition
Sel-bootinfo
seL4-capability-derivation-tree
Sel4-cnode
Sel4-design-for-verification
Sel4-endpoint
Sel4-notification
Sel4-passive-server
Sel4-retype
Sel4-revoke
Sel4-root-task
Sel4-tcb
Sel4-untyped
Selective-message-reception
Semantic-linebreaks
Semantic-versioning-manually-is-error-prone
Sequential-process-model-of-computation
Serialization-approach
Seymour-papert
Shared-memory-is-an-illusion-on-modern-computer-architectures
Shared-state-concurrency
shaw1977-abstraction-and-verification-in-alphard
SICP-1.1-elements-of-programming
SICP-building-abstractions-with-procedures
Simplicity-matters
Simula-67
Simula-class-concatenation
Single-hierarchy-approaches-are-inflexible
Single-source-of-truth
Smalltalk-language
Software-crisis-was-identified-in-1968
Software-development-goals
Software-reuse-only-the-giants-survived
Software-should-be-explainable
Specification-model-should-drive-implementation
Specification-refinement-in-same-language
Specifying-concurrent-program-modules
Speculative-execution
Stack-is-a-bump-allocator
Stack-vs-heap-allocation
State-monad
Static-dispatch
Static-typing
Strachey-fundamental-concepts-in-programming-languages
Structural-type-system
Structure-and-interpretation-of-computer-programs
Structured-concurrency
Structured-control-flow
Structured-message-passing
Structured-programming
Structured-programming-as-specifications
Structures-for-reuse
Subroutines-fortran
Summary-coordinated-and-efficient-huge-page-management-with-ingens
Summary-on-reliable-and-extendable-operating-systems
Supervision-principles-for-programming-fault-tolerant-applications
Sussman
Sussman-the-art-of-the-propagator
Svelte-language
Swig-interface-generator-fail-and-lessons-learned
Synchronization-in-actor-systems
Syntax-transformers
SysMLv1-shortcomings
SysMLv2
SysMLv2-how-does-it-differ-from-programming-language
sysmlv2-with-python-front-end
Systems-development-requires-cross-language-communication
Systems-should-be-queryable
t/title
Tags-alone-dont-scale
Tailwind-CSS-uses-modular-composition
Takeaway-incremental-garbage-collection-of-processes
Takeaway-laws-for-communicating-parallel-processes
Takeaway-synchronization-in-actor-systems
Takeaway-universal-modular-actor-formalism-for-ai
Talk-are-we-there-yet
Talk-growing-a-language
Talk-speculation-keynote
talking-versus-writing-versus-action
Temporal-logic-to-specify-and-verify-cryptographic-protocols
Test-driven-development
Testing-approaches
Tft-learning-systemization
The-cryptographic-doom-principle
The-early-history-of-smalltalk
The-engineer-to-manager-pendulum
The-error-model
The-expression-problem
The-forgotten-facts-problem
The-rust-language-removes-surprises
Thing-model-view-editor
Thoughts-should-be-in-your-own-words
tiddler-sizes
TiddlerTitles-are-concept-handles
Tiddly-wiki-plugins-and-wasm
TiddlyMap!!
Time-of-day
Timeline
Timeouts-and-cancellations-for-humans
Timer-executor-reactor-approaches
TLA-temporal-logic-of-actions
tldraw-based-visualizations
Tock-operating-system
Todos
TOML-doesn't-scale
Tower-service-trait-for-composable-functions
Tracing-approaches-for-system-understanding
Tree-sitter-language-tool
Trusted-platform-module
Type-classes-vs-type-constraints
Type-driven-development
Type-erasure
Type-systems-are-local-contracts
Types-are-propositions
TypeScript-language
Typescript-reflection
Underpowered-description-language
understandable-systems
Understanding-requires-effortful-engagement
Unison-programming-language-is-definition-addressed
Universal-modular-actor-formalism-for-ai
Unix-command-language-single-notion
Unix-domain-sockets
Unix-domain-sockets-as-capability-based-security
Unix-simplicity-over-elaborate-capability
Untapped-power-of-software-visualization
Use-case-for-explainable-software
Useful-tiddler-macros
Validating-safety-and-security-requirements-for-partitioned-architectures
Value-semantics
vance2023heavens-when-the-heavens-went-on-sale
Ventilated-prose-by-fuller
Viewing-control-structures-as-patterns-of-passing-messages
Virtual-machine
Virtual-memory
Virtual-memory-manager
Virtual-memory-processes-and-sharing-in-multics
Visual-programming-has-not-been-successful
Visualization-graph-example
Visualization-references
Visualizations-enable-understanding-non-linear-relationships
Visualizations-for-understanding
Vue-language
wadler1989-how-to-make-ad-hoc-polymorphism-less-ad-hoc
wang2022hertzbleed
Wasm-packs-bindgens-and-rust-notes
We-shape-our-tools-and-then-they-shape-us
web
Web frameworks are dynamic - is it needed
Web signal architecture is verilog model
Web-canvas-compared-to-svg
Web-development-frameworks
Web-development-programming-language-needs
Web-DOM
Web-frameworks-are-like-actor-systems
Web-ontology-language
Web-storage-apis
WebAssembly
WebAssembly-system-interface
What-happened-to-distributed-programming-languages
What-is-a-specification
What-is-a-zettelkasten
When-reading-link-to-concepts
Why-programming-languages-matter
Writing-is-important
X-expressions-provide-meaning-when-writing
XState-visual-model-where-everything-is-an-actor
Xtext-as-model
xx$:/temp/refnotes/library/hewitt1973
xx$:/temp/refnotes/library/hewitt1977
xx$:/temp/refnotes/library/hoare1974
xx$:/temp/refnotes/library/lampson1969
xx$:/temp/refnotes/library/schmidt1994
xx$:/temp/search
Yew-rust-web-stack
Your-what-is-my-how-iteration-and-hierarchy-in-system-design
Zettelkasten-approaches
Zettelkasten-ideas-to-pull-from
Zettelkasten-learn-better-through-active-structure
Zettelkasten-principles
Zettelkasten-youll-be-less-frustrated
Zettelkasten-youll-be-more-productive
Zettelkasten-youll-focus-better
Zettelkasten-youll-think-better
Zettelkasten-youll-waste-less-time
Zettelkastens-advantage-is-in-scaling
Zones-for-isolation-and-sharing