Simplicity == lack of nuance	simple	anti-simple	comment
Parameter List		anti-simple	SEND() is sufficient
Return Value		anti-simple	SEND() is sufficient
Exceptions		anti-simple	SEND() is sufficient
CALL / RETURN		anti-simple	leaves breadcrumbs on stack aka dynamic call chain Aka hidden state
Conflating control flow with data structuring		anti-simple	OOP does not handle control flow well (in an encapsulated manner)
Composition	simple
Inheritance		anti-simple
Scalability			needs simplicity
Synchronicity built on top of parallelism	simple
Multi-tasking built on top of parallelism	simple
Multi-Tasking built on top of synchronicity		anti-simple
Time Sharing		anti-simple
Scapple	simple
FreeMind		anti-simple	asks what kind of diagram, before jotting down thought(s)
TL;DR			another way of saying not-simple
Complexity			another way of saying not-simple
One-line manual / one-page manual / docs	simple
More than one-page manual		anti-simple
Dependencies		anti-simple
Make		anti-simple	accommodates dependencies
Data Structures		anti-simple
Optimization		anti-simple
Single parameter stack		anti-simple
A Stack for every Type			simpler
A Stack for input			simpler
A Stack for output			simpler
Multiple Return Values		anti-simple	SEND() will do SEND() covers more cases
Hierarchy			simplification
Encapsulation			simplification
RY	simple		Repeat Yourself
DRY		anti-simple	Don't Repeat Yourself Could be handled automatically by Common-expression elimination Good for maintenance, hard for users
Single syntax for writing and reading Code		anti-simple
Global variables		anti-simple
Global Functions		anti-simple
Global Types		anti-simple
Global message passing		anti-simple
Message-passing in hierarchical manner	simple
Scoping variables	simple
FP	simple		but too restrictive
Diagrams	simple
Visual Programming using pixels		anti-simple
Atom	simple
Molecule		anti-simple
Cat	simple
Cat -v		anti-simple
Compile-time vs. Runtime		anti-simple	should be a continuum
Static Type Checking vs. Dynamic Type Checking		anti-simple	should be a continuum
Typeless	simple		for the user
Typeful		anti-simple	for the user
Pragma		anti-simple	symptom of non-simple Design
4-Banger Calculator	simple
Scientific Calculator		anti-simple
Calculator App on Computer		anti-simple
VisiCalc, Excel, et al.	simple
PLs (Programming Languages)		anti-simple
Back door with paddle	simple
Back door with bar		anti-simple	see "Design of Everyday Things" https://www.amazon.ca/Design-Everyday-Things-Revised-Expanded/dp/0465050654
Everything is an Object		anti-simple
Everything is a Relation		anti-simple
Everything is a Type		anti-simple
Splitting Data Design from Control Flow Design	simple
Creating Data Structures at Compile Time		anti-simple	premature optimization Could use processor to create data structures at runtime
One app on one cpu	simple
Design using multiple paradigms			can be simpler esp. With encapsulation
Design using a single paradigm		anti-simple
OO	simple		for data design
OO		anti-simple	for control-flow design
State	simple		with Harel StateCharts
CASE statement on type		anti-simple	use OO for this
CASE statement on Control-Flow		anti-simple	use Harel StateCharts for this
CASE statement for splitting data		anti-simple	use if-then-else for this
CASE statement		anti-simple	(should we get rid of CASE?)
LOOP		anti-simple	doesn’t work well for describing distributed computing
Recursion		anti-simple	doesn’t work well for describing distributed computing
Multi-tasking with Time Sharing		not simple	useful only for operating systems
Multi-tasking without Time Sharing	simple		closures provide the effect of “separate stacks”
Full Preemption		anti-simple	only a few instances where it is needed: Windows / MacOS / Linux / etc.
Modal Dialogs		anti-simple	epicycle induced by synchronous mind-set force-fits asynchronous concepts into synchronous paradigm
Thread Safety		anti-simple	replace with one processor for each App
Priorities		anti-simple	use hardware priorities with caution
Essential Complexity		anti-simple	too often used as an excuse for non-simple design
Denotational Semantics		anti-simple
Peter Lee's treatment of Denotational Semantics	simple		Lee applies Divide and Conquer technique to Make D.S. work in passes aka the opposite of everything-at-once https://www.amazon.ca/Realistic-Compiler-Generation-Peter-Lee/dp/0262121417
UNIX pipes	simple
UNIX pipes in Operating Systems Only		anti-simple	Pipes should be built into every PL
FP function pipes			pipes can do more than just chaining call/return together
Textual representation of pipes		anti-simple	restricts outputs to only what can be expressed as text use diagrams & DaS - Diagrams as Syntax (not pixels)
Silver Bullet			there are many - not one - silver bullets
Solving a Problem	simple
Generalizing a Problem		anti-simple
APIs		anti-simple
Plugging earphones into a phone	simple
LOOP ... EXIT WHEN ...	simple		more than one exit-when clause can be used
LOOP ... FOR ... and all other variants of LOOP		anti-simple
Single inheritance		anti-simple	better than what we had
Multiple inheritance	simple		eschew fitting everything into a single taxonomy Eschew fitting everything into a single paradigm
Hardware IC	simple
Software Library Component		anti-simple	uses only one paradigm: "everything is synchronous"
Structured Programming	simple
Scoping	simple
Flat <anything>	simple		simple for user
Flat <anything>		anti-simple	when scaling is required
Declarative			sometimes simple but not always
Backtracking			sometimes simple but not always
LOAD()	simple
ASDF (Make, etc.)		anti-simple	Band-aid for dependency-driven design
Cache		anti-simple
Spaghetti Architecture		anti-simple
Refactoring		anti-simple	symptom of spaghetti architecture
Embedding Architecture into Code		anti-simple
Code is Architecture		anti-simple
Using existing PLs for Architecture		anti-simple	Computer/Software Architecture needs its own language
PLs with + (& other operators)		anti-simple	PLs should have as few operations as needed by a specific solution
S/SL	simple
YACC		anti-simple
S/SL semantic language	simple		beautifully simple
handles to data	simple		encapsulates data
indirection	simple
Drakon	simple
FBP	simple
CL (Common Lisp)		anti-simple	wonderful assembly language
Human Interface (Raskin)	simple		https://www.amazon.ca/Humane-Interface-Directions-Designing-Interactive/dp/0201379376
Window Scrolling Focus vs Typing Focus		anti-simple	window focus should mean that the window gets next keystroke and/or next mouse-wheel event Found in MacOS and Ubuntu Gnome
Cascading Menus		anti-simple	requires precision
Configurability		anti-simple
Single Syntax for Writing and Reading		anti-simple	e.g. in CL ")" is overloaded - "end if" ... "end let" etc... Writing Code is a different activity than reading Code
Cognitive Load		anti-simple
Knowledge of data structure wired into Code		anti-simple	e.g. knowing that something is a List in CL (except at the lowest levels) Use OO for this
Finding atomic components to a solution			Hard to do, but simplifies Design e.g. atoms for parsing
DRY		anti-simple	reserve for maintenance engineering
Programmer (concept of)		anti-simple	split into separate fields such as: (a) Architect (b) Engineer (c) Production Engineer (d) Maintenance Engineer (e) Test Engineer (create tests & modify design for better testing) (f) Coder (g) Testing & Q/A
semi-colon in syntax		anti-simple
comma in syntax		anti-simple
scoping	simple		same as "hierarchy"
parameters		anti-simple	flat
return value		anti-simple	Flat too restrictive
von Neumann paradigm	simple		but limited
von Neumann paradigm		anti-simple	for concurrency
von Neumann paradigm		anti-simple	for parallel
von Neumann paradigm		anti-simple	for distributed
Everything is von Neumann		anti-simple
computers	simple		but parallel
consciousness	simple		but limited
autonomous nervous system			parallel