Domain Analysis of Decisions

[markusvoelter]

Build a feature model of the domain of decisions and design a DSL around it. A starting point are the following points mentioned by @chriseth

• What happens if the set of participants changes while the votes are still being cast (not the case in the example, but usually, the set is flexible)?
• Is there a possibility for "replay attacks", i.e. is it always clear to the person what exactly is voted on, or might a vote be re-used?
• Can a voted upon decision be used as a condition in any part of the code? If yes, does it have to be triggered by someone? Does it reset the vote?

[markusvoelter]

Some considerations:

• Set of parties
  • fixed
  • dynamic
  • limited
  • can join after "seal"
• Start of Decision Process
  • immediately
  • after "seal"
• Revocation
  • Decision can be revoked
  • Decision is fixed, once taken
• Procedure
  • Majority
  • Unanimous
• Number of Options
  • Simple flag (yes/no)
  • One of Many
• Time limit
  • Votes must happen within X time
  • No time limit
• Abstention handling
  • is abstention in favor or against?
  • minimum participation

[bj2015]

Some additional points:

• Result Publication

  • Immediately - Result can be queried directly after each vote
  • After Closure - Result can only be queried after closure (when all votes have been cast or the time limit is reached)

• "can join after 'seal'" should probably be "can join until 'seal'"

• "Number of Options", "Procedure" and "Abstention Handling" can be generalized as follows:

• DataType

  • yes/no => boolean
  • One of Many => Enum
  • all kinds of other data types are comprehensible: integer, float, interval, set (f.i. subset of a given set), list, string, ...

• Consensus

  • a function mapping a set of elements of Type DataType to the single element of Type DataType, which is the result of the decision

Examples: consensus(set<bool> votes): bool = votes.count(true) >= votes.count(false)

consensus(set<Enum> votes): Enum = votes.select{|it| (it, votes.count(it)) }.max{ |it| it.second }.first

consensus(set<integer> votes): integer = votes.sum() / votes.size() # works also for float

# everybody has 2 votes and every element with more that 25% is in
consensus(set<set<string>> votes): set<string> = let valid = votes.where{ |it| it.size() == 2 }, all = valid.inject(union) in 
    all.where{ |e| valid.count{ |it| e in it } >= (valid.size() / 4) }