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/

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