Tech

Notes

major version event changes should publish both events for a period of time
Marten
command line
reset mock counts with Moq
Moq
BSD sed vs GNU sed
testcontainers
C Sharp
asynchronous setup in XUnit
vim
viewing DataGrip passwords
message listeners should store the ids of events they've processed
organizational culture
using IHostedService for a cron job
SIGTERM not reaching Docker processes
software delivery performance metrics
Domain Driven Design Modeling Process - From Problem to Solution Space
Kafka
pathological culture
OpenShift
CSharp classes should be sealed by default
event storming
bitwise enums in CSharp
visual block mode
four controller paths
tutorial documentation quadrant
Spotify Model
WiFi hacking
development lead time can be highly variable
Two Pizza Rule
lazy loading makes you lazy
viewing changes in a context
null forgiving operator
rework
YAGNI
removing large files in git
rules engine tradeoffs
visidata
instrinsic cognitive load
SWOT analysis
germane cognitive load
cron
static ip in debian
domain service
delivery lead time should be highly predictable
vim register
json api
ubiquitous language is the key to domain driven design
ubiquitous language should be used in code
user command flow
value object
generic domain
three types of domains
policy
you do not need event sourcing to do Domain Driven Design
generic domains are typically third parties
supporting domains can be third parties
invariant
message flow diagramming
supporting domain
hidden core domain
unplanned work
Mermaid diagrams
you can safely ignore TaskCancelledException
plans should be meaningful to other people
null conditional operator
take time to plan your code
SharpLab
technology is not value neutral
viewing CIL of a .net file
how-to guide documentation quadrant
tech debt as clutter
template method design pattern
scenario mapping
unplanned work is added directly to the progress section
bureaucratic culture
if it's been in production for six weeks it's now a feature, not a bug
rules engine
testing microservices
component tests
Change tracking in EF Core
microservice testing pyramid
Use lazy loading for EF core
digital dark age
start with your entities and work out from there
cognitive load
Pioneers, Settlers and Town Planners
team topology
Accelerate - The Science of Lean Software and DevOps
markdown to do
development lead time
lead time
design level event storming
design level event storming notation
commands are not the same as events
Guids cannot be marked Required in .Net Core MVC
cursor pagination
csproj to mermaid visualizer
delivery lead time
filtering and sorting a child entity in EF Core
first-to-market core domain
context classifications can change
suspect supporting domain
fluent validation
types of complexity
sed
using sed to change text in files
data mesh
Wardley's business activity lifecycle
dotnet application structure
platform team
stream aligned team
extraneous cognitive load
Wardley Maps
enabling team
concurrency conflict
command listener
Conway's Law
characterwise
blockwise visual
all models are wrong but some are useful
api controller
authentication
"modern" as a joke
aggregates enforce domain invariants
reusable consumer
types of organizational cultures
ubiquitous language
aggregates are referenced via an aggregate root
domain event
aggregate design canvas
context classification
domain roles
heuristics for defining bounded contexts
aggregate root
entity
event sourcing
command to event flow
ubiquitous language facilitates event storming
bounded context canvas
domain events enable event sourcing
three pillars of domain driven design
Domain Driven Design project structure
domain driven Design is language agnostic
domain driven design definition
aggregate lifetime
unplanned work is the result of not building quality into the product
Domain Driven Design starter modelling process
Domain Driven Design
ubiquitous language is contextual
domain driven design patterns
domain driven design modeling process
avoid anemic domain models
benefits of domain driven design
aggregate
arbitrary boundaries result in coupling
bounded context
domain interaction with other services should be through interfaces
bus factor
Alfred (Mac app)
events should be named in the past tense
big bet core domain
aggregates are consistency boundaries
platform
authorization is a series of questions
C Sharp nullable operators
Gang of Four
cancellation token
complicated subsystem team
refer to C Sharp, not .net
elixir
authorization
snack (prioritization)
NewRelic distributed tracing
be aware of single vs split queries
dotnet
architecture decision record
authentication is a series of statements
authention and authorization in .net
be able to tell when something is working and when it's not working
impostor syndrome
end to end tests
antifragility
facade pattern
NetSuite
unix signal
EntityFramework change tracker
fd
unit test
minimum viable product
SIGTERM
four golden signals
switchaudio-osx
performance review
verify logs with Moq
Adding an http client to a .net project
PPP
generating C sharp files from json schema
NewRelic golden signals monitoring
motion smoothing in tvs
macOS menu bar
orchestrator pattern
failure demand
ETL
composite ui
Design Patterns
ELK
event dispatcher
viewing used storage in PostgreSQL
integration test
pull request
Apex
drools
motion smoothing
staff engineer archetype
microservice
Common Intermediate Language
explanation documentation quadrant
alerts should be relevant
staff engineer
contract test
factory
enabling debug logs for kafka
is paying down tech debt always worthwhile?
CQRS
before you can measure success you have to define 'good'
broker topic
SOQL
event listener
documentation quadrants
C Sharp lowering
fzf
don't pass CancellationTokens to Task.Run
repository
reference documentation quadrant
linewise
learning culture
only write contract tests for what you need