公開日: 2017-09-29 変更日: 2017-09-29 Download PDF

autoscale: true

The Concept of Almin

fit Almin.js


Almin is a State management library for JavaScript

fit Almin.js


Almin features

  • Scalable
    • Medium-small(1,000LOC) – Large(100,000LOC)
  • Testable
    • Implement UseCase/Store/Domain as component
  • Debuggable
    • Logger/DevTools/Performance monitoring
  • Layered Architecture
    • DDD/CQRS

Different team structures imply different architectural decisions. -- Clean Architecture Robert C. Martin


The Concept of Almin

  • Write Your domain in Your code
  • Split up Read stack and Write stack
  • Unidirectional data flow
  • Prefer Readable code to Writable code
  • Monitor everything

Write Your domain in Your code

  • You can control domain layer
    • You can write your domain with Pure JavaScript
    • Your domain is not need to subclass of Almin things
  • Almin support application layer
    • Application layer use your domain model
  • If you stop to use almin, you don't need to rewrite your domain

Example: UseCase

Almin provice UseCase class that is a part of application layer

import { UseCase } from "almin";
import yourDomain from "./your-domain";
export ApplicationUseCase extends UseCase {
    execute(){
        // Application Layer use your domain
        yourDomain.doSomething();
    }
}

Split up Read stack and Write stack

  • In Flux/Redux
    • Store has Application logic/state(M) and View state(N)
    • The Complexity: N × M (multiplication)
  • In Almin
    • Domain has Application logic/state(M) – Write state
    • Store has View state(N) - Read state
    • The Complexity: N + M (addition)

Related topic: Command Query Responsibility Segregation(CQRS)


Example: Repository

  • Almin help to support Repository pattern
    • You can save your domain(application state) into the repository
  • Store read application state from the repository
  • Store convert the application state to view state

Realted topic: Model View ViewModel(MVVM), ViewModel


Unidirectional data flow

View -> UseCase -> Store ... -> View -> UseCase -> Store

  • UseCase only report success or failure that is Promise
  • UseCase can write to Store, But can not read from Store
  • Store does't know any UseCase
  • View can not write state to Store directly
  • View can execute any UseCase
  • View can observe the change of Store

Related topic: Flux


fit, Almin Architecture


Prefer Readable code to Writable code

  • Almin prefer Explicit/Readable code to Implicit/Writable code
  • Almin support TypeScript language and Almin is type-safe
  • Pros
    • No magic code
    • Just write and Just work
  • Cons
    • Redundancy

Monitor everything

  • You can observe life-cycle events of almin
  • logging events that are changing of state etc..
  • Integrate almin into DevTools
  • Profiling performance of almin with other library
  • Illustrate your UseCase diagram

inline fill, performance inline, fill, DevTools


Almin.js Icon Conclusion

  • :package: Repo: almin/almin
  • :memo: Document: https://almin.js.org
  • :scroll: Examples: almin/examples
  • :link: Work with React, Vue etc...

fit Almin.js


[fit] Almin is for thinking code