Modeling

Published on
December 10, 2024
Abstracting over people
model modeling mental-models representations knowledge-working ambiguity misconceptions abstractions language language-patterns peopleware people-skills team-building leadership
How to model people?
Published on
November 12, 2024
The ambiguity of objects
model modeling mental-models representations knowledge-working ambiguity misconceptions coding abstractions language language-patterns object-oriented-design messaging functional-design
Are objects essentially bad?
Published on
September 29, 2024
Representing knowledge: what, how and why
model modeling development-process mental-models representations knowledge-working ambiguity misconceptions coding abstractions language language-patterns
What are the different levels of representing knowledge?
Published on
September 11, 2024
The ambiguity of team work
model modeling development-process mental-models representations leadership ambiguity misconceptions knowledge knowledge-working
Heads or hands?
Published on
August 24, 2024
The ambiguity of application
programming paradigms domain-driven-design problem-solving language abstraction modeling business-logic processes model code representations principles
What do we mean by "to apply"?
Published on
May 15, 2024
The law of eventual composition
design-thinking system-thinking modeling domain-driven-design patterns software-architecture software-design interfaces responsibilities responsibility-driven-design coding encoding representation laws heuristics perspectives
What happens when we split things up?
Published on
April 6, 2024
The ambiguity of code
paradigms design-thinking modeling domain-driven-design patterns knowledge-working software-architecture software-design interfaces responsibilities responsibility-driven-design coding encoding representation
How do we understand "the code"?
Published on
March 10, 2024
The ambiguity of interfaces
paradigms design-thinking modeling domain-driven-design patterns knowledge-working software-architecture software-design interfaces responsibilities responsibility-driven-design
How does need-driven thinking shape the way we design?
Published on
January 6, 2024
From concepts to architecture
systems-thinking programming modeling model contexts representations mental-models heuristics principles patterns design-thinking concepts decisions software-architecture architecture collaboration
Does software architecture depend on the ideas?
Published on
December 15, 2023
FSM - Functional State Machines
exploration fsharp fsharp-advent-calendar functional paradigms state-machines modeling declarative-programming
What does make state machines functional?
Published on
December 6, 2023
Common words of the shared apocalypse
fundamentals domain-driven-design software-design simplicity software-architecture software modeling models principles patterns
Are there common words that you can share to scare your teammates?
Published on
November 17, 2023
Easy becomes complex
fundamentals domain-driven-design software-design simplicity software-architecture software modeling models contexts principles patterns
When easy eventually becomes complex?
Published on
November 11, 2023
Simple isn't easy
fundamentals domain-driven-design software-design simplicity software-architecture software modeling models contexts principles patterns
Why simplicity does not require less but more?
Published on
October 24, 2023
The ambiguity of composition
principles fundamentals guidelines programming modeling model contexts representations mental-models heuristics principles patterns design-thinking concepts software-architecture
How can we represent composition?
Published on
September 17, 2023
The ambiguity of software architecture
systems-thinking programming modeling model contexts representations mental-models heuristics principles patterns design-thinking concepts decisions software-architecture architecture collaboration
What do we mean by "software architecture"?
Published on
August 24, 2023
The ambiguity of documentation
object-oriented functional programming modeling model contexts representations mental-models heuristics principles patterns design-thinking concepts
Is a documentation only a manual?
Published on
August 2, 2023
New tools, old rules
architecture object-oriented functional programming modeling model contexts representations mental-models heuristics principles patterns design-thinking contracts service-oriented microservices
Does "old" always remain unattractive?
Published on
July 20, 2023
Concepts, Entities, Data
architecture object-oriented functional programming modeling model contexts representations mental-models heuristics principles patterns design-thinking contracts service-oriented microservices blasphemy database-driven-design table-driven-development
What is the relationship between all three of them?
Published on
July 17, 2023
How do errors evolve?
architecture object-oriented functional programming modeling model contexts representations mental-models heuristics principles patterns design-thinking contracts service-oriented microservices
Compile-time, run-time - what is next in the evolution?
Published on
July 2, 2023
I, interface
oop object-oriented programming roles language modeling model contexts representations mental-models heuristics blasphemy principles patterns design-thinking
Have we misunderstood interfaces?
Published on
May 15, 2023
Concept maps
programming paradigms language modeling model trade-offs representations mental-models domain-driven-design visual-modeling principles patterns design-thinking
Why are we hiding the transformational nature of the problems?
Published on
April 23, 2023
Rethinking "missingness"
programming paradigms language modeling model trade-offs representations mental-models discipline SOLID GRASP principles patterns design-thinking
How can we model absence?
Published on
March 30, 2023
Modularity Uncertainty Heuristic
programming paradigms language modeling model trade-offs metaphors representations mental-models discipline modularity coupling cohesion perspectives architecture design-thinking
Can broken modularity be easily observed and easily fixed at the same time?
Published on
March 12, 2023
"Solution-Probleming"
programming paradigms language modeling problem-solving modeling model trade-offs representations mental-models discipline aspects perspectives architecture design-thinking
What one could learn from a broken coffee grinder?
Published on
March 5, 2023
I don't know
programming paradigms language modeling problem-solving modeling model code representations mental-models discipline aspects perspectives
Is there a benefit of not knowing?
Published on
February 19, 2023
Modeling Maturity Levels
programming paradigms domain-driven-design modeling problem-solving modeling model code representations principles discipline aspects perspectives data-structures behaviors
How we can think of modeling?
Published on
January 26, 2023
The ambiguity of encapsulation
programming paradigms grasp problem-solving solid encapsulation modeling encapsulation model code representations principles discipline
To protect or to hide?
Published on
January 21, 2023
A solid grasp of responsibility
programming paradigms problem-solving language learning model modeling domain-driven-design responsibility-driven-design GRASP SOLID software-design software-engineering metaphors
How to distribute responsibilities?
Published on
January 9, 2023
Slow down
programming paradigms problem-solving language learning model modeling domain-driven-design
How to gain speed by slowing down?
Published on
December 24, 2022
Bool considered harmful?
programming paradigms problem-solving language learning encapsulation value-objects code model modeling type-driven-thinking
Can bool be considered as non-modeling friendly?
Published on
December 15, 2022
Many faces of DDD Aggregates in F#
programming domain-driven-design having-fun language abstraction modeling encapsulation model code representations principles tactical-design ddd fsharp advent-of-code
How could we represent Aggregates, in the tactical DDD sense, using F#?
Published on
December 12, 2022
The ambiguity of abstraction
programming paradigms domain-driven-design problem-solving language abstraction modeling encapsulation model code representations principles
Why are we abstracting?