A RatioWar is a HolyWar, or at least a controversial opinion, that the ratio between two items should be high or low, or greater or lessor than it is usually done in practice. Some point to technical considerations, e.g. regarding optimizations and analysis available in tools today, granularity for meta-data, and reuse. Some suggest that it's primarily a matter of personal preference: the position that WetWare is the primary driver of the best balance choice.

Topics related to RatioWar''''''s include:

* Function/Method size - lines/units of code per function and/or methods per class
** FearOfAddingClasses
** LongFunctions
** ShortMethods or FewShortMethodsPerClass or ManyShortMethodsPerClass or LotsOfShortMethods
** [under construction]

* Thin Vs. Wide Tables - columns per table (sometimes known as normalization degree)
** FearOfAddingTables
** [under construction]
** [under construction]

* Code-line Size - tokens per statement
** [under construction]

* Duplication
** OnceAndOnlyOnce
** DuplicationRefactoringThreshold

* Variable Name Size - characters or syllables per variable name 
** VowelGeneration

* Language - how 'big' should a language be? (features per language)
** LanguageIdiomClutter
** MissingFeatureSmell
** KeyLanguageFeature
** ExpressionProblem
** EconomyOfExpression

* General - policies and issues driving various RatioWar''''''s
** OneResponsibilityRule pushes for smaller functions, classes, tables. 
** CrossCuttingConcern''''''s often lead to ExtremelyInterstrangled BigBallOfMud
** SeparationOfConcerns
** NonFunctionalRequirements
** ChangePattern

An interesting question is whether there are commonalities in the arguments for or against these different items. 

Another interesting question is whether pairs of policies lead towards a 'natural' (fixpoint) balance between large and small, yin to the other's yang. Example: DoTheSimplestThingThatCouldPossiblyWork (brute-force addition of features you need) and RefactorMercilessly (splits out shared elements, makes components smaller) and YouAintGonnaNeedIt (don't support features that aren't in demand) are a trio of SoftwareEngineering policies that achieve a natural balance in the 'size' for functions, classes, methods, etc. And MissingFeatureSmell and LanguageIdiomClutter balance one another as well.
-----
See also: IncompatibleGoals
-----
CategoryConflictResolution, CategoryArchitecture