Programmer’s Thesaurus (2014) | Hacker News Reader

Programmer’s Thesaurus (2014)

wiki.c2.com

66 pointscurtis11 comments

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.

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-...

Not a problem unique to programming.

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

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.

Usually what you want is a style guide.

eg 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

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.

I think that's a 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."

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

Not just a wiki, but the original wiki :) : https://en.wikipedia.org/wiki/Wiki#History.

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

It's the tvtropes of programming.

The C2 Wiki is where I first learned about things like refactoring (http://wiki.c2.com/?ReFactoring), rubber ducking (http://wiki.c2.com/?RubberDucking), and DRY (http://wiki.c2.com/?OnceAndOnlyOnce).

Reply on news.ycombinator.com