Channels
administrivia
announcements
bot-dark-forest
devlog-together
in-alberta
in-boston
in-germany
in-israel
in-london
in-nyc
in-ontario
in-seattle
in-sf
in-socal
introduce-yourself
linking-together
of-end-user-programming
of-functional-programming
of-graphics
of-logic-programming
of-music
present-company
random-encounters
reading-together
share-your-work
thinking-together
two-minute-week
wormholes
Title
s
Stefan
01/31/2019, 1:18 PMAre there any techniques or metrics to define or measure how specific or generic something is? That something could be a function or class in a programming language, an algorithm, or even something less formally defined, like a component in a UI framework.
I'm familiar with some measures of complexity, like counting dependencies or cyclomatic complexity, which seems somewhat related.
Appreciate any pointers to papers or articles about this, even if they "just" define how something is more or less specific or generic than something else to support a hypothesis that is totally unrelated.
š° 1
d
duncanawoods
01/31/2019, 1:35 PMI'm not sure what "how specific or general" would actually mean for a class. If you get a really precise definition then you have probably defined how to measure it too!
It reminds me a bit of https://en.wikipedia.org/wiki/Chomsky_hierarchy - the main technique for e.g. proving something is turing powerful, is to show an isomorophism to a known system with proven properties.
š 1
s
stevekrouse
01/31/2019, 2:07 PMIn BV's ladder of abstraction, the number of parameters in functional abstraction is the measure of abstraction
d
duncanawoods
01/31/2019, 2:39 PMInteresting. The types involved feel like a huge factor for measuring generalisation/specialisation e.g.
add(a : ushort, b : ushortadd(a : int, b : int)add(a : double, b : double)add(a : any, b : any)add<T>(a : T, b : T)add<T>(... list : T)I am reading "An Introduction to General Systems Thinking" right now and it is discussing how to measure the relative generality of scientific laws.
Weinberg claims that that laws should properly be defined as conditional "if... so...". He says that the fewer "if... so..." clauses, the more general the law.
Applying this to code, instead of looking inside the code for it's generality, look outside at the context in which it can be used i.e. how many caveats are there about when it can or cannot be used?
š 1
s
stevekrouse
01/31/2019, 5:42 PMVariables are also know as "degrees of freedom"
ā” 1
š 1
d
duncanawoods
01/31/2019, 5:49 PMNumber of variables/parameters doesn't seem like a good measure when we can just encode any number of variables into a goedel number.
š 1
s
stevekrouse
01/31/2019, 5:57 PMGood point
I feel like you're onto something with the types thread...
(Can't we measure the length of the godel number?)
t
Tim Swast
01/31/2019, 6:08 PMThe first thing that comes to my mind is https://en.wikipedia.org/wiki/Kolmogorov_complexity but you kind of want the inverse. Given a parameterized definition, what is the size of the space it covers.
j
Joshua Horowitz
02/01/2019, 3:22 AMya'll getting silly with this complexity theory fuss
FWIW, it seems like the best way to think about "specific vs general" isn't as a quantitative measure, but as a comparative relation. X is more general than Y if there's a nice mapping from situations where you'd use Y to situations where you could use X instead. (This is analogous to the concept of "reducing" problems in complexity theory; egg on my face for talking smack about CT 5 minutes ago.)
There's a lot of wiggle room in that definition, and rightfully so. For instance: is a Turing machine more general than ANY computational artifact? Well, yeah, kind of. Although the mapping from your function to the Turing machine will basically involve programming the function into the Turing machine, so that's not that "nice" of a mapping.
Two examples of particularly nice mappings:
ā¢ Passing the exact same parameters along, typecast into a more general type! (So
add(a : double, b : double)add(a : int, b : int)join(list, delimiter)joinWithCommas(list)But as the mapping becomes more and more complex (writing wrapper code to adapt a library to a different style of API, etc.), it becomes less and less "nice", and it becomes less and less clear that one artifact is more general than the other.