Software Architecture / Engineering

Notes about the practical side of building software and getting it to
where it needs to be.  This is a counterpart to more technical issues
which are handled in the comsci notes[1].

[1] entry://../compsci/

20200820 Conditions are the better abstraction
20200819 A language that does this automatically?
If time is a parameter, use condition variables
From condtions to events
The condition to event spectrum
Events vs. Conditions
poll events
20200816 Logging
Lazy timer infrastructure
Mixing poll architecture with push events
20200814 Converting a condition machine into an event machine
20200802 functional reactive programming
20200731 Implementing actors
20200729 Pattern matching
20200722 C protocol dispatch
20200718 Rendez-vous over network?
Emulation, events
20200717 Blocking on conditions
20200705 What to do when tired?
Serialize / Deserialize
20200630 Redo as a composition layer
20200629 Getting more annoyed with dynamic typing
20200623 Redo and "gathering patches"
20200622 testability for low-level code
20200423 Create Code Places
20200415 Log union
20200413 Make local, incremental change easy
20200408 environments, dynamic scope
20200402 Name resolution is routing
20200330 paving over
20200328 What if DNS had no root?
20200322 exo: visceral programming
20200314 naming is the central problem
20200309 design is "such that"
20200303 moving from managing files to live state
20200228 why is the work never where you think it is?
aging brain
20200226 Opaque vs. concrete state: can it just be cache?
20200222 Two-level systems
Better logging? A two-level approach.
20200221 redo: restart manager
distributed systems and local memory
20200218 Create "spaces"
strangle instead of rewrite
20200215 one or more?
20200212 Haskell Seq and testing
20200210 Static vs. Dynamic types
20200208 Jim Keller - Lex Fridman
20200204 large teams make things complex
20200201 schedulers
Redo initial dependency generation
20200128 Ron Minnich - On The Metal
Entity Component System in Rust
Jonathan blow - On The Metal
20200127 Abstract code
20200124 Heterogeneous deployment: chain of caches
Make research more predictable
20200121 Cleaning up
20200111 Aging brain
20200108 build as cache
20200102 Configuration management is cache coherence / replication
focus on protocol design
How to make improve software?
Cleanup previous crash
So what went wrong in software evolution?
20191229 Low level "functional" machines don't make sense.
20191227 Machines
Forth as Protocol
20191225 Reverse constructors
Forth protocols
Always use external iteration in C
Why are protocols always so much work?
The case against REST
20191222 How everything is related
Transforming packet processors
20191221 Concurrency
Using a stack as a code sequence
20191219 explicit stacks
20191210 distributed systems
20191209 composite keys vs. nested maps
20191203 Object oriented design..
20191201 Split naming and addressing
Distributed systems: the problem is name resolution
20191130 async/await
20191129 epid
Nested quoting in bash
GOTO and traces
20191128 Library code
20191127 Two kinds of code
20191126 Abstraction discovery
The epid, symmetry is important
20191125 Here's a lesson for the future
20191124 The epid idea
20191123 What's the ideal platform?
The sink naming thing..
Failsafe, distributed
20191121 Fine granularity sinks
20191120 If you abstract all addresses, all that's left is connected sources and sinks
20191117 Why is intuition so often wrong?
20191116 Addressing
20191115 A developer's "business software"
20191114 Objects need to be processes
Two kinds of code
20191113 Breadcrumbs
security and power are always at odds
20191112 Combine events and polling
20191111 late binding doesn't work for large systems
20191110 implementation
20191109 desinging state machine
20191106 How much complexity is enough? And where does it really come from?
20191104 What does a leaf node do?
20191028 services
20191023 There are no names
20191020 debuggability
20191018 distributed systems
State machines
Get rid of the operating system
20191015 think more asynchronous
Correct and simple
avoid using timeouts
20191012 The boundary between messages and subroutines
20191011 Designing
20191009 There is no clean rebuild (there are only incremental build systems)
20190913 Time and space
20190909 stream processing machines
20190905 decentralizing
Incremental development of distributed systems
Delegation is just subroutines
20190904 Why no RTOS?
20190903 zooming in
20190831 caches, partitioning
lazy responses
20190829 event systems
20190827 Are tasks just traces?
20190826 stacks vs. queues
20190824 As A Service
20190819 Embedded
20190818 Tokenizers
simpler uC code
20190817 Back to boring? How to write state machines.
20190816 Protocol oriented programming
20190814 Specifying state machines
20190810 idempotent global state
20190808 symmetric connections, asymmetric setup
20190806 The distributed "commutation" issue : the solution is a common language
20190805 why do things have to be different?
20190731 spaghetti is the natural state
20190730 So why is integration hard?
Debugging distributed systems
20190722 Forth + pattern matching
20190705 Linux code navigation
20190614 ELF
20190610 Metaprogramming for embedded engineers
20190609 estimates
20190531 make things uniform = eliminate accidental complexity
20190530 functional/lazy vs. event-driven/idempotent
20190525 Iterators in C
20190524 why redo is so great
20190523 Haskell for Embedded Software Engineers
20190522 code is a detail
20190521 code review
Abstraction is auto-lifting
20190517 Types are really necessary
20190516 computation vs. communication
20190515 composition
20190511 Late binding is necessary for code reload
The balance
20190510 Distributed systems and "mirroring"
20190509 Editing "dynamic" code
20190505 Asymmetric protocols
Compute vs. memory
20190429 Lock free queue
20190428 Lambda-lifting in C code
20190424 Infrastructure vs. functionality
Lifted closures, restarts, caches
20190423 Idempotency vs. functional reactive
20190422 DSP and Macro languages
FP vs. OO
20190420 Work on the full stack
Why encoding in types can be useful
20190407 Complex trees
20190406 The cost of mental work
Fine granularity and scaffolding context
20190404 About state
Why is math good for modeling design?
20190403 Messy data
Moments of clarity
20190323 Printf debugging
20190320 Phase boundaries
20190317 static vs dynamic
20190316 the blessed tools
20190303 GUIs and corner cases
20190226 What is a task again?
Application vs. library
20190225 glue vs. algorithmic
20190222 redo
20190221 Is a process always just a cache?
20190220 Updates
20190217 frameworks vs. libraries
20190216 State
1-1 continuous deployment
20190215 What is a service?
20190214 redo, push_change,
Big systems
20190213 What is a top_level project?
20190212 implement derivatives directly
20190209 Good tools
20190208 So what with Erlang?
distributed systems
20190207 crossing language barriers
Local reasoning can't solve everything
20190206 Protocols: organizational or technical?
Erlang and Rust
Imperative vs. Functional
20190205 State vs. Cache
20190204 Libraries vs. Frameworks
Live updates
Modularity and Limitation
Functional Objects
20190202 The problem with build systems
Inverting dependencies
Dynamic typing is the default
20190201 Large systems and consistency
To type or not to type
20190131 State
20190122 Inverting the build system
20190120 CSV
20190116 Brooks' silver bullet
20190111 Finding makefile bugs
mutation: only for testing?
20190107 Is source and binary separation just bad?
20190102 discoverability
20190101 notify + batch
20181231 Distributed systems
propagation of changes
20181221 make and variables
How to factor code
20181219 Build, deployment and staging
The show-stopping problem: tools
20181215 Sequential programming is essential
20181213 Distributed system and unidirectional messages (events).
20181208 Abstracting guis.
20181202 Makefile and guard deps
Automatically wrapping a black-box build
20181201 Naming pull and push side
20181129 Proper hierarchical make
20181127 arch and algo hats
trusting the incremental build
20181126 A rebuild should export a dependency list
20181123 Build systems
20181121 backpressure TCP video streaming
20181120 build systems, and what is "push" anyway?
how to design when there are no real specs?
build systems: from push to pull
20181119 redo it simpler?
20181114 Build systems: push and pull
20181113 Design is places
20181110 documentation: 4 types
20181001 MVC / MVP
20180929 models are necessary
20180923 Presentation models
20180919 Composition
Presentation models and the unit machine.
20180915 glue noise floor, implicit properties
Complex code: 1-1 or not?
20180908 Making incremental builds faster
build systems solve social problems not technical ones
20180907 Back to Erlang
20180822 4 hours
20180614 In defence of design patterns
20180526 The problem is composition, not primitives
20180520 Snapshots are nice
20180420 GUIs
20180419 Learning a new architecture
20180418 Closures vs. events
20180414 Need for object-orientation
20180412 Erlang + C
20180410 Code locations are so important
20180407 Normal forms
20180402 The F6 approach -- breadcrumbs
20180325 Live coding: focus on the code buffer that sits between push and pull
20180318 Building large projects
Incremental build and deployment
Build systems
20180317 Build systems
20180315 The difference between low level and high level code
20180311 Am I just whining about types?
20180228 Instead of Shake, use Bazel?
20180223 equational reasoning
20180212 Disappointment
For boring software..
fix routing rules
Too hard to generalize
20180211 Re-use -- we're stuck with this
Setting up Shake
20180209 Sychronization
20180130 Intermediate state
20180124 When you don't see the light
Eliminate compilation
20180121 Trusted code, an exercise
Privilege separation, untrusted code
20180115 Erlang vs. Haskell
20180114 Distributed applications and "IoT"
20180105 embedded.fm 175 (RTOS) and 179 (hierarchical state machines)
20180104 State machines should be the default
if state info can get lost, save it!
20180103 Starting over
20171231 Why are things so arbitrarily incomposible?
20171230 Shake
20171212 Need to go back to imperative programming
20171209 Cached builds
20171205 replace dependency trees by a flat top level builder
20171128 tock, mini os in rust
20171125 Spec functions
Unit tests are about design
20171122 Do not do automatic updates
Eventual consistency / single writer
20171113 Parameterized one-size-fits-all : the weaver antipattern
Lazy Generalization
Why are abstract sinks such a good abstraction?
Assumption: write sink-parameterized code?
Data is decoupled control
In C: buffers are actually just state machines
Compile time pipes
C interface for generic source/sink
Streams of functions : where does the loop go?
"static" OS
20171109 While implementing, make tiny arbitrary choices explicit
20171105 Systems programming needs a real language
Microcontroller Development
20171103 Types
Now, what are the actual problems?
20171028 This is how you write imperative code
20171027 When it's not crystal clear
20171026 Working with sequences? State machines are your friend
20171023 Another reason to use strong types
20171018 Do less
20170912 Modularize through projecting on aspects
20170828 Events and chunks
20170816 One version
20170727 I no longer think binary logs are a good idea
20170724 How to manage a software project
Server or Procedure?
Which language to use?
20170720 Run .NET languages on linux?
20170719 Many small functions hurt readability
20170714 Caches
embracing events and distributed caches
20170707 privileged-ports-are-causing-climate-change
20170618 Flux, tree-diff
20170608 Orient vs. tree-diff
Gui: two approaches
20170607 View splitting
20170606 GUI: Event propagation graphs
20170605 User interfaces
20170510 Question-oriented programming
20170506 State and restarts, compilation caches
20170421 Register configuration language
20170411 Writing embedded software
NASA coding
20170409 Shell programming
20170404 The Debugging Mindset
20170325 When to use OO?
20170305 Exponential sensitivity
20170222 Structure is what is important
20170220 Distributed computing
20170217 Centralize code
20170216 The kind of unknown
20170213 Implementing protocols
20170209 Conflicts
20170204 Eliminate accidental complexity
20170117 Kinds of errors
20170116 Creating context
20170103 video tearing, the poster child of bad abstractions
20161230 programmer psychology
20161229 subdivide
20161228 what is a good protocol?
20161223 genius consultant
20161209 The real problem with software engineering
20161207 protocols
20161127 Engineering problems
20160905 Accidental Complexity - Fine Grained Redundancy
20160515 unikernels
20160316 Why are code examples so important?
20160309 Feature change, a 3-step process
20160223 Static Erlang
20160213 Joe Armstrong on OSC and music
20151006 It's called hardware because it makes everything hard
20151003 Stack ripping
20150923 Debugging - thinking
20131216 A Great Old-Timey Game-Programming Hack
20130128 Clean it up when it becomes a library
20111231 Branching in Darcs / Git
20111220 Testing a stateful monster
20111217 State machines are hard
20111128 Darcs Emacs
20111125 Robustness
Writing stateful code
20111024 On doing things differently
20110509 Abstraction isn't always the solution
20110424 Robustness : external mutators
Robust filesystem
20100321 What did I learn this time?
20100301 Architecture document
Coding The Architecture