GUI Architectural Patterns ?

• MVC
• MVP
• MVVM
• MVI

Their Purpose:

• Model interaction between a human and a computer
• Do it in an effective way

What do we use already

• Functional Programming
• Event Streams/Reactive streams
• Push Notifications
• HTTP SSE text/event-stream
• WebSocket, Firebase, Deepstream
• Kafka, Spark, RabbitMQ
• Actor Model, Akka, Vertx

Broadcast/Fire and Forget

• Notify "post viewed"
• Notify "http request failed"
• Request to send email confirmation


• Push Notifications
• UI events Notifications

State Transfer

• Live Data
• BehaviorSubject (RxBus)
• Room, SQLBrite
• Firebase

Request Data

• Query via event (event bus) and receive response

• Aggregate - autonomous cluster of associated objects
• Aggregate Root - the entry point to access the aggregate
• Value Object - immutable, identity-free data
• Entity - An object defined by its identity
• Bounded Context - isolated part of a larger system with its own Domain Model
• SAGA - coordinates long running process (process manager)

How to delete and edit events?

• retroactove events - reject or correct previous events
• Rewrite Event Log

What if there are 1 billion events to replay?

• Snapshots
• Rewrite event log
• Better design aggregates

Event types and versioning?

• Rewrite Event Log
• design and document good event taxonomy
• ex: "https://myapp.io/tax/incrementQty"

• Commands can be rejected or accepted
• Command validation
• Domain validation
• Validation across multiple domains/aggregates
• Use Query module
• Use Process Managers
• distribute validation workload across shards

• Complex Domains
• Distributed Systems
• Task Based Applications

     override fun completeTask(task: Task) {
        checkNotNull(task)
        mTasksRemoteDataSource.completeTask(task)
        mTasksLocalDataSource.completeTask(task)

        val completedTask = Task(task.title, task.description, task.id, true)

        // Do in memory cache update to keep the app UI up to date
        if (mCachedTasks == null) {
            mCachedTasks = LinkedHashMap()
        }
        mCachedTasks!!.put(task.id, completedTask)
    }
            

    override fun getTasks(): Flowable<List<Task>> {
        // Respond immediately with cache if available and not dirty
        if (mCachedTasks != null && !mCacheIsDirty) {
            return Flowable.fromIterable(mCachedTasks!!.values).toList().toFlowable()
        } else if (mCachedTasks == null) {
            mCachedTasks = LinkedHashMap()
        }

        val remoteTasks = andSaveRemoteTasks

        if (mCacheIsDirty) {
            return remoteTasks
        } else {
            // Query the local storage if available. If not, query the network.
            val localTasks = andCacheLocalTasks
            return Flowable.concat(localTasks, remoteTasks)
                    .filter { tasks -> !tasks.isEmpty() }
                    .firstOrError()
                    .toFlowable()
        }
    }
            

            class TaskDetailPresenter(...
             ...
                fun deleteTask()
                //deleteTask / taskDeleted
                fun activateTask()
                //activateTask / taskActivated
                fun completeTask()
                //completeTask / taskCompleted
            
            

            class AddEditTaskPresenter
             ...
                fun saveTask(title: String, description: String)
                //updateTitle / titleUpdated
                //updateContent / contentUpdated
            
            

              class TasksPresenter(...
              ...
                    fun addNewTask()
                    //createTask / taskCreated
            
            

class TasksAR {
    fun createTask() {}
    fun updateTitle(taskID:Int, title: String) {}
    fun updateContent(taskID:Int, content: String) {}
    fun activateTask(taskID:Int) {}
    fun completeTask(taskID:Int) {}
    fun deleteTask(taskID:Int) {}
}
            
            

@Entity(tableName = "events")
data class Event(
        @ColumnInfo(name = "subjectID")
        var subjectID: String?,
        @ColumnInfo(name = "userID")
        var userID: String?,
        @ColumnInfo(name = "datetime")
        var datetime: Long,
        @ColumnInfo(name = "eventHash")
        var eventHash: String,
        @ColumnInfo(name = "eventID")
        var eventID: String,
        @ColumnInfo(name = "eventData")
        var eventData: Any?
)
                

@Dao interface EventsPublisher {
    @Insert
    fun publishEvent(task: Event)

}
                

class TasksAR
@Inject constructor(val eventsPublisher:EventsPublisher) {
    fun createTask() {
        eventsPublisher.publishEvent(Event("createTask"))
    }
    fun updateTitle(taskID:Int, title:String) {
        doValidate("updateTitle", taskID, title)
        eventsPublisher.publishEvent(Event("updateTitle", taskID, title))
    }
    fun updateContent(taskID:Int, content:String) {
        doValidate("createTask", taskID, content)
        eventsPublisher.publishEvent(Event("createTask", taskID, content))
    }
    fun activateTask(taskID:Int) {
        doValidate("createTask", taskID)
        eventsPublisher.publishEvent(Event("createTask", taskID))
    }
    fun comcompleteTask(taskID:Int) {
        doValidate("createTask", taskID)
        eventsPublisher.publishEvent(Event("createTask", taskID))
    }
    fun deleteTask(taskID:Int) {
        doValidate("createTask", taskID)
        eventsPublisher.publishEvent(Event("createTask", taskID))
    }
}
                

• Easy and Serverless
• Reactive - can subscribe to events
• Can easily hook up to Cloud Functions

  viewHolder.bindToPost(model, new View.OnClickListener() {
                    @Override
                    public void onClick(View starView) {
                        // Need to write to both places the post is stored
                        DatabaseReference globalPostRef = mDatabase.child("posts").child(postRef.getKey());
                        DatabaseReference userPostRef = mDatabase.child("user-posts").child(model.uid).child(postRef.getKey());
                        // Run two transactions
                        onStarClicked(globalPostRef);
                        onStarClicked(userPostRef);
                    }
                });
            
            

FirebaseDatabase.getInstance().getReference().child("events")
    .addChildEventListener(new ChildEventListener()
    {
        fun onChildAdded(dataSnapshot: DataSnapshot, s: String) {
            postCommand(Command(dataSnapshot))
        }
    }
                

  functions.database.ref('/events/{eventID}')
    .onWrite(event => {
      const newVal = process(event.data);
      makeHttpCall(newVal);
      return readModel.ref.child(event.params.subjectId).set(newVal);
    });
            

           // TODO: Many more options and scenarios to consider.