
Programmer’s Thesaurus (2014) - curtis
http://wiki.c2.com/?ProgrammersThesaurus
======
RangerScience
Concept->Name mapping is not a problem unique to software and it has always
seemed to me to be (and I feel like somewhat of an arrogant ass saying this) a
consciousness-level problem.

In order to do this, seems to me you need: 1) Abstract pattern extraction 2)
Abstract pattern to word mapping 3) Composition/decomposition of composite
abstract patterns 4) Transforms on abstract patterns

Think about the game of Go. You have patterns that repeat throughout games,
but with small variations and with various transformations; you've got to be
able to extract the common pattern from the specific instance, and the
commonalities of the variations, and the common transforms (such as something
as simple as rotation/reflection).

Then you've got to have a mapping from those patterns (and meta-patterns) to
words. Near as I can tell, that part of the problem is basically culturally
established; whatever internal encoding you have for the abstractions is
unlikely to be communicable to other entities. You have to work out with those
other entities (aka, humans) what some of those patterns should be called.

------
arayh
I find myself getting annoyed by similar problems trying to name similar but
different concepts. And it seems like this is a very common problem among
programmers. Reminds me of this StackOverflow where everyone seems to have
their own opinion: [https://stackoverflow.com/questions/421965/anyone-else-
find-...](https://stackoverflow.com/questions/421965/anyone-else-find-naming-
classes-and-methods-one-of-the-most-difficult-parts-in-p#422061)

~~~
k__
Not a problem unique to programming.

Just look at math and psyics. They got stuff lile monads and quarks...

------
hyperpape
A related problem: I've been asking for a guide to naming classes/methods for
Java, both for myself and for my teammates. I haven't found anything newer
than the old Java beans crap. There are lots of little conventions you find in
newer libraries that I'd like to see short explanations of.

In principle, naming things is the same in any language, but languages develop
their own conventions.

~~~
proverbialbunny
Usually what you want is a style guide.

eg
[https://google.github.io/styleguide/javaguide.html](https://google.github.io/styleguide/javaguide.html)

Some times you have to build your own, or borrow from other kinds of sources
like:
[https://cloud.google.com/apis/design/naming_convention](https://cloud.google.com/apis/design/naming_convention)

~~~
hyperpape
Yeah, guides that cover what the Google Java guide does (capitalization, where
verbs go) are plentiful.

The example that sent me down this rabbit hole was with in Java. I believe
that:

    
    
        foo.withBar(bar)
    

mostly is, and only should be used with immutable APIs (or maybe a builder
method), but I've never been able to find a source that says it. I believe
this is a sort of convention, but one I haven't seen stated.

~~~
derefr
I think that's a
[https://en.wikipedia.org/wiki/Fluent_interface](https://en.wikipedia.org/wiki/Fluent_interface),
which usually only comes up in the context of functional programmers doing
OOP. It's not so much a matter of style, as that certain paradigms live only
within certain communities who happen to also have/use other styles and
paradigms exclusively, so you never see the paradigm used without its
"friends."

It might be clearest to state in anthropological terms: .withWhatever() is an
"idiom of a particular colloquial dialect of the language, spoken by a
subpopulation."

------
fjsolwmv
It's a link to a pre-StackOverflow wiki/forum. Anyone have a list of useful
links?

~~~
hyperpape
Not just a wiki, but the original wiki :) :
[https://en.wikipedia.org/wiki/Wiki#History](https://en.wikipedia.org/wiki/Wiki#History).

There are pretty frequent links to it on HN:
[https://news.ycombinator.com/from?site=c2.com](https://news.ycombinator.com/from?site=c2.com).

~~~
jpindar
It's the tvtropes of programming.

