Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

awesome-naming

A curated list for when naming things is done right.
https://github.com/gruhn/awesome-naming

Last synced: 3 days ago
JSON representation

  • User Interface Design

    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Bento layout - A grid based layout resembling the compartmentation of bento boxes.
    • Breadcrumb - Navigational aid allowing users to keep track of their location within programs, documents, or websites. The term is a reference to the fairy tale _Hansel and Gretel_.
    • Carousel - A kind of animated slideshow looping back on itself.
    • Clipboard - Where you temporarily put _files_ you are working with (i.e. the copy & paste buffer).
    • Desktop - The metaphorical top of the user's desk, upon which objects such as documents and folders of documents can be placed.
    • Hamburger button - A button to toggle a menu. The associated icon resembles a hamburger.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Scrolling - Screen content is often less like a book with discrete pages and more like a continuous roll of parchment, i.e. a scroll.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
    • Optimistic UI - User interfaces that assume expensive operations will complete successfully thereby improving the perceived performance.
  • IT Security

    • Computer virus - A computer program that self replicates by _infecting_ other computer programs similar to the behavior of biological viruses.
    • Cyber hygiene - Steps and practices that users should take to maintain system health and improve online security.
    • Honeypot - Part of a system meant to look like an attractive target but actually helps detect and deflect attackers.
    • Phoning home - When a system (e.g. stolen computer) secretly reports back to a third party other than the current possessor. The name is a reference to the movie E.T.
    • Sandbox - A safe and isolated environment to test unverified programs that may contain malicious code.
    • Trojan horse - Malware which misleads users of its true intent. The term is derived from the Ancient Greek story of the deceptive Trojan Horse.
    • Backdoor - A method of bypassing normal authentication in a computer system.
    • Cyber hygiene - Steps and practices that users should take to maintain system health and improve online security.
  • Machine Learning and Artificial Intelligence

    • Confusion matrix - A tabular summary of a classifiers "confusion", i.e. how often it thought to make correct predictions when it actually didn't.
    • Decision boundary - A boundary dividing the space of possible data points. Here you decide, everything on this side is SPAM, everything on that side is not.
    • Gradient descent - Minimizing a cost function by iteratively computing the gradient and moving in the direction of steepest descent.
    • Hallucination - A confident response by an AI that does not seem to be justified by its training data.
    • Training - The process of showing the machine a bunch of examples, until it learns what we want from it.
  • Programming Languages and Programming Language Theory

    • Choreographic programming - A programming paradigm where programs are compositions of interactions among multiple concurrent participants.
    • Clojure - A functional language making extensive use of **closures** but with a **j** because it's running on the Java virtual machine.
    • C++ - Although C was certainly a bad name, C++ was quite clever. The iconic increment operator **++** indicates that **C++** is the successor.
    • Garbage Collector - Part of a program that attempts to find and reclaim garbage pieces of memory not used anymore.
    • Syntactic sugar - Syntax that makes the language "sweeter" for human use. Usually a shorthand for common operations that can also be expressed in a more verbose form.
    • Lazy evaluation - An evaluation stategy which suspends evaluation until it's absolutely necessary and then never does it again.
  • Theoretical Computer Science

    • Busy Beaver - Turing machines that produce numbers so insanly large, no other algorithm can keep up with them.
    • Clique problem - The problem of finding groups of mutual friends in a network of people with friendship relations. Or more general, finding complete subgraphs.
    • Game of Life - A game world that showcases how astonishing complexity can arise from very simple ingredients.
    • Oracle - A black box that magically gives answers even to undeciable questions like the halting problem.
    • Pumping lemma - The fact that in some formal languages any sufficiently long string can be _pumped_ with repetitions of its substring and the result stays in the same formal language.
  • Tools, Applications, Libraries, Frameworks

    • Safari - Web browser developed by Apple.
    • yarn - NodeJS dependency manager.
    • clooney - A JavaScript library implementing the actor model for concurrent computation. The term is a reference to George Clooney who is also an actor.
    • horcrux - Splits a file into encrypted fragments that only together can be decrypted again. In the Harry Potter universe, Horcruxes are fragments of a persons soul. To kill the person, all fragments must be destroyed.
    • Puppeteer - A browser automation library. If the browser is the puppet, this is the puppeteer.
    • Uglify - A JavaScript minifier. Removes everything that makes the code readable and pretty to make it smaller.
    • uppy - A dog themed uploader component. The name is a blend of _upload_ and _puppy_. It even comes with a crash recovery plugin called _Golden Retriever_.
    • CockroachDB - Database application, that is marketed as being so fault tolerant and resilient as a cockroach.
    • tldr - Simplified man pages with practical examples.
    • Webpack - A bundler for JavaScript and other *web* assets with a short and descriptive name that also somewhat rhymes.
  • Data Structures and Algorithms

    • Backtracking - When you explore a search space and you reach a dead end, you follow your *tracks* back to the last crossroad and try the other way.
    • Brute force - Violence is actually almost always a solution but not a very clever one.
    • Greedy algorithm - An algorithm that finds a solution by always picking the currently best looking option without thinking too much about past and future decisions.
    • Hill climbing - Starting somewhere in the hilly "landscape" of solutions you go in the direction of steepest ascent until reaching the top of a hill. You might miss higher hills though.
    • Israeli Queue - A type of priority queue and a reference to the infamously unorganized queues in Israel. Here items can *cut in line* when they *have already waiting friends*.
    • Stack - Like with a stack of pancakes you can only add and remove items from the top of this data structure.
    • Tree - A hierarchically organized data structure. From the _root_ item the other items _branch out_ into _nodes_ and _leaves_. A collection of trees is often called a *forest*.
    • Queue - In this data structure items are always added at the end and removed at the front as if the items were waiting in line.
  • Design Patterns and Anti Patterns

    • Adapter - Allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class.
    • Facade - Analogous to a facade in architecture, a facade is an object that serves as a front-facing interface masking more complex underlying structure.
    • Promise - A representation of a result that is available in the future, unless there are errors. Like in reality, promises are broken sometimes.
    • Shotgun surgery - A programming antipattern where in a single change you wildly add code everywhere in your codebase.
    • Spaghetti Code - A program with a tangled and hard-to-follow stucture.
  • Functions

    • fold - Like a blanket being folded up, this function iterates a collection and in each step combines the current item with everything that has already been folded.
    • munch - Parser function that greedily consumes an input stream until it's satisfied.
    • trampoline - Continuously runs functions which itself return functions. Like a child on a trampoline that _returns_ and bounces back up.
    • zip - Merges two lists into one list of pairs like the interlocking teeth of a zipper.
  • Other

    • Magic - A magic program/piece of code is doing it's job but nobody knows how. Like in reality, magic doesn't actually exist. Once you understand it, it's not magic anymore.
    • a11y, i18n, k8s, ... - Abbreviating long words by keeping the first and last letter and writing the number of omitted letters in between.
    • ACID vs. BASE - Acronyms describing competing database ideologies (aka. SQL vs. NoSQL). Note that acid and base are also opposites in chemistry.
    • Bottleneck - A central part of a network/application that significantly limits throughput/performance and should ideally be eliminated.
    • Brick - When your device is so corrupted it virtually turns into a brick.
    • camelCase, snake_case, kebab-case - Different case styles where the name illustrates its appearance.
    • Easter egg - A hidden feature especially in video games in reference to the Easter egg hunt.
    • Floating point number - This representation can encode numbers at very different magnitudes with limited amount of digits by letting the radix point _float_ instead of being fixed in place.
    • Framework - In software architecture (like in actual architecture) frameworks provide basic structure to build upon that guide and constrain the further development.
    • Glue Code - Jenga and LEGO bricks don't share the same interface but you can always glue them together.
    • Heisenbug - A bug that seems to disappear or change when one tries to study it. It's a pun on Werner Heisenberg who discovered that the act of observing quantum systems inevitably alters their state.
    • Process starvation - A problem where a process is perpetually denied resources to do its work.
    • Time travel debugging - Stepping back in time through source code to understand execution and sometimes even to change history.
    • Tree shaking - Shake the dependency tree until all the dead parts are falling off and you end up with a nice lean tree.
    • Unfair enumeration - A program that outputs all even numbers and then all odd numbers generates an unfair enumeration of the natural numbers because some numbers are never reached.
    • Yoda condition - When you write `if ("red" === color) {` instead of `if (color === "red") {` because it reads as, “if red equals the color”, similar to the way the Star Wars character Yoda speaks.