home.social

#processmodeling — Public Fediverse posts

Live and recent posts from across the Fediverse tagged #processmodeling, aggregated by home.social.

  1. Post-OOP Imperative Functional Java.
    Model the process. Not the domain.

    Most Java code still asks the wrong question:
    "What is this domain object?"
    But production systems fail, scale, and burn because of processes, not nouns.

    If your system is a sequence of irreversible steps, model it as a sequence,
    not as interacting objects pretending to be immortal.

    This follows ideas from Railway-Oriented Programming (ROP):
    errors and decisions are values, not control-flow side effects.

    Modeling the process means you can read this top to bottom
    and understand exactly what happens.
    No debugger. No IDE magic. No tribal knowledge.

    Control flow is explicit.
    You see the execution order.
    Nothing hides in constructors, annotations, or overrides.

    Failure is a first-class concept.
    Once it fails or decides early, nothing else runs.
    No exception archaeology.

    Processes > Objects.
    Real systems are workflows where refactoring is safe.

    Steps are reordered, removed, or replaced
    without collapsing a class hierarchy.
    Testing is trivial, small stepwise context — even for an AI.

    Feed input. Assert final result.
    No mocking five layers of indirection.

    GraalVM / native-friendly.
    No reflection rituals.
    The compiler smiles.

    Objects are great for long-lived entities.
    User actions, payments, rules, and failures are short-lived processes.

    I model what happens,
    not what pretends to exist forever.

    Influenced by:
    Railway-Oriented Programming,
    Functional Core / Imperative Shell,
    Workflow / Saga patterns,
    Command pipelines,
    Unix philosophy,
    and value-oriented libraries like Vanilla-DI.

    Don't be stuck in axioms.

    #PostOOP
    #ImperativeFunctional
    #ProcessOverObjects
    #ModelTheProcess
    #WorkflowFirst
    #RailwayOrientedProgramming
    #FunctionalCore
    #ImperativeShell
    #CommandPipeline
    #ExplicitControlFlow
    #ValueOrientedDesign
    #ProcessModeling
    #FailFast
    #NoExceptionArchaeology
    #ComposableSystems
    #NativeFriendly
    #GraalVM
    #NoReflection
    #DeterministicCode
    #RefactorSafe
    #SagaPattern
    #UnixPhilosophy
    #VanillaDI
    #ModernJava
    #ArchitectureMatters

  2. Post-OOP Imperative Functional Java.
    Model the process. Not the domain.

    Most Java code still asks the wrong question:
    "What is this domain object?"
    But production systems fail, scale, and burn because of processes, not nouns.

    If your system is a sequence of irreversible steps, model it as a sequence,
    not as interacting objects pretending to be immortal.

    This follows ideas from Railway-Oriented Programming (ROP):
    errors and decisions are values, not control-flow side effects.

    Modeling the process means you can read this top to bottom
    and understand exactly what happens.
    No debugger. No IDE magic. No tribal knowledge.

    Control flow is explicit.
    You see the execution order.
    Nothing hides in constructors, annotations, or overrides.

    Failure is a first-class concept.
    Once it fails or decides early, nothing else runs.
    No exception archaeology.

    Processes > Objects.
    Real systems are workflows where refactoring is safe.

    Steps are reordered, removed, or replaced
    without collapsing a class hierarchy.
    Testing is trivial, small stepwise context — even for an AI.

    Feed input. Assert final result.
    No mocking five layers of indirection.

    GraalVM / native-friendly.
    No reflection rituals.
    The compiler smiles.

    Objects are great for long-lived entities.
    User actions, payments, rules, and failures are short-lived processes.

    I model what happens,
    not what pretends to exist forever.

    Influenced by:
    Railway-Oriented Programming,
    Functional Core / Imperative Shell,
    Workflow / Saga patterns,
    Command pipelines,
    Unix philosophy,
    and value-oriented libraries like Vanilla-DI.

    Don't be stuck in axioms.

    #PostOOP
    #ImperativeFunctional
    #ProcessOverObjects
    #ModelTheProcess
    #WorkflowFirst
    #RailwayOrientedProgramming
    #FunctionalCore
    #ImperativeShell
    #CommandPipeline
    #ExplicitControlFlow
    #ValueOrientedDesign
    #ProcessModeling
    #FailFast
    #NoExceptionArchaeology
    #ComposableSystems
    #NativeFriendly
    #GraalVM
    #NoReflection
    #DeterministicCode
    #RefactorSafe
    #SagaPattern
    #UnixPhilosophy
    #VanillaDI
    #ModernJava
    #ArchitectureMatters

  3. Post-OOP Imperative Functional Java.
    Model the process. Not the domain.

    Most Java code still asks the wrong question:
    "What is this domain object?"
    But production systems fail, scale, and burn because of processes, not nouns.

    If your system is a sequence of irreversible steps, model it as a sequence,
    not as interacting objects pretending to be immortal.

    This follows ideas from Railway-Oriented Programming (ROP):
    errors and decisions are values, not control-flow side effects.

    Modeling the process means you can read this top to bottom
    and understand exactly what happens.
    No debugger. No IDE magic. No tribal knowledge.

    Control flow is explicit.
    You see the execution order.
    Nothing hides in constructors, annotations, or overrides.

    Failure is a first-class concept.
    Once it fails or decides early, nothing else runs.
    No exception archaeology.

    Processes > Objects.
    Real systems are workflows where refactoring is safe.

    Steps are reordered, removed, or replaced
    without collapsing a class hierarchy.
    Testing is trivial, small stepwise context — even for an AI.

    Feed input. Assert final result.
    No mocking five layers of indirection.

    GraalVM / native-friendly.
    No reflection rituals.
    The compiler smiles.

    Objects are great for long-lived entities.
    User actions, payments, rules, and failures are short-lived processes.

    I model what happens,
    not what pretends to exist forever.

    Influenced by:
    Railway-Oriented Programming,
    Functional Core / Imperative Shell,
    Workflow / Saga patterns,
    Command pipelines,
    Unix philosophy,
    and value-oriented libraries like Vanilla-DI.

    Don't be stuck in axioms.

























  4. Post-OOP Imperative Functional Java.
    Model the process. Not the domain.

    Most Java code still asks the wrong question:
    "What is this domain object?"
    But production systems fail, scale, and burn because of processes, not nouns.

    If your system is a sequence of irreversible steps, model it as a sequence,
    not as interacting objects pretending to be immortal.

    This follows ideas from Railway-Oriented Programming (ROP):
    errors and decisions are values, not control-flow side effects.

    Modeling the process means you can read this top to bottom
    and understand exactly what happens.
    No debugger. No IDE magic. No tribal knowledge.

    Control flow is explicit.
    You see the execution order.
    Nothing hides in constructors, annotations, or overrides.

    Failure is a first-class concept.
    Once it fails or decides early, nothing else runs.
    No exception archaeology.

    Processes > Objects.
    Real systems are workflows where refactoring is safe.

    Steps are reordered, removed, or replaced
    without collapsing a class hierarchy.
    Testing is trivial, small stepwise context — even for an AI.

    Feed input. Assert final result.
    No mocking five layers of indirection.

    GraalVM / native-friendly.
    No reflection rituals.
    The compiler smiles.

    Objects are great for long-lived entities.
    User actions, payments, rules, and failures are short-lived processes.

    I model what happens,
    not what pretends to exist forever.

    Influenced by:
    Railway-Oriented Programming,
    Functional Core / Imperative Shell,
    Workflow / Saga patterns,
    Command pipelines,
    Unix philosophy,
    and value-oriented libraries like Vanilla-DI.

    Don't be stuck in axioms.

    #PostOOP
    #ImperativeFunctional
    #ProcessOverObjects
    #ModelTheProcess
    #WorkflowFirst
    #RailwayOrientedProgramming
    #FunctionalCore
    #ImperativeShell
    #CommandPipeline
    #ExplicitControlFlow
    #ValueOrientedDesign
    #ProcessModeling
    #FailFast
    #NoExceptionArchaeology
    #ComposableSystems
    #NativeFriendly
    #GraalVM
    #NoReflection
    #DeterministicCode
    #RefactorSafe
    #SagaPattern
    #UnixPhilosophy
    #VanillaDI
    #ModernJava
    #ArchitectureMatters

  5. Post-OOP Imperative Functional Java.
    Model the process. Not the domain.

    Most Java code still asks the wrong question:
    "What is this domain object?"
    But production systems fail, scale, and burn because of processes, not nouns.

    If your system is a sequence of irreversible steps, model it as a sequence,
    not as interacting objects pretending to be immortal.

    This follows ideas from Railway-Oriented Programming (ROP):
    errors and decisions are values, not control-flow side effects.

    Modeling the process means you can read this top to bottom
    and understand exactly what happens.
    No debugger. No IDE magic. No tribal knowledge.

    Control flow is explicit.
    You see the execution order.
    Nothing hides in constructors, annotations, or overrides.

    Failure is a first-class concept.
    Once it fails or decides early, nothing else runs.
    No exception archaeology.

    Processes > Objects.
    Real systems are workflows where refactoring is safe.

    Steps are reordered, removed, or replaced
    without collapsing a class hierarchy.
    Testing is trivial, small stepwise context — even for an AI.

    Feed input. Assert final result.
    No mocking five layers of indirection.

    GraalVM / native-friendly.
    No reflection rituals.
    The compiler smiles.

    Objects are great for long-lived entities.
    User actions, payments, rules, and failures are short-lived processes.

    I model what happens,
    not what pretends to exist forever.

    Influenced by:
    Railway-Oriented Programming,
    Functional Core / Imperative Shell,
    Workflow / Saga patterns,
    Command pipelines,
    Unix philosophy,
    and value-oriented libraries like Vanilla-DI.

    Don't be stuck in axioms.

    #PostOOP
    #ImperativeFunctional
    #ProcessOverObjects
    #ModelTheProcess
    #WorkflowFirst
    #RailwayOrientedProgramming
    #FunctionalCore
    #ImperativeShell
    #CommandPipeline
    #ExplicitControlFlow
    #ValueOrientedDesign
    #ProcessModeling
    #FailFast
    #NoExceptionArchaeology
    #ComposableSystems
    #NativeFriendly
    #GraalVM
    #NoReflection
    #DeterministicCode
    #RefactorSafe
    #SagaPattern
    #UnixPhilosophy
    #VanillaDI
    #ModernJava
    #ArchitectureMatters

  6. In our latest video, Celia explains what BPMN Call Activities are and how they can be used in Flows for APEX 22.2+. youtube.com/watch?v=yG8uTJb_FA flowsforapex.org #flowsforapex #orclapex #bpmn #processmodeling

  7. In our latest video, Celia explains what BPMN Call Activities are and how they can be used in Flows for APEX 22.2+. youtube.com/watch?v=yG8uTJb_FA flowsforapex.org #flowsforapex #orclapex #bpmn #processmodeling

  8. In our latest video, Celia explains what BPMN Call Activities are and how they can be used in Flows for APEX 22.2+. youtube.com/watch?v=yG8uTJb_FA flowsforapex.org #flowsforapex #orclapex #bpmn #processmodeling

  9. In our latest video, Celia explains what BPMN Call Activities are and how they can be used in Flows for APEX 22.2+. youtube.com/watch?v=yG8uTJb_FA flowsforapex.org #flowsforapex #orclapex #bpmn #processmodeling

  10. 🗓 Mark your calendars! Camunda Platform 8.2 arrives on April 11, 2023, and we can't wait to show how the newest features create a better experience across the process development lifecycle. Save your seat to join us on April 18: bit.ly/3mfVd1z

    #processorchestration #processmodeling