Key Concepts

Introduction

The "Key Concepts" pages can be used as a hierarchical, annotated index, but their primary purpose is to provide a "study guide" for aspiring Elixir programmers. These pages are adapted from Clojure Key Concepts.

Note: The term "Elixero" is my own shorthand for "Elixir programmer" (:-).

Like its immediate ancestors (e.g., Clojure, Erlang, Ruby), Elixir is a very eclectic programming language. It draws upon a wide range of sources and supports a substantial set of programming concepts. Very few aspiring Elixeros will be familiar with all of these concepts, let alone how they interrelate.

For example, Clojure programmers may have used Actors and/or FP techniques, but be unfamiliar with pervasive patterns and the Erlang/OTP ecosystem. Hygienic macros, pipelines, and protocols may be new to Erlang and Ruby programmers.

José Valim has also added his own "special sauce", finding ways to meld and/or supplement these concepts into a cohesive whole. For example, consider the pervasive use of macros in the Elixir implementation.

As a hosted language, Elixir can draw upon a large body of Erlang code and lore. Elixeros have also been busy, porting and/or creating libraries. Consequently, aspiring Elixeros have a large (and growing) body of knowledge to discover, locate, select, comprehend, and use.

Motivation

There is a wealth of Resources (e.g., books, videos, web sites), so finding specific information tends to be easy. The difficulty of comprehending and using the information will vary, of course, depending on the person involved and the resources they are able to find.

However, none of this provides any focused help in detecting unknown unknowns: key concepts that the Elixero has never encountered (or noticed). Telling newbies to "read everything" isn't kind (let alone practical): leaving discovery up to chance is simply inefficient.

So, we need an efficient way for aspiring Elixeros to find out about unknown concepts, assess their proficiency, and organize their studies. These pages are a (very minimal) attempt in this direction.

Approach

My approach to this challenge is to create a taxonomy of concepts, implemented as a (cross-linked) tree of web pages. This structure provides the usual benefits of hierarchies: modularity, organization, and rapid navigation. It also allows rapid, straightforward navigation to a given topic page.

Each topic page (e.g., Architecture) contains a collection of (brief) definitions, organized by subtopic. If a topic page would be too large for comfort, it is broken up into an index page (e.g., Data) and a collection of subtopic pages (e.g., Data Collections).

Note: Much of this material is adapted from elixir-lang.org or Wikipedia. Most of the external links go to these (fine!) sites.

Usage

These pages can (and I hope, will) be used as a reference (e.g., "annotated concept index"). However, they can also be used as a "check list", "reading list", etc. Basically, dip into each topic and skim all of its entries. If you find yourself saying "Heh?" (rather than "Uhuh"), you've found a problem.

Either make a note to get back to the topic later (slacker :-) or follow the embedded links and read up on it. If you run into problems, please get in touch; maybe we can improve the situation. Finally, please feel free to suggest additions and corrections!

Topics

The lists below contain links into the topical pages. Sorry for the sprawl; there's a lot to cover...

Architecture - WIP

The Architecture page discusses the overall architecture of the (Erlang/OTP-based) Elixir implementation.

Data - WIP

The Data pages discuss various aspects of Elixir's approach to data.

Data (Abstract) - WIP

The Data (Abstract) page discusses abstract concepts (e.g., immutability, persistence) related to Elixir's approach to data.

Data Collections - WIP

The Data Collections page discusses Elixir's approach to data collections (e.g., maps, vectors).

Data Elements - WIP

The Data Elements page discusses Elixir's approach to data elements (e.g., integers, strings).

Metadata - WIP

The Metadata page discusses Elixir's (novel) approach to metadata (e.g., :doc, :tag).

References - WIP

The References page discusses Elixir's approach to reference data types (e.g., atoms).

Support - WIP

The Support page discusses Elixir's support mechanisms (e.g., garbage collection).

Functions - WIP

The Functions pages discuss Elixir functions, etc.

Function Dispatch - WIP

The Function Dispatch page discusses Elixir's approaches to function dispatch (e.g., behaviours, multimethods, protocols).

Higher Order Functions - WIP

The Higher Order Functions page discusses Elixir's approach to anonymous functions, lambda expressions, etc.

Erlang, etc. - WIP

The Erlang, etc. page discusses popular approaches to using Erlang (etc) from Elixir. It also touches on some Erlang concepts (and jargon) that aspiring Elixeros need to know.

To Do ...

Several additional topics are already planned or in progress, e.g.:

  • Complexity

  • Concurrency

  • Control Flow

  • Design Goals

  • Macros

  • Refactoring


This wiki page is maintained by Rich Morin, an independent consultant specializing in software design, development, and documentation. Please feel free to email comments, inquiries, suggestions, etc!

Topic revision: r37 - 04 Apr 2016, RichMorin
This site is powered by FoswikiCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding CFCL Wiki? Send feedback