Computing

General

See also Maths#Computation, Computer, Emulation, Virtualisation, Data, *nix, Maths#Types

to very much further sort and understand.

A program is many things. It is a piece of text typed by a programmer, it is the directing force that makes the computer do what it does, it is data in the computer's memory, yet it controls the actions performed on this same memory. Analogies that try to compare programs to objects we are familiar with tend to fall short, but a superficially fitting one is that of a machine. The gears of a mechanical watch fit together ingeniously, and if the watchmaker was any good, it will accurately show the time for many years. The elements of a program fit together in a similar way, and if the programmer knows what he is doing, the program will run without crashing.

A computer is a machine built to act as a host for these immaterial machines. Computers themselves can only do stupidly straightforward things. The reason they are so useful is that they do these things at an incredibly high speed. A program can, by ingeniously combining many of these simple actions, do very complicated things. ... When a program works, it is beautiful. The art of programming is the skill of controlling complexity. The great program is subdued, made simple in its complexity.

-- http://eloquentjavascript.net/chapter1.html

Basics

• WP: Computer_literacy - defined as the knowledge and ability to use computers and related technology efficiently, with skill levels ranging from elementary use to computer programming and advanced problem solving. Computer literacy can also refer to the comfort level someone has with using computer programs and applications. Another valuable component is understanding how computers work and operate. An individual's level of computer literacy is measured on the scale of how skilled they are when it comes to using computers and other related tools to achieve a goal. Computer literacy may be distinguished from computer programming, which primarily focuses on the design and coding of computer programs rather than the familiarity and skill in their use. Various countries, including the United Kingdom and the United States, have created initiatives to improve national computer literacy rates.

• WP: List_of_important_publications_in_computer_science

• WP: Computing_platform

• YouTube: Richard Feynman Computer Heuristics Lecture [1]

• WP: Computer_programming

• WP: Script_(computing)

• WP: Interactive_computing - refers to software which accepts input from the user as it runs. Interactive software includes commonly used programs, such as word processors or spreadsheet applications. By comparison, non-interactive programs operate without user intervention; examples of these include compilers and batch processing applications that are pre-programmed to run independently.

• Intro | Putting the "You" in CPU - A technical explainer of how your computer runs programs, from start to finish.Curious exactly what happens when you run a program on your computer? Read this article to learn how multiprocessing works, what system calls really are, how computers manage memory with hardware interrupts, and how Linux loads executables.
  • https://github.com/hackclub/putting-the-you-in-cpu

• http://www.cs.hmc.edu/csforall [2]

• Khan Academy: Computer science: information theory

• Ask HN: What's the best technical talk you've heard?

• https://github.com/mtdvio/every-programmer-should-know

• How To Become A Hacker - Eric Steven Raymond
• http://www.catb.org/~esr/faqs/smart-questions.html

• Pipe Logic - "In this model, a UNIX pipe acts like a wire, that is, a conductor with parasitic capacitance."

• https://github.com/dwmkerr/hacker-laws

• Wikipedia:Algorithms + Data Structures = Programs

• What I tell all new programmers
• Programmer Competency Matrix
• Six languages to master.
• Learning C, reducing fear.
• Programming is Hard, Let's Go Scripting...
• A Scripter at Heart
• http://vislab-ccom.unh.edu/~schwehr/Classes/2011/esci895-researchtools/

• Simple Made Easy - Rich Hickey emphasizes simplicity’s virtues over easiness’, showing that while many choose easiness they may end up with complexity, and the better way is to choose easiness along the simplicity path. ]

• Self-Taught Developers: Are You Missing Your Foundation?
• Torvalds' quote about good programmer - "Bad programmers worry about the code. Good programmers worry about data structures and their relationships."

• Stack Exchange: I've inherited 200K lines of spaghetti code — what now?

• Become a Programmer, Motherfucker
• Teach Yourself Programming in Ten Years
• Learnable Programming - Bret Victor - Designing a programming system for understanding programs

• Computer Science For Everyone

• What is static program analysis?

• r2c blog — Introducing Semgrep and r2c
  • https://github.com/returntocorp/semgrep - a fast, open-source, static analysis tool that excels at expressing code standards — without complicated queries — and surfacing bugs early at editor, commit, and CI time. Precise rules look like the code you’re searching; no more traversing abstract syntax trees or wrestling with regexes.

• The 5 Hardest Parts of Programming - Optimization, Networking, Security, Reliability, Scalability

• The Pokayoke Guide to Developing Software
• I bet you over-engineered your startup

• https://news.ycombinator.com/item?id=12637239

• How To Ask Questions The Smart Way

• slash7 with Amy Hoy » Blog Archive » Help Vampires: A Spotter’s Guide

• The Cursed Computer Iceberg Meme - the intent is to awaken you to many of the peculiarities and weirdness of computers. hopefully, after reading these articles, you will have learned a lot and will embrace chaos.

Reference

• WikiChip - a semiconductor and computer engineering technology website. We detail historical and modern electronic systems and technologies as well as related topics.

• http://stackoverflow.com/
  • StackMonthly - A monthly digest of the best questions on StackOverflow

• Chart for Learning a Programming Language

• Hyperpolyglot - a programming language side-by-side reference sheet
  • Interpreted Languages: PHP, Perl, Python, Ruby (Sheet One)
• http://rosettacode.org/wiki/Rosetta_Code
• A Very Quick Comparison of Popular Languages for Teaching Computer Programming
• syntax across languages
• http://helloworldquiz.com/

• Programming languages ranked by expressiveness
• The Computer Language Benchmarks Game

• How do we tell truths that might hurt? - E.W. Dijkstra
• YourLanguageSucks

• My boss decided to add a “person to blame” field to every bug report. How can I convince him that it's a bad idea?

• Ask HN: Your favourite style guide?
• Patterns and Anti-Patterns in Code Comments

• Project Euler is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve. Although mathematics will help you arrive at elegant and efficient methods, the use of a computer and programming skills will be required to solve most problems.
• Websites like projecteuler.net
• JavaScript solutions to the Project Euler problems.

• Dad and the Ten Commandments of Egoless Programming

• "The Best Programming Advice I Ever Got" with Rob Pike

• Comparing Objective Caml and Standard ML

• The Last Programming Language
  • Not all programmers are alike: a language rant

• Typing Practice for Programmers

• Operations Anti-Patterns

• Dynamic languages are static languages

• Troubleshooting Yourself in the Foot

• Naivety Helped Me Learn Rails

• Great Ideas in Theoretical Computer Science - OCW

• Advanced programming languages

• Greg Wilson - What We Actually Know About Software Development, and Why We Believe It's True

• Programming Languages Are Simply Not Powerful Enough

• Why Python, Ruby, and Javascript are Slow

• Don't Copy And Paste Other People's Code, Type It Out

• http://codular.com/

• http://pandodaily.com/2013/05/07/should-everybody-learn-to-code-a-pandodaily-meta-media-mashup-of-opinion/

• https://news.ycombinator.com/item?id=5802960
• http://esolangs.org/wiki/Main_Page

• Great Works in Programming Languages

• https://github.com/adambard/learnxinyminutes-docs

• http://www.csc.kth.se/utbildning/kth/kurser/DD1335/gruint10/litterature/

• http://thecodelesscode.com/contents

• http://showmedo.com/

• http://lee-phillips.org/lispmath/
• http://www.evanmiller.org/mathematical-hacker.html
• http://www.the-adam.com/adam/rantrave/st02.pdf

• https://github.com/labuladong/fucking-algorithm/tree/english

• https://github.com/sindresorhus/awesome

• Beautiful Software - Christopher Alexander's research initiative on computing and the environment

Books

• https://github.com/vhf/free-programming-books/blob/master/free-programming-books.md

• http://hackershelf.com/

• https://news.ycombinator.com/item?id=10715161

• WP: Structure_and_Interpretation_of_Computer_Programs
  • http://www.eecs.berkeley.edu/~bh/sicp.html
  • http://news.ycombinator.com/item?id=2115756
  • http://xuanji.appspot.com/isicp/
  • https://berkeley-cs61as.github.io/ [3]
  • http://www.posteriorscience.net/?p=206 [4]
  • https://news.ycombinator.com/item?id=13918465

• http://combinators.info/

• https://gitorious.org/learn-x-the-hard-way/learn-x-the-hard-way/blobs/master/README

• http://codingforinterviews.com/books

• http://en.wikibooks.org/wiki/Computer_Programming
• WikiBooks: A-level Computing/AQA/Problem Solving, Programming, Operating Systems, Databases and Networking/Programming Concepts

• Software Foundations

• http://eric.themoritzfamily.com/books-every-self-taught-computer-scientist-should-read.html

• http://nlpwp.org/book/

• http://stackoverflow.com/questions/194812/list-of-freely-available-programming-books/392926#392926

• http://citizen428.net/blog/2010/08/12/30-free-programming-ebooks/

• http://natureofcode.com/book/

• http://programmer.97things.oreilly.com/wiki/index.php/Contributions_Appearing_in_the_Book

• https://news.ycombinator.com/item?id=8035332

• https://courses.csail.mit.edu/6.042/spring17/mcs.pdf [5]

News and blogs

• http://news.ycombinator.com

• http://arstechnica.com

• http://slashdot.org

• http://www.theregister.co.uk

• http://www.2600.com

• Ask HN: What unknown technical blogs or sites do you read?

• Ask HN: What are your daily must-read sites?

• http://lambda-the-ultimate.org

• http://queue.acm.org

• http://www.infoq.com

• http://www.dzone.com

• http://techcrunch.com

• http://www.cringely.com

• http://www.kernelmag.com

• http://www.h-online.com - closed

History

• WP: History_of_computing

• WP: History_of_computing_hardware

• http://computerpionee.rs/

• http://gunkies.org/wiki/Main_Page

• Finite of Sense and Infinite of Thought:
  A History of Computation, Logic and Algebra

• YouTube: Ron Pressler - Finite of Sense and Infinite of Thought: A History of Computation, Logic and Algebra

• Leibniz: Explanation of Binary Arithmetic (1703) [6]

• WP: Calculus_ratiocinator
• Leibniz: Logic | Internet Encyclopedia of Philosophy -

• WP: Stepped_reckoner - a digital mechanical calculator invented by the German mathematician Gottfried Wilhelm Leibniz around 1672 and completed in 1694. The name comes from the translation of the German term for its operating mechanism, Staffelwalze, meaning 'stepped drum'. It was the first calculator that could perform all four arithmetic operations. Its intricate precision gearwork, however, was somewhat beyond the fabrication technology of the time; mechanical problems, in addition to a design flaw in the carry mechanism, prevented the machines from working reliably.

• WP: Leibniz_wheel

• WP: Arithmometer

• WP: Difference_engine

• WP: Analytical_Engine

• http://www.rrsignalpix.com/grsnx.html

• WP: Z1_%28computer%29

• WP: ENIAC

• http://www.zl2al.com/blog/category/ibm-704-computer - 1959

• http://www.cyberliving.uk/

• http://www.gresham.ac.uk/lectures-and-events/a-very-brief-history-of-computing-1948-2015 [7]

• WP: History_of_computing_hardware_(1960s%E2%80%93present)

• WP: History_of_computer_hardware_in_Soviet_Bloc_countries

• WP: Sketchpad - 1963
  • http://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-574.pdf

• http://www.curtamania.com/curta/database/brand/olivetti/Olivetti%20Programma%20101/index.html - 1965 [8]

• WP: SRI_International
  • WP: Augmentation_Research_Center
  • WP: NLS_(computer_system)
  • YouTube: The Mother of All Demos, presented by Douglas Engelbart (1968)

• http://dougengelbart.org/
  • http://worrydream.com/Engelbart/
  • https://news.ycombinator.com/item?id=6875879

• WP: Bill_English_(computer_engineer)

• WP: Input_method_editor

• WP: RAND_Tablet

• WP: PARC_(company)

• WP: Xerox_Alto - 1973

• https://news.ycombinator.com/item?id=11929396

• WP: Altair_8800 - a microcomputer designed in 1975 based on the Intel 8080 CPU. Interest grew quickly after it was featured on the cover of the January 1975 issue (published in late November 1974) of Popular Electronics, and was sold by mail order through advertisements there, in Radio-Electronics, and in other hobbyist magazines. The designers hoped to sell a few hundred build-it-yourself kits to hobbyists, and were surprised when they sold thousands in the first month.

• YouTube: Computer That Changed Everything (Altair 8800) - Computerphile

• WP: Xerox_Star - 1981
  • WP: Pilot_(operating_system)
  • YouTube: The Final Demonstration of the Xerox 'Star' computer [9]
    • "with the longest perspective perhaps of most folks on object orientated guis, has your faith in object orientated guis been shaken at all?" "not badly enough to call them guis." - 2:01:50
  • PARC Movies

• Introducing Darkstar: A Xerox Star Emulator – ENGBLG - [10]

• http://www.jagshouse.com/swyft.html [11]

• http://www.mission-base.com/tamiko/theory/cm_txts/di-frames.html - 1983
• WP: Connection_Machine

• WP: Apple_Lisa - 1983

• WP: Apple_Macintosh - 1984

• WP: Graphical_Environment_Manager

• http://toastytech.com/guis [12]

• http://www.filfre.net/2015/03/the-68000-wars-part-1-lorraine/ [13]

• YouTube: Alan Kay - Normal Considered Harmful [14]

• The Jargon File - a comprehensive compendium of hacker slang illuminating many aspects of hackish tradition, folklore, and humor.

• https://news.ycombinator.com/item?id=25912241

Ternary

• WP: Ternary_computer - also called trinary computer, is one that uses ternary logic (i.e., base 3) instead of the more common binary system (i.e., base 2) in its calculations. This means it uses trits (instead of bits, as most computers do).
• WP: Setun - Russian, 1958

• https://dev.to/buntine/the-balanced-ternary-machines-of-soviet-russia

• YouTube: homebrew ternary computer
  • https://github.com/ssloy/triador - Ternary computer emulator

• https://github.com/tedkotz/ternary - A storage place for my ternary experiments, including an emulator for a theoretical 27-trit CPU.

People

• WP: Claude_Shannon - was an American mathematician, electrical engineer, and cryptographer known as "the father of information theory". Shannon is noted for having founded information theory with a landmark paper, "A Mathematical Theory of Communication", that he published in 1948.He is also well known for founding digital circuit design theory in 1937, when—as a 21-year-old master's degree student at the Massachusetts Institute of Technology (MIT)—he wrote his thesis demonstrating that electrical applications of Boolean algebra could construct any logical numerical relationship. Shannon contributed to the field of cryptanalysis for national defense during World War II, including his fundamental work on codebreaking and secure telecommunications.

• PDF: A Mathematical Theory of Communication - By C. E. SHANNON, 1948

• WP: Alan_Turing

• WP: Konrad_Zuse
  • http://www.linuxvoice.com/konrad-zuse-nearly-the-german-turing-5 [15]

• WP: John_von_Neumann
  • http://stepanov.lk.net/mnemo/legende.html

• WP: Alonzo_Church

• WP: Alfred_Tarski

• WP: Kurt_G%C3%B6del

• WP: Emil_Leon_Post

• WP: Stephen_Cole_Kleene

• WP: Erich_Bloch

https://news.ycombinator.com/item?id=23869819

• https://news.ycombinator.com/item?id=17797003

• Important Women in CS Who Aren't Grace Hopper, Margaret Hamilton, or Ada Lovelace - Hillel Wayne

• Ask HN: Alan Kay says programing is pop culture. Where can I find the classics?

• YouTube: Extracting Energy from the Turing Tarpit - Alan C. Kay during the ACM A.M. Turing Centenary Celebration, June, 2012.

• An Interview with Computing Pioneer Alan Kay | TIME.com - Born in 1940, computer scientist Alan Curtis Kay is one of a handful of visionaries most responsible for the concepts which have propelled personal computing forward over the past thirty years.

• Goodbye Joe

• Vimeo: Bret Victor - Inventing on Principle

• Falsehoods programmers believe about geography – Thias の blog

• .:: Phrack Magazine ::.

Architecture

See also Electronics

• George Dyson on the Origins of the Digital Universe - The talk focuses on the work done at The Institute for Advanced Study in Princeton New Jersey by such renowned scientists as John von Neumann and Kurt Godel.

• WP: Computer_architecture

• WP: Harvard_architecture - a computer architecture with physically separate storage and signal pathways for instructions and data. The term originated from the Harvard Mark I relay-based computer, which stored instructions on punched tape (24 bits wide) and data in electro-mechanical counters. These early machines had data storage entirely contained within the central processing unit, and provided no access to the instruction storage as data. Programs needed to be loaded by an operator; the processor could not initialize itself.

• WP: Von_Neumann_architecture - meaning has evolved to be any stored-program computer in which an instruction fetch and a data operation cannot occur at the same time because they share a common bus. This is referred to as the von Neumann bottleneck and often limits the performance of the system. The design of a von Neumann architecture is simpler than the more modern Harvard architecture which is also a stored-program system but has one dedicated set of address and data buses for reading data from and writing data to memory, and another set of address and data buses for fetching instructions.

• WP: Modified_Harvard_architecture - a variation of the Harvard computer architecture that allows the contents of the instruction memory to be accessed as if it were data. Most modern computers that are documented as Harvard architecture are, in fact, Modified Harvard architecture.

• WP: Flynn's_taxonomy - a classification of computer architectures, proposed by Michael Flynn in 1966. The classification system has stuck, and has been used as a tool in design of modern processors and their functionalities.

• CDA 5106 - Advanced Computer Architecture I Reading List

• OpenCores - Since 1999, OpenCores is the most prominent online community for the development of gateware IP (Intellectual Properties) Cores. It is the place where such cores are shared and promoted in the spirit of Free and Open Source collaboration.
  • http://opencores.org/projects - main objective is to design and publish core designs under a license for hardware modeled on the Lesser General Public License (LGPL) for software. We are committed to the ideal of freely available, freely usable and re-usable open source hardware.

• Microprocessors Running on Air?. There was a time, now forgotten, where… | by Erik Engheim | Jan, 2021 | Medium - [16]

Instructions

• WP: Instruction_set - or instruction set architecture (ISA), is the part of the computer architecture related to programming, including the native data types, instructions, registers, addressing modes, memory architecture, interrupt and exception handling, and external I/O. An ISA includes a specification of the set of opcodes (machine language), and the native commands implemented by a particular processor.

• WP: First-generation_programming_language - a machine-level programming language. A first generation (programming) language (1GL) is a grouping of programming languages that are machine level languages used to program first-generation computers. Originally, no translator was used to compile or assemble the first-generation language. The first-generation programming instructions were entered through the front panel switches of the computer system.The instructions in 1GL are made of binary numbers, represented by 1s and 0s. This makes the language suitable for the understanding of the machine but far more difficult to interpret and learn by the human programmer.The main advantage of programming in 1GL is that the code can run very fast and very efficiently, precisely because the instructions are executed directly by the central processing unit (CPU). One of the main disadvantages of programming in a low level language is that when an error occurs, the code is not as easy to fix.First generation languages are very much adapted to a specific computer and CPU, and code portability is therefore significantly reduced in comparison to higher level languages.Modern day programmers still occasionally use machine level code, especially when programming lower level functions of the system, such as drivers, interfaces with firmware and hardware devices. Modern tools such as native-code compilers are used to produce machine level from a higher-level language.

• WP: Microarchitecture - sometimes abbreviated to µarch or uarch, also called computer organization, is the way a given instruction set architecture (ISA) is implemented on a processor. A given ISA may be implemented with different microarchitectures; implementations may vary due to different goals of a given design or due to shifts in technology. Computer architecture is the combination of microarchitecture and instruction set design.

• WP: List_of_instruction_sets

• https://github.com/oowekyala/arm-cheatsheet - All ARM assembly commands on one pdf page

• PDF: Proprietary versus open instruction sets [17]

• WP: Microcode - a layer of hardware-level instructions or data structures involved in the implementation of higher level machine code instructions in central processing units, and in the implementation of the internal logic of many channel controllers, disk controllers, network interface controllers, network processors, graphics processing units, and other hardware. It resides in special high-speed memory and translates machine instructions into sequences of detailed circuit-level operations. It helps separate the machine instructions from the underlying electronics so that instructions can be designed and altered more freely. It also makes it feasible to build complex multi-step instructions while still reducing the complexity of the electronic circuitry compared to other methods. Writing microcode is often called microprogramming and the microcode in a particular processor implementation is sometimes called a microprogram.

• https://wiki.archlinux.org/index.php/Microcode

• Linux* Processor Microcode Data File

• Notes on Intel Microcode Updates

• https://www.bedroomlan.org/projects/mcasm [18]

• WP: Machine_code - a set of instructions executed directly by a computer's central processing unit (CPU). Each instruction performs a very specific task, such as a load, a jump, or an ALU operation on a unit of data in a CPU register or memory. Every program directly executed by a CPU is made up of a series of such instructions. Numerical machine code (i.e., not assembly code) may be regarded as the lowest-level representation of a compiled or assembled computer program or as a primitive and hardware-dependent programming language. While it is possible to write programs directly in numerical machine code, it is tedious and error prone to manage individual bits and calculate numerical addresses and constants manually. It is thus rarely done today, except for situations that require extreme optimization or debugging.

• WP: Word_(computer_architecture) - term for the natural unit of data used by a particular processor design. A word is basically a fixed-sized group of digits (binary or decimal) that are handled as a unit by the instruction set or the hardware of the processor. The number of digits in a word (the word size, word width, or word length) is an important characteristic of any specific processor design or computer architecture.

• WP: Opcode - the portion of a machine language instruction that specifies the operation to be performed.

• WP: Operand#Computer_science - the part of a computer instruction which specifies what data is to be manipulated or operated on, while at the same time representing the data itself. A computer instruction describes an operation such as add or multiply X, while the operand (or operands, as there can be more than one) specify on which X to operate as well as the value of X. Additionally, in assembly language, an operand is a value (an argument) on which the instruction, named by mnemonic, operates. The operand may be a processor register, a memory address, a literal constant, or a label.

• WP: Bytecode - also known as p-code (portable code), is a form of instruction set designed for efficient execution by a software interpreter. Unlike human-readable source code, bytecodes are compact numeric codes, constants, and references (normally numeric addresses) which encode the result of parsing and semantic analysis of things like type, scope, and nesting depths of program objects. They therefore allow much better performance than direct interpretation of source code.

"fundamentally the same as machine code, in that it describes low level operations such as reading and writing memory, and basic calculations. Bytecode is typically conceived to be produced when COMPILING a higher level language, for example PHP or Java, and unlike machine code for many hardware based processors, may have operations to support specific features of the higher level language. A key difference is that the processor of bytecode is usually a program, though processors have been created for interpreting some bytecode specifications, e.g. a processor called SOAR (Smalltalk On A RISC) for Smalltalk bytecode. While you wouldn't typically call native machine code bytecode, for some types of processors such as CISC and EISC (e.g. Linn Rekursiv, from the people who made record players), the processor itself contains a program that is interpreting the machine instructions, so there are parallels." [19]

Machine data types - All data in computers based on digital electronics is represented as bits (alternatives 0 and 1) on the lowest level. The smallest addressable unit of data is usually a group of bits called a byte (usually an octet, which is 8 bits). The unit processed by machine code instructions is called a word (as of 2011, typically 32 or 64 bits). Most instructions interpret the word as a binary number, such that a 32-bit word can represent unsigned integer values from 0 to 2^{32}-1 or signed integer values from -2^{31} to 2^{31}-1. Because of two's complement, the machine language and machine doesn't need to distinguish between these unsigned and signed data types for the most part.

There is a specific set of arithmetic instructions that use a different interpretation of the bits in word as a floating-point number. Machine data types need to be exposed or made available in systems or low-level programming languages, allowing fine-grained control over hardware. The C programming language, for instance, supplies integer types of various widths, such as short and long. If a corresponding native type does not exist on the target platform, the compiler will break them down into code using types that do exist. For instance, if a 32-bit integer is requested on a 16 bit platform, the compiler will tacitly treat it as an array of two 16 bit integers.

• http://www.math.grin.edu/~rebelsky/Courses/152/97F/Readings/machine-data.html

Processing

• WP: Microelectronics

• WP: Processor_(computing)#Computing

• WP: Processor_design

• WP: Voltage_regulator_module - VRM), sometimes called processor power module (PPM), is a buck converter that provides a microprocessor the appropriate supply voltage, converting +5 V or +12 V to a much lower voltage required by the CPU, allowing processors with different supply voltage to be mounted on the same motherboard.

• Libre Silicon - We develop a free (as in freedom, not as in free of charge) and open source semiconductor manufacturing process standard, including a full mixed signal PDK, and provide a quick, easy and inexpensive way for manufacturing. No NDAs will be required anywhere to get started, making it possible to build the designs in your basement if you wish so. We are aiming to revolutionize the market by breaking through the monopoly of proprietary closed source manufacturers! [20]

CPU

• WP: Central_processing_unit

• WP: CPU_design

• https://github.com/larsbrinkhoff/awesome-cpus

• WP: Semiconductor_intellectual_property_core

• WP: Uniprocessor_system

• WP: List_of_CPU_architectures

• https://news.ycombinator.com/item?id=8529658

• Great Microprocessors of the Past and Present (V 13.4.0) - [21]

• WP: Control_unit - a component of a computer's central processing unit (CPU) that directs operation of the processor. It controls communication and co-ordination between input/output devices. It reads and interprets instructions and determines the sequence for processing the data.

• WP: Control_store - the part of a CPU's control unit that stores the CPU's microprogram. It is usually accessed by a microsequencer.

• WP: Microsequencer

• WP: Processor_register

• AVX-512: when and how to use these new instructions – Daniel Lemire's blog -

• WP: Memory_address_register
• WP: Memory_data_register

• WP: Register_renaming
• http://www.mikeash.com/pyblog/friday-qa-2013-10-11-why-registers-are-fast-and-ram-is-slow.html

• WP: Accumulator_(computing)

• WP: Adder_(electronics)

• Abusing the CPU’s adder circuits | scaramanga - [22]

• WP: Arithmetic_logic_unit
  • http://www.righto.com/2013/09/the-z-80-has-4-bit-alu-heres-how-it.html

• http://www.righto.com/2017/03/inside-vintage-74181-alu-chip-how-it.html

• WP: Execution_unit

• WP: Cache_coherence - the uniformity of shared resource data that ends up stored in multiple local caches. When clients in a system maintain caches of a common memory resource, problems may arise with incoherent data, which is particularly the case with CPUs in a multiprocessing system. In the illustration on the right, consider both the clients have a cached copy of a particular memory block from a previous read. Suppose the client on the bottom updates/changes that memory block, the client on the top could be left with an invalid cache of memory without any notification of the change. Cache coherence is intended to manage such conflicts by maintaining a coherent view of the data values in multiple caches.

• WP: CPU_cache

• YouTube: Why do CPUs Need Caches? - Computerphile

• WP: Instruction_pipeline
• http://lolengine.net/blog/2011/9/17/playing-with-the-cpu-pipeline [23]

• WP: Pipeline_burst_cache

• WP: NX_bit - stands for No-eXecute, a technology used in CPUs to segregate areas of memory for use by either storage of processor instructions (code) or for storage of data, a feature normally only found in Harvard architecture processors. However, the NX bit is being increasingly used in conventional von Neumann architecture processors, for security reasons.

• WP: Branch_predictor

• WP: Branch_predication - a strategy in computer architecture design for mitigating the costs usually associated with conditional branches, particularly branches to short sections of code. It does this by allowing each instruction to conditionally either perform an operation or do nothing.

• WP: MIMD

• WP: SPMD

• WP: Vector_processor - a central processing unit (CPU) that implements an instruction set containing instructions that operate on one-dimensional arrays of data called vectors

• WP: Scalar_processor

• https://github.com/kragen/calculusvaporis

• https://news.ycombinator.com/item?id=11836728

• https://news.ycombinator.com/item?id=12933838

• http://2x-1.net/ob/gray1 [24]

• WP: Processor_affinity - or CPU pinning or "cache affinity", enables the binding and unbinding of a process or a thread to a central processing unit (CPU) or a range of CPUs, so that the process or thread will execute only on the designated CPU or CPUs rather than any CPU. This can be viewed as a modification of the native central queue scheduling algorithm in a symmetric multiprocessing operating system. Each item in the queue has a tag indicating its kin processor. At the time of resource allocation, each task is allocated to its kin processor in preference to others.

Microprocessor

• WP: Microprocessor - a computer processor that incorporates the functions of a computer's central processing unit (CPU) on a single integrated circuit

• http://www.lighterra.com/papers/modernmicroprocessors/ [25]

• https://news.ycombinator.com/item?id=10194221

• http://www.righto.com/2015/05/the-texas-instruments-tmx-1795-first.html [26]

• http://queue.acm.org/detail.cfm?id=2687011 [27]

Coprocessor

• WP: Coprocessor - a computer processor used to supplement the functions of the primary processor (the CPU). Operations performed by the coprocessor may be floating point arithmetic, graphics, signal processing, string processing, encryption or I/O Interfacing with peripheral devices. By offloading processor-intensive tasks from the main processor, coprocessors can accelerate system performance. Coprocessors allow a line of computers to be customized, so that customers who do not need the extra performance need not pay for it.

• WP: Floating-point_unit - FPU, colloquially a math coprocessor) is a part of a computer system specially designed to carry out operations on floating point numbers. Typical operations are addition, subtraction, multiplication, division, square root, bitshifting. Some systems (particularly older, microcode-based architectures) can also perform various transcendental functions such as exponential or trigonometric calculations, though in most modern processors these are done with software library routines. In a general purpose computer architectures, one or more FPUs may be integrated with the central processing unit; however many embedded processors do not have hardware support for floating-point operations.
  • http://www.eecs.berkeley.edu/~wkahan/ieee754status/754story.html

• http://lemire.me/blog/2017/02/28/how-many-floating-point-numbers-are-in-the-interval-01/ [28]

• WP: Arithmetic_underflow - The term arithmetic underflow (also floating point underflow, or just underflow) is a condition in a computer program where the result of a calculation is a number of smaller absolute value than the computer can actually represent in memory on its central processing unit (CPU).

• WP: Denormal_number - fill the underflow gap around zero in floating-point arithmetic. Any non-zero number with magnitude smaller than the smallest normal number is subnormal.

• WP: Controller_(computing) - a chip, an expansion card, or a stand-alone device that interfaces with a peripheral device. This may be a link between two parts of a computer (for example a memory controller that manages access to memory for the computer) or a controller on an external device that manages the operation of (and connection with) that device.

The term is sometimes used in the opposite sense to refer to a device by which the user controls the operation of the computer, as in game controller. In desktop computers the controller may be a plug in board, a single integrated circuit on the motherboard, or an external device. In mainframes the controller is usually either a separate device attached to a channel or integrated into the peripheral.

• WP: Memory_controller

• WP: Hardware_acceleration

• some WP: Digital_literacy

• WP: Compute_kernel - a routine compiled for high throughput accelerators (such as GPUs), DSPs or FPGAs, separate from (but used by) a main program. They are sometimes called compute shaders, sharing execution units with vertex shaders and pixel shaders on GPUs, but are not limited to execution on one class of device, or graphics APIs.

DSP

• WP: Digital_signal_processor

• WP: Parallel_processing_(DSP_implementation)

• http://www.dspguru.com/ [29]

• http://diydsp.com/livesite/

CISC

• WP: Complex_instruction_set_computing

x86

• WP: Intel_4004

• WP: X86_assembly_language

• WP: x86

• WP: Intel_8086

• https://github.com/folkertvanheusden/8086-processor-emulation-validation-testset - This test set allows you to verify the correctness of the 8086 implementation you've put in your emulator.

• https://github.com/homebrew8088/8086-PC-Compatible - 8086 PC Compatible project developed in 2021. The Motherboard is built to be generally PC XT/AT compatible. THIS DOES NOT WORK CORRECTLY FOR REFERENCE ONLY

• WP: Intel_8088 - a variant of the Intel 8086. Introduced on June 1, 1979, the 8088 has an eight-bit external data bus instead of the 16-bit bus of the 8086. The 16-bit registers and the one megabyte address range are unchanged, however. In fact, according to the Intel documentation, the 8086 and 8088 have the same execution unit (EU)—only the bus interface unit (BIU) is different. The original IBM PC is based on the 8088, as are its clones.

• homebrew8088.com - 8088 Motherboard project. The Motherboard is built to be generally PC XT compatible. The schematics and source code can be found on my GitHub page. Features: -8088, NEC V20, or NEC V40 Processor -640k RAM (This can be changed) -8 Bit ISA sockets -PC Speaker -USB "Hard Drive" -PS/2 Keyboard -ATX form factor
  • https://github.com/homebrew8088/8088-PC-Compatible - 8088 PC Compatible project developed in 2021. The Motherboard is built to be generally PC XT compatible.

• https://github.com/homebrew8088/Arduino-8088 - SPI library for Arduino to connect to 8088

• https://github.com/homebrew8088/pi86 - Raspberry PI 8088 "hat"

• • WP: Intel_80186
    • https://www.jamieiles.com/80186 [30]

• WP: Intel_80286

• WP: Intel_80386

• WP: IA-32

• WP: X86-64

• https://lobste.rs/s/qtb4xg/x86_amd64_instruction_reference

• https://news.ycombinator.com/item?id=13045558
• https://news.ycombinator.com/item?id=13051137
• https://news.ycombinator.com/item?id=7422703
• http://mainisusuallyafunction.blogspot.co.uk/2014/02/x86-is-turing-complete-with-no-registers.html [31]
• https://code.google.com/p/corkami/wiki/x86oddities
• http://www.cl.cam.ac.uk/~sd601/papers/mov.pdf [32]
• https://news.ycombinator.com/item?id=7680706
• WP: Advanced_Vector_Extensions
  • Future instruction set: AVX-512

• http://0xax.blogspot.co.uk/2014/08/say-hello-to-x64-assembly-part-1.html [33]

• YouTube: x86 Assembly Crash Course
• https://www.youtube.com/watch?v=yOyaJXpAYZQ

• http://www.flatassembler.net/ [34]

• https://news.ycombinator.com/item?id=10704222

• http://www.nasm.us/

• https://stefanheule.com/publications/pldi16-strata

• https://github.com/ghaerr/blink16 - Tiny visual 8086 emulator based on Blink

• https://news.ycombinator.com/item?id=12581427

• WP: Input/output_base_address

• Uncorrectable freedom and security issues on x86 platforms [35]

• https://news.ycombinator.com/item?id=13782477

• https://copy.sh/v86/
  • https://github.com/copy/v86/blob/master/Readme.md

• https://medium.com/@_neerajpal/explained-difference-between-x86-x64-disassembly-49e9678e1ae2

• Speculating the entire x86-64 Instruction Set In Seconds with This One Weird Trick – Can.ac
  • can1357/haruspex: Exploration of x86-64 ISA using speculative execution. - a project attempting to explore and audit the x86-64 instruction set by (ab)using speculative execution and certain low-level performance counters Intel CPUs provide mainly for the identification of undocumented opcodes and deducing the pipeline properties of each instruction

• https://github.com/xoreaxeaxeax/sandsifter - The sandsifter audits x86 processors for hidden instructions and hardware bugs, by systematically generating machine code to search through a processor's instruction set, and monitoring execution for anomalies. Sandsifter has uncovered secret processor instructions from every major vendor; ubiquitous software bugs in disassemblers, assemblers, and emulators; flaws in enterprise hypervisors; and both benign and security-critical hardware bugs in x86 chips. With the multitude of x86 processors in existence, the goal of the tool is to enable users to check their own systems for hidden instructions and bugs.

RISC

• http://cs.stanford.edu/people/eroberts/courses/soco/projects/risc/risccisc/

• WP: Reduced_instruction_set_computing

• WP: Classic_RISC_pipeline

• http://blog.jwhitham.org/2016/02/risc-instruction-sets-i-have-known-and.html [36]

MIPS

• WP: MIPS_instruction_set

• EE Times: MIPS Goes Open Source - [37]

• A modern RISC workstation for a modern (government) era. | Fun with virtualization

SPARC

• WP: SPARC

Power

• WP: Power_Architecture

• WP: IBM_POWER_microprocessors

• WP: IBM_POWER_Instruction_Set_Architecture - older POWER ISA

• WP: PowerPC

• WP: Cell_(microprocessor)

• http://www.tomshardware.com/news/ibm-power9-servers-supercomputers-nvidia,31567.html [38]

Alpha

• WP: DEC_Alpha

ARM

• WP: ARM_architecture

• YouTube: A tour of the ARM architecture and its Linux support - Thomas Petazzoni

RISC-V

• http://riscv.org/
  • WP: RISC-V

• http://gigaom.com/2014/08/19/risc-creator-is-pushing-open-source-chips-for-cloud-computing-and-the-internet-of-things/ [39]

• https://github.com/riscv/riscv-opcodes - enumerates standard RISC-V instruction opcodes and control and status registers. It also contains a script to convert them into several formats (C, Scala, LaTeX).

• RISC-V Assembly Programming - This website contains a set of resources to support learning/teaching assembly programming using the RISC-V ISA. [40]

• lowRISC - producing fully open hardware systems. From the processor core to the development board, our goal is to create a completely open computing eco-system. Our open-source SoC (System-on-a-Chip) designs will be based on the 64-bit RISC-V instruction set architecture. Volume silicon manufacture is planned as is a low-cost development board. There are more details on our plans in these slides from a recent talk [41] [42]

• http://www.lowrisc.org/blog/2017/11/seventh-risc-v-workshop-day-one/ [43]
• http://www.lowrisc.org/blog/2017/11/seventh-risc-v-workshop-day-two/

• PULP Platform - What you will get is a competitive, state-of-the-art 32-bit processor based on the RISC-V architecture, with a rich set of peripherals, and full debug support. At ETH Zurich and Universita’ di Bologna we have put many of the ideas that we have developed through our research on ultra-low-power parallel processing (PULP project) into PULPino. It is the little hip brother to its more serious bigger brothers.
  • http://www.eetimes.com/document.asp?doc_id=1329327 [44]

• https://news.ycombinator.com/item?id=12715531

• https://github.com/cliffordwolf/picorv32

• https://github.com/cnlohr/mini-rv32ima - A tiny C header-only risc-v emulator.

• https://www.crowdsupply.com/onchip/open-v https://news.ycombinator.com/item?id=13017478

• https://news.ycombinator.com/item?id=13065044

• https://news.ycombinator.com/item?id=13381070

• https://www.crowdsupply.com/sifive/hifive1

• https://www.sifive.com/products/hifive-unleashed/ [45]
  • https://www.crowdsupply.com/sifive/hifive-unleashed

• https://fedoraproject.org/wiki/Architectures/RISC-V

• RISC-V from scratch 1: Introduction, toolchain setup, and hello world!
• RISC-V from scratch 2: Hardware layouts, linker scripts, and C runtimes - [46]

• https://github.com/standardsemiconductor/lion - Where Lions Roam: RISC-V on the VELDT [47]

• https://github.com/OpenXiangShan/XiangShan - Open-source high-performance RISC-V processor

Other

• https://www.altera.com/products/processors/overview.html
  • http://free-electrons.com/blog/how-we-found-that-the-linux-nios2-memset-implementation-had-a-bug/ [48]

• WP: SuperH
• http://www.shared-ptr.com/sh_insns.html
• http://j-core.org/ [49]

• https://news.ycombinator.com/item?id=12645661 - 64 bit, 1024 core

• https://github.com/ucb-bar/riscv-boom

• https://news.ycombinator.com/item?id=15342840 - boom2

• https://github.com/pulp-platform/ariane [50]

GPU

• WP: Graphics_processing_unit

• WP: Nvidia_PureVideo

• WP: Unified_Video_Decoder

• http://www.cs.virginia.edu/~gfx/papers/paper.php?paper_id=59 [51]

TPU

• WP: Tensor_processing_unit - are application-specific integrated circuits (ASIC) developed specifically for machine learning. Compared to graphics processing units (which as of 2016 are frequently used for the same tasks), they are designed explicitly for a higher volume of reduced precision computation with higher IOPS per watt (e.g. as little as 8-bit precision), and lack hardware for rasterisation/texture mapping. The chip has been specifically designed for Google's TensorFlow framework, however Google still uses CPUs and GPUs for other machine learning. Other AI accelerator designs are appearing from other vendors also and are aimed at embedded and robotics markets.

The Mill

• The Belt | Mill computing [52]
• The Mill - summary of first three talks
• http://ootbcomp.com/topic/introduction-to-the-mill-cpu-programming-model-2/ [53]

• https://news.ycombinator.com/item?id=7590377

• http://laughtonelectronics.com/Arcana/One-bit%20computer/One-bit%20computer.html [54]

Parallel computing

• WP: Parallel_computing

• WP: Amdahl's_law - a formula which gives the theoretical speedup in latency of the execution of a task at fixed workload that can be expected of a system whose resources are improved. It is named after computer scientist Gene Amdahl, and was presented at the AFIPS Spring Joint Computer Conference in 1967.Amdahl's law is often used in parallel computing to predict the theoretical speedup when using multiple processors. For example, if a program needs 20 hours to complete using a single thread, but a one hour portion of the program cannot be parallelized, therefore only the remaining 19 hours (p = 0.95) of execution time can be parallelized, then regardless of how many threads are devoted to a parallelized execution of this program, the minimum execution time cannot be less than one hour.

• WP: Automatic_parallelization

• WP: Transputer

• WP: SIMD - Single instruction, multiple data (SIMD) is a class of parallel computers in Flynn's taxonomy. It describes computers with multiple processing elements that perform the same operation on multiple data points simultaneously. Such machines exploit data level parallelism, but not concurrency: there are simultaneous (parallel) computations, but only a single process (instruction) at a given moment. SIMD is particularly applicable to common tasks such as adjusting the contrast in a digital image or adjusting the volume of digital audio. Most modern CPU designs include SIMD instructions to improve the performance of multimedia use. Not to be confused with SIMT which utilizes threads.

• zeuxcg.org - Flavors of SIMD - [55]

• https://news.ycombinator.com/item?id=19198758

• WP: OpenMP

• WP: OpenACC

• https://github.com/taichi-dev/taichi - a parallel programming language for high-performance numerical computations. It is embedded in Python, and its just-in-time compiler offloads compute-intensive tasks to multi-core CPUs and massively parallel GPUs.

GPGPU

• WP: General-purpose_computing_on_graphics_processing_units

• http://gpgpu.org/

• https://github.com/Meinersbur/ppcg - Using PPCG to generate CUDA or OpenCL code

• WP: Load-link/store-conditional - LL/SC, sometimes known as load-reserved/store-conditional (LR/SC), are a pair of instructions used in multithreading to achieve synchronization. Load-link returns the current value of a memory location, while a subsequent store-conditional to the same memory location will store a new value only if no updates have occurred to that location since the load-link. Together, this implements a lock-free atomic read-modify-write operation. "Load-linked" is also known as load-link, load-reserved, and load-locked.

CUDA

• WP: CUDA - (Compute Unified Device Architecture) is a parallel computing platform and application programming interface (API) model created by Nvidia. It allows software developers and software engineers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing – an approach termed GPGPU (General-Purpose computing on Graphics Processing Units). The CUDA platform is a software layer that gives direct access to the GPU's virtual instruction set and parallel computational elements, for the execution of compute kernels. The CUDA platform is designed to work with programming languages such as C, C++, and Fortran. This accessibility makes it easier for specialists in parallel programming to use GPU resources, in contrast to prior APIs like Direct3D and OpenGL, which required advanced skills in graphics programming. CUDA-powered GPUs also support programming frameworks such as OpenACC and OpenCL; and HIP by compiling such code to CUDA. When CUDA was first introduced by Nvidia, the name was an acronym for Compute Unified Device Architecture, but Nvidia subsequently dropped the common use of the acronym.

• https://github.com/NVIDIA/libcudacxx - libcu++, the NVIDIA C++ Standard Library, is the C++ Standard Library for your entire system. It provides a heterogeneous implementation of the C++ Standard Library that can be used in and between CPU and GPU code.

• https://github.com/ogiroux/freestanding - A freestanding Standard C++ library for GPU programs.

• Polyhedral parallel code generation for CUDA | ACM Transactions on Architecture and Code Optimization (TACO)

• https://news.ycombinator.com/item?id=13171182

• https://github.com/vosen/ZLUDA - CUDA on Intel GPUs

• https://github.com/jgbit/vuda - a header-only library based on Vulkan that provides a CUDA Runtime API interface for writing GPU-accelerated applications.

• https://github.com/rogerallen/raytracinginoneweekendincuda - The code for the ebook Ray Tracing in One Weekend by Peter Shirley translated to CUDA by Roger Allen. This work is in the public domain.

OpenCL

• WP: OpenCL - a framework for writing programs that execute across heterogeneous platforms consisting of central processing units (CPUs), graphics processing units (GPUs), digital signal processors (DSPs), field-programmable gate arrays (FPGAs) and other processors or hardware accelerators. OpenCL specifies programming languages (based on C99 and C++11) for programming these devices and application programming interfaces (APIs) to control the platform and execute programs on the compute devices. OpenCL provides a standard interface for parallel computing using task- and data-based parallelism.

• Khronos Announces OpenCL 3.0: Hitting the Reset Button on Compute Frameworks -

• https://github.com/Oblomov/clinfo - Print all known information about all available OpenCL platforms and devices in the system

• YouTube: But Mummy I don't want to use CUDA - Open source GPU compute

• WP: SYCL - a higher-level programming model for OpenCL as a single-source domain specific embedded language (DSEL) based on pure C++11 for SYCL 1.2.1 to improve programming productivity. This is a standard developed by Khronos Group, announced in March 2014.

ROCm

• ROCm - the first open-source HPC/Hyperscale-class platform for GPU computing that’s also programming-language independent. We are bringing the UNIX philosophy of choice, minimalism and modular software development to GPU computing. The new ROCm foundation lets you choose or even develop tools and a language run time for your application.ROCm is built for scale; it supports multi-GPU computing in and out of server-node communication through RDMA. It also simplifies the stack when the driver directly incorporates RDMA peer-sync support.ROCm has a rich system run time with the critical features that large-scale application, compiler and language-run-time development requires.HSA Compliant Runtime and Driver for AMD RADEON GPU’s

• AMD libraries

Microcontroller

• WP: Microcontroller - a small computer (SoC) on a single integrated circuit containing a processor core, memory, and programmable input/output peripherals. Program memory in the form of Ferroelectric RAM, NOR flash or OTP ROM is also often included on chip, as well as a typically small amount of RAM. Microcontrollers are designed for embedded applications, in contrast to the microprocessors used in personal computers or other general purpose applications consisting of various discrete chips.

• WP: PIC_microcontroller

• https://news.ycombinator.com/item?id=13902377

• WP: System_on_a_chip

• WP: MPSoC

• https://news.ycombinator.com/item?id=13330034

ASIC

• WP: Application-specific_integrated_circuit

• WP: Application-specific_standard_product

PAL

• WP: Programmable_Array_Logic - a family of programmable logic device semiconductors used to implement logic functions in digital circuits introduced by Monolithic Memories, Inc. (MMI, in March 1978. MMI obtained a registered trademark on the term PAL for use in "Programmable Semiconductor Logic Circuits". The trademark is currently held by Lattice Semiconductor. PAL devices consisted of a small PROM (programmable read-only memory) core and additional output logic used to implement particular desired logic functions with few components.

CPLD

• WP: Complex_programmable_logic_device - CPLD, is a programmable logic device with complexity between that of PALs and FPGAs, and architectural features of both. The main building block of the CPLD is a macrocell, which contains logic implementing disjunctive normal form expressions and more specialized logic operations.

FPGA

• WP: Field-programmable_gate_array

• http://forums.xilinx.com/t5/Embedded-Development-Tools/GPUs-vs-FPGAs/td-p/60112
• https://news.ycombinator.com/item?id=6305113

• An FPGA is an Impoverished Accelerator [56]

• https://github.com/amaranth-lang/amaranth - The Amaranth project provides an open-source toolchain for developing hardware based on synchronous digital logic using the Python programming language, as well as evaluation board definitions, a System on Chip toolkit, and more. It aims to be easy to learn and use, reduce or eliminate common coding mistakes, and simplify the design of complex hardware with reusable components. The Amaranth toolchain consists of the Amaranth hardware definition language, the standard library, the simulator, and the build system, covering all steps of a typical FPGA development workflow. At the same time, it does not restrict the designer’s choice of tools: existing industry-standard (System)Verilog or VHDL code can be integrated into an Amaranth-based design flow, or, conversely, Amaranth code can be integrated into an existing Verilog-based design flow. [57]

• Language & toolchain — Amaranth HDL toolchain 0.4.dev223 documentation

• • https://github.com/csboling/pixtolic

Memory

• WP: Computer_memory

• WP: Create,_read,_update_and_delete

• WP: Computer_data_storage

• WP: Memory_hierarchy

There are four major storage levels:

1. Internal – Processor registers and cache.
2. Main – the system RAM and controller cards.
3. On-line mass storage – Secondary storage.
4. Off-line bulk storage – Tertiary and Off-line storage.

• WP: Memory_storage_density

• WP: Auxiliary_memory

• WP: Main_memory

• WP: Non-volatile_memory

• WP: NVDIMM NVDIMM - a type of random-access memory for computers. Non-volatile memory is memory that retains its contents even when electrical power is removed, for example from an unexpected power loss, system crash, or normal shutdown. "Dual in-line" identifies the memory as using the DIMM package. NVDIMMs improve application performance and system crash recovery time. They enhance solid-state drive (SSD) endurance and reliability. "Non-volatile" products may use volatile memory during normal operation and dump the contents into non-volatile memory if the power fails, using an on-board backup power source. Volatile memory is faster than non-volatile; it is byte-addressable; and it can be written to arbitrarily, without concerns about wear and device lifespan. However, including a second memory to achieve non-volatility (and the on-board backup power source) increases the product cost compared to volatile memory.

• WP: Read-only_memory

• A Vacuum Tube ROM? - [58]

• WP: ECC_memory - Error correction code memory (ECC memory, is a type of computer data storage that uses an error correction code[a] (ECC) to detect and correct n-bit data corruption which occurs in memory. ECC memory is used in most computers where data corruption cannot be tolerated, like industrial control applications, critical databases, and infrastructural memory caches. Typically, ECC memory maintains a memory system immune to single-bit errors: the data that is read from each word is always the same as the data that had been written to it, even if one of the bits actually stored has been flipped to the wrong state. Most non-ECC memory cannot detect errors, although some non-ECC memory with parity support allows detection but not correction.

• ECC RAM on AMD Ryzen 7000 desktop CPUs :: sunshowers [59]

• WP: EEPROM

• 28C256 EEPROM Writer - a simple homemade EEPROM writer that any one can make. The code is written in python. I have included my Kicad Files where you can find the schematics and PCB layout. This was developed to be a cheap alternative for writing 32k EEPROMs for my 8088 projects. You can compile and upload code in the application or just upload a precompiled file. When using the application to compile the JMP code for an 8088 is automatically inserted at address 0x7FF0.
  • https://github.com/homebrew8088/Raspberry-Pi-32k-EEPROM-Programmer - Rapberry Pi 32k EEPROM Programmer.

• WP: Flash_memory

• WP: Volatile_memory

• WP: Delay_line_memory

• WP: Random-access_memory

• WP: Static_random-access_memory

• WP: Dynamic_random-access_memory

• WP: Memory_rank - a set of DRAM chips connected to the same chip select, which are therefore accessed simultaneously. In practice all DRAM chips share all of the other command and control signals, and only the chip select pins for each rank are separate (the data pins are shared across ranks).

• WP: Synchronous_dynamic_random-access_memory

• WP: DDR_SDRAM

• WP: Scratchpad_memory

• WP: Address_space - defines a range of discrete addresses, each of which may correspond to a network host, peripheral device, disk sector, a memory cell or other logical or physical entity.

• WP: Memory_address

• WP: Memory_map

• WP: Memory_management

• WP: Memory_management_unit

• WP: Memory_management_(operating_systems)

• http://www.memorymanagement.org/

• WP: Direct_memory_access

• http://nommu.org/ [60]

• http://nommu.org/memory-faq.txt [61]

• WP: Bank_switching - a technique used in computer design to increase the amount of usable memory beyond the amount directly addressable by the processor. It can be used to configure a system differently at different times; for example, a ROM required to start a system from diskette could be switched out when no longer needed.

• WP: Slab_allocation - a memory management mechanism intended for the efficient memory allocation of kernel objects. It eliminates fragmentation caused by allocations and deallocations. The technique is used to retain allocated memory that contains a data object of a certain type for reuse upon subsequent allocations of objects of the same type. It is analogous to an object pool, but only applies to memory, not other resources. Slab allocation was first introduced in the Solaris 5.4 kernel by Jeff Bonwick. It is now widely used by many Unix and Unix-like operating systems including FreeBSD and Linux.

• WP: Memory_segmentation

• WP: Segmentation_fault

• WP: Memory_protection

• WP: Executable_space_protection - the marking of memory regions as non-executable, such that an attempt to execute machine code in these regions will cause an exception. It makes use of hardware features such as the NX bit, or in some cases software emulation of those features.

• WP: Virtual_memory - a memory management technique that is implemented using both hardware and software. It maps memory addresses used by a program, called virtual addresses, into physical addresses in computer memory.

• WP: Virtual_address_space

• WP: Paging - a memory management scheme by which a computer stores and retrieves data from secondary storage[a] for use in main memory.

• WP: Page_(computer_memory) - memory page, or virtual page is a fixed-length contiguous block of virtual memory, described by a single entry in the page table. It is the smallest unit of data for memory management in a virtual memory operating system.

• WP: Page_table - the data structure used by a virtual memory system in a computer operating system to store the mapping between virtual addresses and physical addresses. Virtual addresses are used by the accessing process, while physical addresses are used by the hardware, or more specifically, by the RAM subsystem.

• What they don't tell you about demand paging in school - offlinemark

• WP: Page_fault - a type of interrupt, called trap, raised by computer hardware when a running program accesses a memory page that is mapped into the virtual address space, but not actually loaded into main memory. When handling a page fault, the operating system generally tries to make the required page accessible at the location in physical memory, or terminates the program in case of an illegal memory access. Contrary to what "fault" might suggest, valid page/hard faults are not errors, and are common and necessary to increase the amount of memory available to programs in any operating system that utilizes virtual memory,

• WP: Thrashing_(computer_science) - occurs when a computer's virtual memory subsystem is in a constant state of paging, rapidly exchanging data in memory for data on disk, to the exclusion of most application-level processing

• WP: Call_stack - a stack data structure that stores information about the active subroutines of a computer program. This kind of stack is also known as an execution stack, control stack, run-time stack, or machine stack, and is often shortened to just "the stack". Although maintenance of the call stack is important for the proper functioning of most software, the details are normally hidden and automatic in high-level programming languages. Many computer instruction sets provide special instructions for manipulating stacks.

A call stack is used for several related purposes, but the main reason for having one is to keep track of the point to which each active subroutine should return control when it finishes executing.

• WP: Stack-based_memory_allocation - because data is added and removed to the stack in a last-in-first-out manner, stack-based memory allocation is very simple and typically faster than heap-based memory allocation (also known as dynamic memory allocation).

• http://jvns.ca/blog/2016/03/01/a-few-notes-on-the-stack/ [62]

• http://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap/80113#80113

• https://news.ycombinator.com/item?id=6848415

• https://news.ycombinator.com/item?id=6879212

• WP: Heap_(data_structure)

• WP: Non-uniform_memory_access - a computer memory design used in multiprocessing, where the memory access time depends on the memory location relative to the processor. Under NUMA, a processor can access its own local memory faster than non-local memory (memory local to another processor or memory shared between processors). The benefits of NUMA are limited to particular workloads, notably on servers where the data are often associated strongly with certain tasks or users.

• http://linux.die.net/man/8/numactl

• WP: Pointer_(computer_programming) - a programming language object, whose value refers to (or "points to") another value stored elsewhere in the computer memory using its address. A pointer references a location in memory, and obtaining the value stored at that location is known as dereferencing the pointer.

• r/learnprogramming: What's the point of pointers?
  • http://www.reddit.com/r/learnprogramming/comments/1ehg69/

• https://www.cs.umd.edu/class/sum2003/cmsc311/Notes/BitOp/pointer.html

• WP: Pointer_aliasing - refers to the situation where the same memory location can be accessed using different names.

• WP: Smart_pointer

• https://lwn.net/Articles/219983/

• Cheat Engine

• https://github.com/Hexorg/Rampage - Linux memory scanner/editor written in python. Similar to scanmem, artmoney, or cheat engine in concept. Allows you to find values of programs in RAM and then change them. Made to be used inside of a python shell. You don't need to know python to use this, but it can help with some automation.

• WP: Test_and_test-and-set - the test-and-set CPU instruction is used to implement mutual exclusion in multiprocessor environments. Although a correct lock can be implemented with test-and-set, it can lead to resource contention in busy lock (caused by bus locking and cache invalidation when test-and-set operation needs to access memory atomically).To lower the overhead a more elaborate locking protocol test and test-and-set is used. The main idea is to reduce writeback that can create resource contention when two separate threads want the same lock. If n threads are competing for the lock, they will attempt to acquire it as soon as it is released if only using test and set, causing each thread to invalidate the lock flag, meaning it must be propagated through the cache of the remaining processors n times, before any one thread may safely read it. By adding the check-yield step, only the first thread of execution to notice the lock is free will attempt to obtain it, eliminating the writeback.

Storage

See Storage

• WP: Persistence_(computer_science)

Interrupts

• WP: Interrupt - a signal to the processor emitted by hardware or software indicating an event that needs immediate attention. An interrupt alerts the processor to a high-priority condition requiring the interruption of the current code the processor is executing. The processor responds by suspending its current activities, saving its state, and executing a function called an interrupt handler (or an interrupt service routine, ISR) to deal with the event. This interruption is temporary, and, after the interrupt handler finishes, the processor resumes normal activities.

• WP: Interrupt_request_(PC_architecture) - or IRQ, is a hardware signal sent to the processor that temporarily stops a running program and allows a special program, an interrupt handler, to run instead. Hardware interrupts are used to handle events such as receiving data from a modem or network card, key presses, or mouse movements.

Interrupt lines are often identified by an index with the format of IRQ followed by a number. For example, on the Intel 8259 family of PICs there are eight interrupt inputs commonly referred to as IRQ0 through IRQ7. In x86 based computer systems that use two of these PICs, the combined set of lines are referred to as IRQ0 through IRQ15. Technically these lines are named IR0 through IR7, and the lines on the ISA bus to which they were historically attached are named IRQ0 through IRQ15. Newer x86 systems integrate an Advanced Programmable Interrupt Controller (APIC) that conforms to the Intel APIC Architecture. These APICs support a programming interface for up to 255 physical hardware IRQ lines per APIC, with a typical system implementing support for only around 24 total hardware lines.

• WP: Interrupt_handler - also known as an interrupt service routine or ISR, a callback function in microcontroller firmware, an operating system or a device driver, whose execution is triggered by the reception of an interrupt. In general, interrupts and their handlers are used to handle high-priority conditions that require the interruption of the current code the processor is executing.

Interrupt handlers have a multitude of functions, which vary based on the reason the interrupt was generated and the speed at which the interrupt handler completes its task. For example, pressing a key on a computer keyboard, or moving the mouse, triggers interrupts that call interrupt handlers which read the key, or the mouse's position, and copy the associated information into the computer's memory. An interrupt handler is a low-level counterpart of event handlers. These handlers are initiated by either hardware interrupts or interrupt instructions in software, and are used for servicing hardware devices and transitions between protected modes of operation such as system calls.

• WP: Exception_handling - the process of responding to the occurrence, during computation, of exceptions – anomalous or exceptional conditions requiring special processing – often changing the normal flow of program execution. It is provided by specialized programming language constructs or computer hardware mechanisms.

• WP: Programmable_Interrupt_Controller

• WP: Advanced_Programmable_Interrupt_Controller

• WP: Message_Signaled_Interrupts - an alternative in-band method of signaling an interrupt, using special in-band messages to replace traditional out-of-band assertion of dedicated interrupt lines. While more complex to implement in a device, message signaled interrupts have some significant advantages over pin-based out-of-band interrupt signaling. Message signaled interrupts are supported in PCI bus since its version 2.2, and in later available PCI Express bus. Some non-PCI architectures also use message signaled interrupts.

• https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/PCI/MSI-HOWTO.txt?id=HEAD

• http://stackoverflow.com/questions/10894702/diff-between-io-apic-level-and-pci-msi-x

• https://github.com/Irqbalance/irqbalance - a daemon to help balance the cpu load generated by interrupts across all of a systems cpus. Irqbalance identifies the highest volume interrupt sources, and isolates them to a single unique cpu, so that load is spread as much as possible over an entire processor set, while minimizing cache miss rates for irq handlers.

Other

• https://news.ycombinator.com/item?id=8773114

Security

• WP: CPU_modes

• WP: Protection_ring

• WP: Capability-based_security

Runtime

• WP: Computing_platform - or digital platform or software platform is an environment in which a piece of software is executed. It may be the hardware or the operating system (OS), even a web browser and associated application programming interfaces, or other underlying software, as long as the program code is executed with it. Computing platforms have different abstraction levels, including a computer architecture, an OS, or runtime libraries. A computing platform is the stage on which computer programs can run. A platform can be seen both as a constraint on the software development process, in that different platforms provide different functionality and restrictions; and as an assistant to the development process, in that they provide low-level functionality ready-made. For example, an OS may be a platform that abstracts the underlying differences in hardware and provides a generic command for saving files or accessing the network.

• WP: Runtime_system - or runtime environment is a sub-system that exists both in the computer where a program is created, as well as in the computers where the program is intended to be run. The name comes from the compile time and runtime division from compiled languages, which similarly distinguishes the computer processes involved in the creation of a program (compilation) and its execution in the target machine (the run time). Most programming languages have some form of runtime system that provides an environment in which programs run. This environment may address a number of issues including the management of application memory, how the program accesses variables, mechanisms for passing parameters between procedures, interfacing with the operating system, and otherwise. The compiler makes assumptions depending on the specific runtime system to generate correct code. Typically the runtime system will have some responsibility for setting up and managing the stack and heap, and may include features such as garbage collection, threads or other dynamic features built into the language.

• WP: Interpreted_language

• WP: Interpreter_(computing)

• WP: Scripting_language

• WP: Read-eval-print_loop - REPL, also termed an interactive toplevel or language shell, is a simple interactive computer programming environment that takes single user inputs, executes them, and returns the result to the user; a program written in a REPL environment is executed piecewise. The term usually refers to programming interfaces similar to the classic Lisp machine interactive environment. Common examples include command-line shells and similar environments for programming languages, and the technique is very characteristic of scripting languages.

• WP: Green_threads - threads that are scheduled by a runtime library or virtual machine (VM) instead of natively by the underlying operating system. Green threads emulate multithreaded environments without relying on any native OS capabilities, and they are managed in user space instead of kernel space, enabling them to work in environments that do not have native thread support.

Programming

See also Languages, Development, Maths#Software 2

• WP: Computer_programming

Assembly

• WP: Assembly_language - Human-readable instructions to the assembler + data bytes + operators
• WP: Second-generation_programming_language - A generational way to categorize assembly languages.
• WP: Automatic_programming - A type of computer programming that allows higher abstraction levels.

Learning Assembly

• Programming With Ones and Zeros [63]
• https://github.com/FFmpeg/asm-lessons - FFmpeg School of Assembly Language
• Programming from the Ground Up Book [64]
  • http://ftp.igh.cnrs.fr/pub/nongnu//pgubook/ProgrammingGroundUp-1-0-lettersize.pdf

Assembly Tools

• Rappel - Assembly REPL [65]
• https://github.com/osandov/asmase - A REPL for assembly language using an LLVM backend
• yasp - A web-based assembler development environment [66]

Assembly Programming Challenges

• http://www.corewars.org/
• http://juhakiili.com/box256/manual [67]
• http://blog.codinghorror.com/heres-the-programming-game-you-never-asked-for/ [68]
• https://microcorruption.com/login
• https://www.stockfighter.io/
• http://boundvariable.org/task.shtml
• http://www.zachtronics.com/the-codex-of-alchemical-engineering/
• http://laughtonelectronics.com/Arcana/One-bit%20computer/One-bit%20computer.html [69]

= 6502 Assembly

• WP: MOS_Technology_6502
• MOnSter 6502 [70]
  • YouTube: MOnSter 6502 Update #1
• Easy 6502
• http://www.visual6502.org/ [71]
• Visual 6502 Remix
  • A new cycle-stepped 6502 CPU emulator [72]
• https://github.com/gregjames/Sim2600 - Atari 2600 transistor-level simulation
• https://github.com/klynch71/6502sim - Near gate-level Verilog simulation of the 6502
• The 100 MHz 6502 · e-basteln [73]

Reverse Engineering & Disassembly

• WP: Disassembler
• A Gentle Primer on Reverse Engineering [74]
• http://www.capstone-engine.org/
• https://github.com/zyantific/zyan-disassembler-engine [75]
• https://panopticon.re/ [76]

Programming Concepts & Theory

• WP: Endianness
• Lexical differential highlighting instead of syntax highlighting
• Epigrams in Programming by Alan J. Perlis [77]
• Bumper-Sticker Computer Science (1985) [78]
• WP: The_Elements_of_Programming_Style
• https://github.com/droogans/unmaintainable-code
• https://github.com/dwmkerr/hacker-laws#kernighans-law

Software Development & Programming Practices

• WP: Dynamic_programming_language
• Livecoding.tv - Livestreaming for coders
• WP: Self-hosting_(compilers) - the use of a program as part of the toolchain or operating system that produces new versions of that same program—for example, a compiler that can compile its own source code. Self-hosting software is commonplace on personal computers and larger systems. Other programs that are typically self-hosting include kernels, assemblers, command-line interpreters and revision control software.
• WP: Program_lifecycle_phase
• WP: Execution_model

Programming Cheats & References

• cheat.sh/:firstpage
  • https://github.com/chubin/cheat.sh
• https://github.com/gleitz/howdoi - Instant coding answers via CLI

Programming Philosophy

• The Three Virtues of a GREAT Programmer by Larry Wall
  • Laziness, Impatience, Hubris
• 2nd State of the Onion

Miscellaneous

• https://github.com/cjbarber/ToolsOfTheTrade
• StackOverflow: Absolute Beginner's Guide to Bit Shifting?
• The genesis of a perfect programming language
• Session: It's Not You, It's Them: Why Programming Languages Are Hard To Teach
• What the Obama IT team teaches us about polyglot programming
• https://wg21.link - ISO Working Group document short URLs

Syntax

• WP: Syntax_(programming_languages)

• WP: Lexical_grammar - the process of converting a sequence of characters (such as in a computer program or web page) into a sequence of tokens (strings with an identified "meaning"). A program that performs lexical analysis may be called a lexer, tokenizer, or scanner (though "scanner" is also used to refer to the first stage of a lexer). Such a lexer is generally combined with a parser, which together analyze the syntax of programming languages, web pages, and so forth.

For instance, the lexical grammar for many programming languages specifies that a string literal starts with a " character and continues until a matching " is found (escaping makes this more complicated), that an identifier is an alphanumeric sequence (letters and digits, usually also allowing underscores, and disallowing initial digits), and that an integer literal is a sequence of digits. So in the following character sequence "abc" xyz1 23 the tokens are string, identifier and number (plus whitespace tokens) because the space character terminates the sequence of characters forming the identifier. Further, certain sequences are categorized as keywords – these generally have the same form as identifiers (usually alphabetical words), but are categorized separately; formally they have a different token type.

• WP: Lexical_analysis - the process of converting a sequence of characters (such as in a computer program or web page) into a sequence of tokens (strings with an identified "meaning"). A program that performs lexical analysis may be called a lexer, tokenizer, or scanner (though "scanner" is also used to refer to the first stage of a lexer). Such a lexer is generally combined with a parser, which together analyze the syntax of programming languages, web pages, and so forth.

• WP: Language_construct - a syntactically allowable part of a program that may be formed from one or more lexical tokens in accordance with the rules of a programming language. The term "language construct" is often used as a synonym for control structure, and should not be confused with a function.

• WP: Category:Programming_constructs

• WP: Syntactic_noise - syntax within a programming language that makes the programming language more difficult to read and understand for humans. It fills the language with excessive clutter that makes it a hassle to write code. Syntactic noise is considered to be the opposite of syntactic sugar, which is syntax that makes a programming language more readable and enjoyable for the programmer.

• SyntacticNoise

• WP: Catalan_number - a sequence of natural numbers that occur in various counting problems, often involving recursively-defined objects. They are named after the Belgian mathematician Eugène Charles Catalan (1814–1894).

Using zero-based numbering, the nth Catalan number is given directly in terms of binomial coefficients. The first Catalan numbers for n = 0, 1, 2, 3, … are: 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190, 6564120420, 24466267020, 91482563640, 343059613650, 1289904147324, 4861946401452, … (sequence A000108 in OEIS).

• WP: Dyck_language - the language consisting of balanced strings of square brackets [ and ]. It is important in the parsing of expressions that must have a correctly nested sequence of brackets, such as arithmetic or algebraic expressions.

• http://interactivepython.org/runestone/static/pythonds/BasicDS/SimpleBalancedParentheses.html

• WP: Reserved_word - also known as a reserved identifier is a word that cannot be used as an identifier, such as the name of a variable, function, or label – it is "reserved from use". This is a syntactic definition, and a reserved word may have no meaning.

A closely related and often conflated notion is a keyword which is a word with special meaning in a particular context. This is a semantic definition. By contrast, names in a standard library but not built into the language are not considered reserved words or keywords. The terms "reserved word" and "keyword" are often used interchangeably – one may say that a reserved word is "reserved for use as a keyword" – and formal use varies from language to language; for this article we distinguish as above.

In general reserved words and keywords need not coincide, but in most modern languages keywords are a subset of reserved words, as this makes parsing easier, since keywords cannot be confused with identifiers. In some languages, like C or Python, reserved words and keywords coincide, while in other languages, like Java, all keywords are reserved words, but some reserved words are not keywords – these are "reserved for future use". In yet other languages, such as ALGOL and PL/I there are keywords but no reserved words, with keywords being distinguished from identifiers by other means.

• http://crasseux.com/books/ctutorial/Reserved-words-in-C.html

• Why Does "=" Mean Assignment? - [79]

• WP: Identifier#In_computer_languages - are tokens (also called symbols) which name language entities. Some of the kinds of entities an identifier might denote include variables, types, labels, subroutines, and packages.

• WP: Declaration_(computer_programming) - specifies properties of an identifier: it declares what a word (identifier) means. Declarations are most commonly used for functions, variables, constants, and classes, but can also be used for other entities such as enumerations and type definitions. Beyond the name (the identifier itself) and the kind of entity (function, variable, etc.), declarations typically specify the data type (for variables and constants), or the type signature (for functions); types may also include dimensions, such as for arrays. A declaration is used to announce the existence of the entity to the compiler; this is important in those strongly typed languages that require functions, variables, and constants, and their types to be specified with a declaration before use, and is used in forward declaration. The term "declaration" is frequently contrasted with the term "definition", but meaning and usage varies significantly between languages

• WP: Initialization_(programming) - the assignment of an initial value for a data object or variable. The manner in which initialization is performed depends on programming language, as well as type, storage class, etc., of an object to be initialized. Programming constructs which perform initialization are typically called initializers and initializer lists. Initialization is distinct from (and preceded by) declaration, although the two can sometimes be conflated in practice. The complement of initialization is finalization, which is primarily used for objects, but not variables. Initialization is done either by statically embedding the value at compile time, or else by assignment at run time.

• WP: Finalization - the process of preparing an object for deallocation; strictly speaking, finalization is all parts of object destruction until memory deallocation itself. Finalization is formally complementary to initialization, which is the part of object creation that follows allocation, but differs significantly in practice

• WP: Directive_(programming) - a language construct that specifies how a compiler (or assembler or interpreter) should process its input. Directives are not part of the language proper – they are not part of the grammar, and may vary from compiler to compiler – but instead function either as an in-band form of a command-line option, specifying compiler behavior, or are processed by a preprocessor. In some cases directives specify global behavior, while in other cases they only affect a local section, such as a block of programming code. In some cases, such as some C pragmas, directives are optional compiler hints, and may be ignored, but normally they are prescriptive, and must be followed. However, a directive does not perform any action in the language itself, but rather only a change in the behavior of the compiler.

This term could be used to refer to proprietary third party tags and commands (or markup) embedded in code that result in additional executable processing that extend the existing compiler, assembler and language constructs present in the development environment. The term "directive" is also applied in a variety of ways that are similar to the term command.

• WP: First-class_citizen - In programming language design, a first-class citizen (also type, object, entity, or value) in a given programming language is an entity which supports all the operations generally available to other entities. These operations typically include being passed as an argument, returned from a function, and assigned to a variable.

• WP: Free-form_language

• WP: Indentation_style - a convention governing the indentation of blocks of code to convey the program's structure. This article largely addresses the free-form languages, such as C programming language and its descendants, but can be (and frequently is) applied to most other programming languages (especially those in the curly bracket family), where whitespace is otherwise insignificant. Indent style is just one aspect of programming style.

• WP: Syntactic_sugar - syntax within a programming language that is designed to make things easier to read or to express. It makes the language "sweeter" for human use: things can be expressed more clearly, more concisely, or in an alternative style that some may prefer.

For example, many programming languages provide special syntax for referencing and updating array elements. Abstractly, an array reference is a procedure of two arguments: an array and a subscript vector, which could be expressed as get_array(Array, vector(i,j)). Instead, many languages provide syntax like Array[i,j]. Similarly an array element update is a procedure of three arguments, something like set_array(Array, vector(i,j), value), but many languages provide syntax like Array[i,j] = value.

Specifically, a construct in a language is called syntactic sugar if it can be removed from the language without any effect on what the language can do: functionality and expressive power will remain the same. Language processors, including compilers, static analyzers, and the like, often expand sugared constructs into more fundamental constructs before processing, a process sometimes called "desugaring".

• WP: Lex_(software)

• WP: Flex_(lexical_analyser_generator)

• WP: Syntax_analysis#Programming_languages

• WP: Backus–Naur_Form - BNF (Backus Normal Form or Backus–Naur Form) is one of the two main notation techniques for context-free grammars, often used to describe the syntax of languages used in computing, such as computer programming languages, document formats, instruction sets and communication protocols; the other main technique for writing context-free grammars is the van Wijngaarden form. They are applied wherever exact descriptions of languages are needed: for instance, in official language specifications, in manuals, and in textbooks on programming language theory. Many extensions and variants of the original Backus–Naur notation are used; some are exactly defined, including Extended Backus–Naur Form (EBNF) and Augmented Backus–Naur Form (ABNF).

• WP: Extended_Backus%E2%80%93Naur_Form

• Obsidian is now free for work - Obsidian

• RFC 4234 - Augmented BNF for Syntax Specifications: ABNF - Internet technical specifications often need to define a formal syntax. Over the years, a modified version of Backus-Naur Form (BNF), called Augmented BNF (ABNF), has been popular among many Internet specifications. The current specification documents ABNF. It balances compactness and simplicity, with reasonable representational power. The differences between standard BNF and ABNF involve naming rules, repetition, alternatives, order- independence, and value ranges. This specification also supplies additional rule definitions and encoding for a core lexical analyzer of the type common to several Internet specifications.

• WP: Augmented_Backus%E2%80%93Naur_form - a metalanguage based on Backus–Naur form (BNF, but consisting of its own syntax and derivation rules. The motive principle for ABNF is to describe a formal system of a language to be used as a bidirectional communications protocol. It is defined by Internet Standard 68 ("STD 68", type case sic), which as of December 2010 was RFC 5234, and it often serves as the definition language for IETF communication protocols.

• WP: Van_Wijngaarden_grammar

• WP: Parsing_expression_grammar - or PEG, is a type of analytic formal grammar, i.e. it describes a formal language in terms of a set of rules for recognizing strings in the language. The formalism was introduced by Bryan Ford in 2004 and is closely related to the family of top-down parsing languages introduced in the early 1970s. Syntactically, PEGs also look similar to context-free grammars (CFGs), but they have a different interpretation: the choice operator selects the first match in PEG, while it is ambiguous in CFG. This is closer to how string recognition tends to be done in practice, e.g. by a recursive descent parser. Unlike CFGs, PEGs cannot be ambiguous; if a string parses, it has exactly one valid parse tree. It is conjectured that there exist context-free languages that cannot be parsed by a PEG, but this is not yet proven. PEGs are well-suited to parsing computer languages, but not natural languages where their performance is comparable to general CFG algorithms such as the Earley algorithm

Compared to pure regular expressions (i.e. without back-references), PEGs are strictly more powerful, but require significantly more memory. For example, a regular expression inherently cannot find an arbitrary number of matched pairs of parentheses, because it is not recursive, but a PEG can. However, a PEG will require an amount of memory proportional to the length of the input, while a regular expression matcher will require only a constant amount of memory.

• The Packrat Parsing and Parsing Expression Grammars Page

• WP: Recursive_descent_parser

• WP: Pratt_parser

• https://tdop.github.io/
• http://javascript.crockford.com/tdop/tdop.html
• http://l-lang.org/blog/TDOP---Pratt-parser-in-pictures/
• https://news.ycombinator.com/item?id=2344837

Data structures

• WP: Data_structure

• http://opendatastructures.org/ [80]
• https://news.ycombinator.com/item?id=12758176

• WP: Plain_old_data_structure

• PDF: The Periodic Table of Data Structures [81]

• http://www.cs.usfca.edu/~galles/visualization/Algorithms.html [82]

• WP: Set_data_structure

• WP: Abstract_semantic_graph

• WP: Bit_string

Array

• WP: Array_data_structure

• WP: Array_data_type

• WP: Associative_array

• WP: Lookup_table - an array that replaces runtime computation with a simpler array indexing operation. The savings in terms of processing time can be significant, since retrieving a value from memory is often faster than undergoing an "expensive" computation or input/output operation. The tables may be precalculated and stored in static program storage, calculated (or "pre-fetched") as part of a program's initialization phase (memoization), or even stored in hardware in application-specific platforms. Lookup tables are also used extensively to validate input values by matching against a list of valid (or invalid) items in an array and, in some programming languages, may include pointer functions (or offsets to labels) to process the matching input. FPGAs also make extensive use of reconfigurable, hardware-implemented, lookup tables to provide programmable hardware functionality.

• WP: Hash_table

Tree

• WP: Tree_(data_structure)

• WP: Tree_traversal

• https://eugene-eeo.github.io/blog/tree-traversal-storage.html [83]

• WP: Binary_tree

• WP: Binary_search_tree

B-tree

• WP: B-tree

• Stryku.pl - A journey to searching Have I Been Pwned database in 49μs (C++) - [84]

Radix tree

• WP: Radix_tree - (also radix trie or compact prefix tree) is a data structure that represents a space-optimized trie (prefix tree) in which each node that is the only child is merged with its parent. The result is that the number of children of every internal node is at most the radix r of the radix tree, where r is a positive integer and a power x of 2, having x ≥ 1. Unlike regular trees, edges can be labeled with sequences of elements as well as single elements. This makes radix trees much more efficient for small sets (especially if the strings are long) and for sets of strings that share long prefixes.

• https://github.com/fanf2/qp

to sort

• WP: Rope_%28data_structure%29

• http://randomcomputation.blogspot.co.uk/2013/08/blog-post.html

• https://github.com/antirez/rax
  • https://news.ycombinator.com/item?id=101987

• http://courses.csail.mit.edu/6.851/spring12/

• http://www.careerride.com/c-arrays-and-linked-list.aspx

The difference between arrays and linked lists are:

- Arrays are linear data structures. Linked lists are linear and non-linear data structures. - Linked lists are linear for accessing, and non-linear for storing in memory - Array has homogenous values. And each element is independent of each other positions. Each node in the linked list is connected with its previous node which is a pointer to the node. - Array elements can be modified easily by identifying the index value. It is a complex process for modifying the node in a linked list. - Array elements can not be added, deleted once it is declared. The nodes in the linked list can be added and deleted from the list.

• http://www.infoq.com/presentations/Data-Structures

• Data Structures for Text Sequences [85]

• https://www.snellman.net/blog/archive/2016-12-13-ring-buffers/ [86]

• http://algoviz.org/OpenDSA/

• http://www.brpreiss.com/books/opus5/html/book.html

• http://okasaki.blogspot.ru/2008/02/ten-years-of-purely-functional-data.html

• http://www.xanadu.com/zigzag/
• YouTube: Ted Nelson on Zigzag data structures - relationship vector, hyperthoginal

• https://news.ycombinator.com/item?id=13263038

• Half-Edge Data Structures [87]

• WP: Semaphore_%28programming%29

• https://news.ycombinator.com/item?id=8761539

• WP: Continuation
• WP: Continuation-passing_style
• http://matt.might.net/articles/cps-conversion/

• http://beautifulracket.com/explainer/continuations.html

• (call/cc this-class) -

• Understanding the Type of call/cc · Leandro Facchinetti - [88]

• WP: Stack_(abstract_data_type)

• WP: Stack_register

• WP: Symbol_table

• http://kukuruku.co/hub/cpp/lock-free-data-structures-the-evolution-of-a-stack [89]

• "Visualizing Persistent Data Structures" by Dann Toliver

Mutability

• WP: Persistent_data_structure

• http://davesquared.net/2013/03/reasoning-and-mutability.html

Evaluation

• WP: Evaluation

• WP: Expression_(mathematics)

• WP: Expression_(computer_science)

An expression evaluates to a value. A statement does something.

x = 1
y = x + 1     # an expression
print y       # a statement, prints 2

• WP: Statement_(programming)

• Heuristic definition of an expression [90]

• WP: Evaluation_strategy

• WP: Expression-oriented_programming_language

• WP: Referential_transparency_(computer_science)

• WP: Side_effect_(computer_science)

• WP: Information_hiding

• WP: Conditional_(computer_programming)

• WP: Strict_function - in the denotational semantics of programming languages is a function f where f\left(\perp\right) = \perp. The entity \perp, called bottom, denotes an expression which does not return a normal value, either because it loops endlessly or because it aborts due to an error such as division by zero. A function which is not strict is called non-strict. A strict programming language is one in which user-defined functions are always strict.

Intuitively, non-strict functions correspond to control structures. Operationally, a strict function is one which always evaluates its argument; a non-strict function is one which may not evaluate some of its arguments. Functions having more than one parameter may be strict or non-strict in each parameter independently, as well as jointly strict in several parameters simultaneously.

• WP: Non-strict_programming_language - A strict programming language is one in which only strict functions (functions whose parameters must be evaluated completely before they may be called) may be defined by the user. A non-strict programming language allows the user to define non-strict functions, and hence may allow lazy evaluation.

• WP: Control_flow

• WP: Scope_(computer_science)
• http://stackoverflow.com/questions/6441218/can-a-local-variables-memory-be-accessed-outside-its-scope/6445794#6445794

• WP: Scope_resolution_operator - helps to identify and specify the context to which an identifier refers, particularly by specifying a namespace or class. The specific uses vary across different programming languages with the notions of scoping. In many languages, the scope resolution operator is written ::.

• WP: Hooking

• WP: Rewriting

• WP: Recursion_(computer_science)
• How recursion got into programming: a comedy of errors [91]
• WP: Modulo_operation

• Vimeo: Impossible Programs - Scottish Ruby Conf

Operators

• WP: Operator_(programming) - constructs which behave generally like functions, but which differ syntactically or semantically from usual functions. Common simple examples include arithmetic (addition with +, comparison with >) and logical operations (such as AND or &&). More involved examples include assignment (usually = or :=), field access in a record or object (usually .), and the scope resolution operator (often ::). Languages usually define a set of built-in operators, and in some cases allow user-defined operators.

• WP: Operators_in_C_and_C%2B%2B

Functions

See Maths

• WP: Subroutine or function is a sequence of program instructions that perform a specific task, packaged as a unit. This unit can then be used in programs wherever that particular task should be performed. Subprograms may be defined within programs, or separately in libraries that can be used by multiple programs. In different programming languages a subroutine may be called a procedure, a function, a routine, a method, or a subprogram. The generic term callable unit is sometimes used.

• WP: Closure_(computer_science) - also lexical closures or function closures are a technique for implementing lexically scoped name binding in languages with first-class functions. Operationally, a closure is a record storing a function[a] together with an environment: a mapping associating each free variable of the function (variables that are used locally, but defined in an enclosing scope) with the value or storage location to which the name was bound when the closure was created. A closure—unlike a plain function—allows the function to access those captured variables through the closure's reference to them, even when the function is invoked outside their scope.

• What's a Closure?

• WP: Currying

• WP: Call_site - a call site of a function or subroutine is the location (line of code) where the function is called (or may be called, through dynamic dispatch). A call site is where zero or more arguments are passed to the function, and zero or more return values are received.

• Push Ifs Up And Fors Down - A short note on two related rules of thumb. [92]

• WP: Language_binding - an application programming interface (API) that provides glue code specifically made to allow a programming language to use a foreign library or operating system service (one that is not native to that language).

• WP: Foreign_function_interface

• WP: Wrapper_function - a subroutine in a software library or a computer program whose main purpose is to call a second subroutine or a system call with little or no additional computation. Wrapper functions are used to make writing computer programs easier by abstracting away the details of a subroutine's underlying implementation.

• WP: Wrapper_library - or library wrappers) consist of a thin layer of code (a "shim") which translates a library's existing interface into a compatible interface.

• WP: Anonymous_function - also function literal or lambda abstraction is a function definition that is not bound to an identifier. Anonymous functions are often: arguments being passed to higher-order functions, or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfill the same role for the function type as literals do for other data types.

• WP: Function_type - the type of a variable or parameter to which a function has or can be assigned, or an argument or result type of a higher-order function taking or returning a function.

• WP: Trailing_return_type

• WP: Function_prototype - or function interface is a declaration of a function that specifies the function's name and type signature (arity, parameter types, and return type), but omits the function body. The term is particularly used in C and C++. While a function definition specifies how the function does what it does (the "implementation"), a function prototype merely specifies its interface, i.e. what data types go in and come out of it.

In a prototype, parameter names are optional (and in C/C++ have function prototype scope, meaning their scope ends at the end of the prototype), however, the type is necessary along with all modifiers (e.g. if it is a pointer or a const parameter). In object-oriented programming, interfaces and abstract methods serve much the same purpose.

• WP: Function_objects - allows an object to be invoked or called as if it were an ordinary function, usually with the same syntax (a function parameter that can also be a function).

• http://journal.stuffwithstuff.com/2013/08/26/what-is-open-recursion/ [93]

• WP: Callback_(computer_science) - a piece of executable code that is passed as an argument to other code, which is expected to call back (execute) the argument at some convenient time. The invocation may be immediate as in a synchronous callback, or it might happen at a later time as in an asynchronous callback. In all cases, the intention is to specify a function or subroutine as an entity that is, depending on the language, more or less similar to a variable. Programming languages support callbacks in different ways, often implementing them with subroutines, lambda expressions, blocks, or function pointers.

• WP: Tail_call - a subroutine call performed as the final action of a procedure. If a tail call might lead to the same subroutine being called again later in the call chain, the subroutine is said to be tail-recursive, which is a special case of recursion. Tail recursion (or tail-end recursion) is particularly useful, and often easy to handle in implementations.

• https://medium.com/binary-dreams/from-java-to-scala-tail-recursion-a6acdd71a94d

• WP: Function_pointer - Instead of referring to data values, a function pointer points to executable code within memory. When dereferenced, a function pointer can be used to invoke the function it points to and pass it arguments just like a normal function call. Such an invocation is also known as an "indirect" call, because the function is being invoked indirectly through a variable instead of directly through a fixed name or address. Function pointers can be used to simplify code by providing a simple way to select a function to execute based on run-time values.

• WP: Funarg_problem - refers to the difficulty in implementing first-class functions (functions as first-class objects) in programming language implementations so as to use stack-based memory allocation of the functions. The difficulty only arises if the body of a nested function refers directly (i.e., not via argument passing) to identifiers defined in the environment in which the function is defined, but not in the environment of the function call. To summarize the discussion below, two standard resolutions are to either forbid such references or to create closures.

• WP: Inline_expansion - or inlining, is a manual or compiler optimization that replaces a function call site with the body of the called function. Inline expansion is similar to macro expansion, but occurs during compilation, without changing the source code (the text), while macro expansion occurs prior to compilation, and results in different text that is then processed by the compiler. Inlining is an important optimization, but has complicated effects on performance. As a rule of thumb, some inlining will improve speed at very minor cost of space, but excess inlining will hurt speed, due to inlined code consuming too much of the instruction cache, and also cost significant space.

• WP: Defunctionalization - refers to a compile-time transformation which eliminates higher-order functions, replacing them by a single first-order apply function. The technique was first described by John C. Reynolds in his 1972 paper, "Definitional Interpreters for Higher-Order Programming Languages". Reynolds' observation was that a given program contains only finitely many function abstractions, so that each can be assigned (and replaced by) a unique identifier. Every function application within the program is then replaced by a call to the apply function with the function identifier as the first argument. The apply function's only job is to dispatch on this first argument, and then perform the instructions denoted by the function identifier on the remaining arguments.

• PDF: Generating Functions - this book is about generating functions and some of their uses indiscrete mathematics. [94]

• From callback to (Future -> Functor -> Monad) [95]

• https://dspace.mit.edu/bitstream/handle/1721.1/6090/AIM-378.pdf?sequence=2&isAllowed=y [96]

• philosophy of mind - Am I a monad? Are we a monad? (Software and hardware) - Philosophy Stack Exchange - [97]

Hash function

• WP: Hash_function - any function that can be used to map data of arbitrary size to data of fixed size. The values returned by a hash function are called hash values, hash codes, hash sums, or simply hashes. One use is a data structure called a hash table, widely used in computer software for rapid data lookup. Hash functions accelerate table or database lookup by detecting duplicated records in a large file. An example is finding similar stretches in DNA sequences. They are also useful in cryptography.
  • http://programmers.stackexchange.com/questions/49550/which-hashing-algorithm-is-best-for-uniqueness-and-speed/145633#145633
  • http://www.hashids.org/
  • http://floodyberry.com/noncryptohashzoo/

• xxHash - Extremely fast non-cryptographic hash algorithm - an extremely fast non-cryptographic hash algorithm, working at speeds close to RAM limits. It is proposed in two flavors, 32 and 64 bits.
  • https://github.com/Cyan4973/xxHash

• -1406.2294v1- A Fast, Minimal Memory, Consistent Hash Algorithm - [98] [99]

Algorithms

See also Computing#Computational complexity, Maths

• WP: Algorithm

• https://news.ycombinator.com/item?id=15469660

• WP: Algorithm_characterizations

• Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne - surveys the most important algorithms and data structures in use today. We motivate each algorithm that we address by examining its impact on applications to science, engineering, and industry.

• https://news.ycombinator.com/item?id=18805624

• WP: Algorithmic_information_theory - a subfield of information theory and computer science that concerns itself with the relationship between computation and information. According to Gregory Chaitin, it is "the result of putting Shannon's information theory and Turing's computability theory into a cocktail shaker and shaking vigorously."

• http://www.jamisbuck.org/presentations/rubyconf2011/index.html

• http://www3.cs.stonybrook.edu/~algorith/video-lectures/

• WP: Memoization

• http://interactivepython.org/runestone/static/pythonds/index.html [100]

• http://www.nayuki.io/page/fast-fibonacci-algorithms [101]

• http://www.algosort.com/
• WP: List_of_algorithms
• http://www.jjj.de/fxt/fxtpage.html#fxtbook [102]
• Dictionary of Algorithms and Data Structures
• http://news.ycombinator.com/item?id=4961357
• http://graphics.stanford.edu/~seander/bithacks.html
• http://rosettacode.org/wiki/Category:Programming_Tasks
• http://www.hackersdelight.org/
• http://blog.notdot.net/tag/damn-cool-algorithms
• http://aima.cs.berkeley.edu/
• http://www.cleveralgorithms.com/
• http://www.cs.sunysb.edu/~algorith/ [103]
• http://www.comp.nus.edu.sg/~stevenha/visualization/ [104]

• http://jasonpark.me/AlgorithmVisualizer/
• https://news.ycombinator.com/item?id=12326806

• http://visualgo.net/

• https://idea-instructions.com [105]

• http://bost.ocks.org/mike/algorithms/ [106]

• https://news.ycombinator.com/item?id=8088842

• http://justin.abrah.ms/computer-science/how-to-calculate-big-o.html

• http://accidentallyquadratic.tumblr.com/
  • http://accidentallyquadratic.tumblr.com/post/113840433022/why-accidentally-quadratic [107]

• http://news.ycombinator.com/item?id=4783301

• http://leftnode.com/entry/i-am-a-great-programmer-but-horrible-algorithmist.html

• http://jake.simvla.com/posts/531-mr-mrs-kipling

• https://www.varnish-cache.org/trac/wiki/ArchitectNotes

• http://developers.memsql.com/blog/common-pitfalls-in-writing-lock-free-algorithms/

• https://queue.acm.org/detail.cfm?id=1814327

• http://compgeom.cs.uiuc.edu/~jeffe/teaching/algorithms/

• http://keyj.emphy.de/balanced-shuffle/ [108]

• http://www.eternallyconfuzzled.com/jsw_home.aspx [109]

• http://files.righto.com/calculator/sinclair_scientific_simulator.html

• http://planning.cs.uiuc.edu/

• http://www.rockpapershotgun.com/2010/11/02/genetic-algorithms-find-build-order-from-hell/

• http://theory.stanford.edu/~amitp/GameProgramming/AStarComparison.html [110]

• http://jimkang.com/quadtreevis/

• https://news.ycombinator.com/item?id=7949995
• https://news.ycombinator.com/item?id=13517597

• https://flafla2.github.io/2014/08/09/perlinnoise.html [https://news.ycombinator.com/item?id=8158572

• WP: Monte_Carlo_method
• http://montepie.herokuapp.com/ [111]
• https://news.ycombinator.com/item?id=12537043

• http://katrinaeg.com/simulated-annealing.html [112]

• WP: Correctness_(computer_science)

• WP: Hoare_logic

• WP: Logical_assertion

• WP: Assertion_(software_development) - a statement that a predicate (Boolean-valued function, a true–false expression) is expected to always be true at that point in the code. If an assertion evaluates to false at run time, an assertion failure results, which typically causes the program to crash, or to throw an assertion exception.

• WP: Invariant_%28computer_science%29 - a condition that can be relied upon to be true during execution of a program, or during some portion of it. It is a logical assertion that is held to always be true during a certain phase of execution. For example, a loop invariant is a condition that is true at the beginning and end of every execution of a loop.

• WP: Loop_invariant

• WP: Class_invariant

• https://www.cs.princeton.edu/~rs/talks/AC11-Cardinality.pdf

• Main Page - Algorithms for Competitive Programming - The goal of this project is to translate the wonderful resource http://e-maxx.ru/algo which provides descriptions of many algorithms and data structures especially popular in field of competitive programming. Moreover we want to improve the collected knowledge by extending the articles and adding new articles to the collection.
  • https://github.com/e-maxx-eng/e-maxx-eng

Sorting

• What different sorting algorithms sound like
• http://panthema.net/2013/sound-of-sorting/
• http://preshing.com/20121026/1mb-sorting-explained
• http://www.dangermouse.net/esoteric/bogobogosort.html
• http://ljs.io/projects/rainbow/ [113]
• http://sorting.at/ [114]

• stacksort

• https://xosh.org/VisualizingSorts

• https://lobste.rs/s/gh1ngc/is_this_simplest_most_surprising_sorting

• Faster sorting algorithms discovered using deep reinforcement learning | Nature - [115]

Bloom filter

• https://news.ycombinator.com/item?id=6093777 - bloom filters

• http://billmill.org/bloomfilter-tutorial/

• https://news.ycombinator.com/item?id=12241332

• https://news.ycombinator.com/item?id=13056726

• When Bloom filters don't bloom - [116]

• Gopiandcode > logs > Bloom filters debunked: Dispelling 30 Years of bad math with Coq! - [117]

• Word-aligned Bloom filters – Daniel Lemire's blog - da* https://news.ycombinator.com/item?id=28737910 -

Polymorphism

• WP: Polymorphism_(computer_science) - the provision of a single interface to entities of different types. A polymorphic type is one whose operations can also be applied to values of some other type, or types

• WP: Ad_hoc_polymorphism - a kind of polymorphism in which polymorphic functions can be applied to arguments of different types, because a polymorphic function can denote a number of distinct and potentially heterogeneous implementations depending on the type of argument(s) to which it is applied. It is also known as function overloading or operator overloading. The term ad hoc in this context is not intended to be pejorative; it refers simply to the fact that this type of polymorphism is not a fundamental feature of the type system.

• WP: Function_overloading

• WP: Operator_overloading

• WP: Parametric_polymorphism - a way to make a language more expressive, while still maintaining full static type-safety. Using parametric polymorphism, a function or a data type can be written generically so that it can handle values identically without depending on their type. Such functions and data types are called generic functions and generic datatypes respectively and form the basis of generic programming.

• WP: Subtyping

• WP: Polymorphism_in_object-oriented_programming

• WP: Dynamic_dispatch

• WP: Multiple_dispatch

• http://eli.thegreenplace.net/2016/a-polyglots-guide-to-multiple-dispatch/ [118]

Control structures

• WP: Control_flow

• WP: Control_flow_diagram
• WP: Control_flow_graph

• WP: Conditional_(programming)
• WP: Switch_statement

• http://degoes.net/articles/destroy-all-ifs [119]

• WP: For_loop
• WP: While_loop
• WP: Do_while_loop
• WP: Foreach_loop

• WP: Exception_handling

• WP: Continuation

• WP: Container_(abstract_data_type)

• WP: Coroutines

• WP: Generator_(computer_science) - a special routine that can be used to control the iteration behaviour of a loop. In fact, all generators are iterators. A generator is very similar to a function that returns an array, in that a generator has parameters, can be called, and generates a sequence of values. However, instead of building an array containing all the values and returning them all at once, a generator yields the values one at a time, which requires less memory and allows the caller to get started processing the first few values immediately. In short, a generator looks like a function but behaves like an iterator.

Generators can be implemented in terms of more expressive control flow constructs, such as coroutines or first-class continuations. Generators, also known as semicoroutines, are a special case of (and weaker than) coroutines, in that they always yield control back to the caller (when passing a value back), rather than specifying a coroutine to jump to

Libraries

• PDF: Reflections on Trusting Trust - Ken Thompson, 1984

• PDF: How To Write Shared Libraries - Ulrich Drepper, December 10, 2011. Abstract: Today, shared libraries are ubiquitous. Developers use them for multiple reasons and create them just as they would create application code. This is a problem, though, since on many platforms some additional techniques must be applied even to generate decent code. Even more knowledge is needed to generate optimized code. This paper introduces the required rules and techniques. In addition, it introduces the concept of ABI (Application Binary Interface) stability and shows how to manage it.

• http://depstack.io

• https://abi-laboratory.pro
  • https://abi-laboratory.pro/tracker

• ABI Compliance Checker - A tool for checking backward API/ABI compatibility of a C/C++ library

• https://github.com/lvc/abi-dumper - ABI Dumper — a tool to dump ABI of an ELF object containing DWARF debug info.

System calls

See *nix

• WP: System_call

• http://stackoverflow.com/questions/10149621/where-can-i-find-system-call-source-code

• http://jvns.ca/blog/2016/01/23/sendfile-a-new-to-me-system-call/

Macros

• WP: Macro_(computer_science)

• http://www.loper-os.org/?p=401

• http://www.wilfred.me.uk/blog/2014/09/15/comparative-macrology/ [120]

Metaprogramming

• WP: Metaprogramming - the writing of computer programs with the ability to treat programs as their data. It means that a program could be designed to read, generate, analyse or transform other programs, and even modify itself while running. In some cases, this allows programmers to minimize the number of lines of code to express a solution (hence reducing development time), or it gives programs greater flexibility to efficiently handle new situations without recompilation. The language in which the metaprogram is written is called the metalanguage. The language of the programs that are manipulated is called the object language. The ability of a programming language to be its own metalanguage is called reflection or reflexivity

• http://c2.com/cgi/wiki?MetaProgramming

• https://hookrace.net/blog/introduction-to-metaprogramming-in-nim/ [121]

• http://weblog.therealadam.com/2011/12/09/why-metaprogram-when-you-can-program/

Events

• WP: Event_loop

• WP: Event_(computing)

• WP: Event-driven_programming

• WP: Futures_and_promises

• https://www.infoq.com/presentations/systems-event-driven

Messaging

See also Network#Messaging, Data#Serialization

• WP: Messaging_pattern - In software architecture, a messaging pattern is a network-oriented architectural pattern which describes how two different parts of a message passing system connect and communicate with each other. In telecommunications, a message exchange pattern (MEP) describes the pattern of messages required by a communications protocol to establish or use a communication channel. There are two major message exchange patterns — a request–response pattern, and a one-way pattern. For example, HTTP is a request–response pattern protocol, and UDP is a one-way pattern.

• http://c2.com/cgi/wiki?AlanKayOnMessaging [122]

• WP: Message_queue - and mailboxes are software-engineering components used for interprocess communication, or for inter-thread communication within the same process.

• WP: Publish–subscribe_pattern

• http://blog.iron.io/2012/12/top-10-uses-for-message-queue.html

• WP: Interface_description_language - or interface definition language (IDL), is a generic term for a language that lets a program or object written in one language communicate with another program written in an unknown language. IDLs are usually used to describe data types and interfaces in a language-independent way, for example, between those written in C++ and those written in Java. IDLs are commonly used in remote procedure call software. In these cases the machines at either end of the link may be using different operating systems and computer languages. IDLs offer a bridge between the two different systems. Software systems based on IDLs include Sun's ONC RPC, The Open Group's Distributed Computing Environment, IBM's System Object Model, the Object Management Group's CORBA (which implements OMG IDL), an IDL based on DCE/RPC, and Data Distribution Service, Mozilla's XPCOM, Microsoft's Microsoft RPC (which evolved into COM and DCOM), Facebook's Thrift and WSDL for Web services.

• WP: Remote_procedure_call - when a computer program causes a procedure (subroutine) to execute in a different address space (commonly on another computer on a shared network), which is coded as if it were a normal (local) procedure call, without the programmer explicitly coding the details for the remote interaction. That is, the programmer writes essentially the same code whether the subroutine is local to the executing program, or remote. This is a form of client–server interaction (caller is client, executor is server), typically implemented via a request–response message-passing system. In the object-oriented programming paradigm, RPC calls are represented by remote method invocation (RMI). The RPC model implies a level of location transparency, namely that calling procedures are largely the same whether they are local or remote, but usually they are not identical, so local calls can be distinguished from remote calls. Remote calls are usually orders of magnitude slower and less reliable than local calls, so distinguishing them is important.RPCs are a form of inter-process communication (IPC), in that different processes have different address spaces: if on the same host machine, they have distinct virtual address spaces, even though the physical address space is the same; while if they are on different hosts, the physical address space is different. Many different (often incompatible) technologies have been used to implement the concept.

• WP: Request–response - or request–reply, is one of the basic methods computers use to communicate with each other, in which the first computer sends a request for some data and the second responds to the request. Usually, there is a series of such interchanges until the complete message is sent; browsing a web page is an example of request–response communication. Request–response can be seen as a telephone call, in which someone is called and they answer the call.Request–response is a message exchange pattern in which a requestor sends a request message to a replier system which receives and processes the request, ultimately returning a message in response. This is a simple, but powerful messaging pattern which allows two applications to have a two-way conversation with one another over a channel. This pattern is especially common in client–server architectures. For simplicity, this pattern is typically implemented in a purely synchronous fashion, as in web service calls over HTTP, which holds a connection open and waits until the response is delivered or the timeout period expired. However, request–response may also be implemented asynchronously, with a response being returned at some unknown later time. When a synchronous system communicates with an asynchronous system, it is referred to as "sync over async" or "sync/async". This is common in enterprise application integration (EAI) implementations where slow aggregations, time-intensive functions, or human workflow must be performed before a response can be constructed and delivered.

Apache Thrift

• Apache Thrift - framework for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and seamlessly between C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, OCaml and Delphi and other languages. Thrift allows you to define data types and service interfaces in a simple definition file. Taking that file as input, the compiler generates code to be used to easily build RPC clients and servers that communicate seamlessly across programming languages. Instead of writing a load of boilerplate code to serialize and transport your objects and invoke remote methods, you can get right down to business.

zeromq

• zeromq - Distributed Messaging. Connect your code in any language, on any platform. Carries messages across inproc, IPC, TCP, TIPC, multicast. Smart patterns like pub-sub, push-pull, and router-dealer. High-speed asynchronous I/O engines, in a tiny library. Backed by a large and active open source community. Supports every modern language and platform. Build any architecture: centralized, distributed, small, or large. Free software with full commercial support.
  • ØMQ - The Guide
  • Chapter Eight

hyperglyph

• https://github.com/hyperglyph/hyperglyph - ducked typed ipc over http
  • Vimeo: Thomas Figg @iamtef - RESTful-RPC or how I learned to stop worrying and love hypermedia

MessagePack

• MessagePack - an efficient binary serialization format. It lets you exchange data among multiple languages like JSON but it's faster and smaller. For example, small integers (like flags or error code) are encoded into a single byte, and typical short strings only require an extra byte in addition to the strings themselves.

AMQP

• AMQP - Advanced Message Queuing Protocol, an open standard for passing business messages between applications or organizations. It connects systems, feeds business processes with the information they need and reliably transmits onward the instructions that achieve their goals.

RabbitMQ

• RabbitMQ - the most widely deployed open source message broker. RabbitMQ is lightweight and easy to deploy on premises and in the cloud. It supports multiple messaging protocols. RabbitMQ can be deployed in distributed and federated configurations to meet high-scale, high-availability requirements.

tosort

• https://news.ycombinator.com/item?id=8377345 - using a DB for messaging?

• https://blog.jooq.org/2014/09/26/using-your-rdbms-for-messaging-is-totally-ok/

Concurrency

• WP: Concurrent_computing - a form of computing in which several computations are executing during overlapping time periods—concurrently—instead of sequentially (one completing before the next starts). This is a property of a system—this may be an individual program, a computer, or a network—and there is a separate execution point or "thread of control" for each computation ("process"). A concurrent system is one where a computation can make progress without waiting for all other computations to complete—where more than one computation can make progress at "the same time".

• WP: Concurrency_(computer_science)

• WP: Concurrency_control

• Concurrency is not parallelism - The Go Blog - But when people hear the word concurrency they often think of parallelism, a related but quite distinct concept. In programming, concurrency is the composition of independently executing processes, while parallelism is the simultaneous execution of (possibly related) computations. Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once. With talk from Rob Pike on Go.
  • YouTube: Rob Pike - 'Concurrency Is Not Parallelism'

Hand wavey definition

• Concurrency = dealing with a lot of thigns at one
• Parallelism = doing a lot of things at once

• WP: Communicating_sequential_processes - a formal language for describing patterns of interaction in concurrent systems. It is a member of the family of mathematical theories of concurrency known as process algebras, or process calculi, based on message passing via channels. CSP was highly influential in the design of the occam programming language, and also influenced the design of programming languages such as Limbo, RaftLib, Go, Crystal, and Clojure's core.async.CSP was first described in a 1978 paper by Tony Hoare, but has since evolved substantially. CSP has been practically applied in industry as a tool for specifying and verifying the concurrent aspects of a variety of different systems, such as the T9000 Transputer, as well as a secure ecommerce system. The theory of CSP itself is also still the subject of active research, including work to increase its range of practical applicability (e.g., increasing the scale of the systems that can be tractably analyzed)

• WP: Thread_(computing)

• http://250bpm.com/blog:81 [123]

• https://github.com/0xAX/linux-insides/blob/master/SyncPrim/sync-4.md [124]

• WP: Mutual_exclusion - the requirement of ensuring that no two concurrent processes are in their critical section at the same time; it is a basic requirement in concurrency control, to prevent race conditions. Here, a critical section refers to a period when the process accesses a shared resource, such as shared memory. The requirement of mutual exclusion was first identified and solved by Edsger W. Dijkstra in his seminal 1965 paper titled Solution of a problem in concurrent programming control, and is credited as the first topic in the study of concurrent algorithms.

• WP: Race_condition#Software

• WP: Critical_section - a part of a multi-process program that may not be concurrently executed by more than one of the program's processes.[a] In other words, it is a piece of a program that requires mutual exclusion of access. Typically, the critical section accesses a shared resource, such as a data structure, a peripheral device, or a network connection, that does not allow multiple concurrent accesses.

• WP: Spinlock

• WP: Concurrent_algorithm

• https://drive.google.com/file/d/0B1n48l1C3eK8OWR5d0daTko2X2s/view [125]

• WP: Synchronization_(computer_science)#Thread_or_process_synchronization

• WP: Deadlock - a situation in which two or more competing actions are each waiting for the other to finish, and thus neither ever does.

• WP: Starvation_(computer_science) - where a process is perpetually denied necessary resources to process its work.

• WP: Busy_waiting

• WP: Lock_(computer_science) - or mutex (from mutual exclusion) is a synchronization mechanism for enforcing limits on access to a resource in an environment where there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy.

• https://github.com/rigtorp/awesome-lockfree - A collection of resources on wait-free and lock-free programming.

• WP: Message_passing

• WP: Channel_(programming)

Futures and promises

• WP: Futures_and_promises - future, promise, delay, and deferred refer to constructs used for synchronizing in some concurrent programming languages. They describe an object that acts as a proxy for a result that is initially unknown, usually because the computation of its value is yet incomplete.

• http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/ [126]
• https://lukasa.co.uk/2016/07/The_Function_Colour_Myth/

• https://news.ycombinator.com/item?id=11526887

Parallelism

• WP: Parallel_computing - a type of computation in which many calculations or the execution of processes are carried out concurrently. Large problems can often be divided into smaller ones, which can then be solved at the same time. There are several different forms of parallel computing: bit-level, instruction-level, data, and task parallelism. Parallelism has long been employed in high-performance computing, but it's gaining broader interest due to the physical constraints preventing frequency scaling.[2] As power consumption (and consequently heat generation) by computers has become a concern in recent years, parallel computing has become the dominant paradigm in computer architecture, mainly in the form of multi-core processors.

• WP: Analysis_of_parallel_algorithms - Like in the analysis of "ordinary", sequential, algorithms, one is typically interested in asymptotic bounds on the resource consumption (mainly time spent computing), but the analysis is performed in the presence of multiple processor units that cooperate to perform computations. Thus, one can determine not only how many "steps" a computation takes, but also how much faster it becomes as the number of processors goes up.

• WP: Bit-level_parallelism - a form of parallel computing based on increasing processor word size. Increasing the word size reduces the number of instructions the processor must execute in order to perform an operation on variables whose sizes are greater than the length of the word. (For example, consider a case where an 8-bit processor must add two 16-bit integers. The processor must first add the 8 lower-order bits from each integer, then add the 8 higher-order bits, requiring two instructions to complete a single operation. A 16-bit processor would be able to complete the operation with single instruction.) Originally, all electronic computers were serial (single-bit) computers. The first electronic computer that was not a serial computer—the first bit-parallel computer—was the 16-bit Whirlwind from 1951. From the advent of very-large-scale integration (VLSI) computer chip fabrication technology in the 1970s until about 1986, advancements in computer architecture were done by increasing bit-level parallelism,[1] as 4-bit microprocessors were replaced by 8-bit, then 16-bit, then 32-bit microprocessors. This trend generally came to an end with the introduction of 32-bit processors, which have been a standard in general purpose computing for two decades. Only recently, with the advent of x86-64 architectures, have 64-bit processors become commonplace. On 32-bit processors, external data bus width continues to increase. For example, DDR1 SDRAM transfers 128 bits per clock cycle. DDR2 SDRAM transfers a minimum of 256 bits per burst.

• WP: Instruction-level_parallelism - a measure of how many of the instructions in a computer program can be executed simultaneously. There are two approaches to instruction level parallelism: in hardware and in software. Hardware level works upon dynamic parallelism whereas, the software level works on static parallelism. Dynamic parallelism means the processor decides at run time which instructions to execute in parallel, whereas static parallelism means the compiler decides which instructions to execute in parallel. The Pentium processor works on the dynamic sequence of parallel execution but the Itanium processor works on the static level parallelism.

• WP: Data_parallelism - a form of parallelization across multiple processors in parallel computing environments. It focuses on distributing the data across different nodes, which operate on the data in parallel. It can be applied on regular data structures like arrays and matrices by working on each element in parallel.

• WP: Task_parallelism - also known as function parallelism and control parallelism, is a form of parallelization of computer code across multiple processors in parallel computing environments. Task parallelism focuses on distributing tasks—concurrently performed by processes or threads—across different processors. In contrast to data parallelism which involves running the same task on different components of data, task parallelism is distinguished by running many different tasks at the same time on the same data. A common type of task parallelism is pipelining which consists of moving a single set of data through a series of separate tasks where each task can execute independently of the others.

Garbage collection

• WP: Garbage_collection_(computer_science)

• WP: Cheney%27s_algorithm

• Old New Thing: Everybody thinks about garbage collection the wrong way

• http://xtzgzorex.wordpress.com/2012/10/11/demystifying-garbage-collectors/

• https://news.ycombinator.com/item?id=10794026

• http://blog.brownplt.org/2013/02/19/teaching-gc.html

• http://michaelrbernste.in/2013/06/03/real-time-garbage-collection-is-real.html

• http://journal.stuffwithstuff.com/2013/12/08/babys-first-garbage-collector/ [127]

• https://news.ycombinator.com/item?id=7499101

• https://news.ycombinator.com/item?id=8263811

Paradigms

• http://c2.com/cgi/wiki?BigIdea

• WP: Programming_paradigm
  • http://upload.wikimedia.org/wikipedia/commons/f/f7/Programming_paradigms.svg

• We Really Don't Know How To Compute!

• The Rule of Least Power - When designing computer systems, one is often faced with a choice between using a more or less powerful language for publishing information, for expressing constraints, or for solving some problem. This finding explores tradeoffs relating the choice of language to reusability of information. The "Rule of Least Power" suggests choosing the least powerful language suitable for a given purpose.

• Kevin Mahoney: Applying "Make Invalid States Unrepresentable" - [128]

Literate programming

• WP: Literate_programming

• http://akkartik.name/post/literate-programming [129]

• YouTube: Knuth on Literate Programming - 2007

• YouTube: Literate Programming - Donald Knuth, 2018

Imperative

• WP: Imperative_programming - a programming paradigm that uses statements that change a program's state. In much the same way that the imperative mood in natural languages expresses commands, an imperative program consists of commands for the computer to perform. Imperative programming focuses on describing how a program operates.

• WP: Procedural_programming - a programming paradigm, derived from structured programming, based upon the concept of the procedure call. Procedures, also known as routines, subroutines, or functions (not to be confused with mathematical functions, but similar to those used in functional programming), simply contain a series of computational steps to be carried out. Any given procedure might be called at any point during a program's execution, including by other procedures or itself. Procedural programming languages include C, Go, Fortran, Pascal, and BASIC. Computer processors provide hardware support for procedural programming through a stack register and instructions for calling procedures and returning from them. Hardware support for other types of programming is possible, but no attempt was commercially successful (for example Lisp machines or Java processors).

• WP: Structured_programming - a programming paradigm aimed at improving the clarity, quality, and development time of a computer program by making extensive use of subroutines, block structures, for and while loops—in contrast to using simple tests and jumps such as the goto statement which could lead to "spaghetti code" which is difficult both to follow and to maintain. It emerged in the late 1950s with the appearance of the ALGOL 58 and ALGOL 60 programming languages, with the latter including support for block structures.

Contributing factors to its popularity and widespread acceptance, at first in academia and later among practitioners, include the discovery of what is now known as the structured program theorem in 1966, and the publication of the influential "Go To Statement Considered Harmful" open letter in 1968 by Dutch computer scientist Edsger W. Dijkstra, who coined the term "structured programming". Structured programming is most frequently used with deviations that allow for clearer programs in some particular cases, such as when exception handling has to be performed.

• http://c2.com/cgi/wiki?LasagnaCode
• http://c2.com/cgi/wiki?RavioliCode
• http://c2.com/cgi/wiki?CousCousCode

Recursive

• Recursive functions of symbolic expressions and their computation by machine, Part I

Object orientated

• WP: Object-oriented_programming - OOP

• https://news.ycombinator.com/item?id=11808551 - Alan Kay on objects et al

• http://lists.squeakfoundation.org/pipermail/squeak-dev/1998-October/017019.html [130]

• http://c2.com/cgi/wiki?ClosuresAndObjectsAreEquivalent

• What is the difference between Alan Kay's definition of OOP and Carl Hewitt's Actor Model? - Quora -

• https://www.cs.utexas.edu/users/wcook/papers/OOPvsADT/CookOOPvsADT90.pdf [131]

• YouTube: Pong & Object Oriented Programming - Computerphile

• YouTube: CS\M04\T01 - Classes, Objects, Properties and Method Concepts

• WP: Object_(computer_science)

• WP: Class_(computer_science)

• WP: Instance_(computer_science)

• WP: Method_(computer_programming) - a procedure associated with an object. An object is made up of data and behavior, which form the interface that an object presents to the outside world. Data is represented as properties of the object and behavior as methods. For example, a Window object would have methods such as open and close, while its state (whether it is opened or closed) would be a property.

• http://stackoverflow.com/questions/4203163/how-do-i-design-a-class-in-python/4203836#4203836

• https://medium.com/@simplyianm/why-gos-structs-are-superior-to-class-based-inheritance-b661ba897c67 [132]

• WP: Resource_Acquisition_Is_Initialization

• WP: Inheritance_(object-oriented_programming)

• WP: Multiple_inheritance

• WP: Prototype-based_programming

• WP: Differential_inheritance

• https://news.ycombinator.com/item?id=16605831
• https://lobste.rs/s/bb2dyo/why_inheritance_never_made_any_sense

• WP: Object_copy
• WP: Object_lifetime

• WP: Object_composition

• WP: Composition_over_inheritance

• WP: Encapsulation_(object-oriented_programming)

• WP: Resource_acquisition_is_initialization - a programming idiom used in several object-oriented languages to describe a particular language behavior. In RAII, holding a resource is a class invariant, and is tied to object lifetime: resource allocation (or acquisition) is done during object creation (specifically initialization), by the constructor, while resource deallocation (release) is done during object destruction (specifically finalization), by the destructor. Thus the resource is guaranteed to be held between when initialization finishes and finalization starts (holding the resources is a class invariant), and to be held only when the object is alive. Thus if there are no object leaks, there are no resource leaks.

• WP: Mutator_method
• WP: Protocol_(object-oriented_programming)

• WP: Delegation_(programming)
• WP: Delegation_pattern

• WP: Mixin

• WP: Coupling_(computer_programming)

• WP: Observer_pattern
• WP: Template_method_pattern
• WP: Factory_method_pattern
• WP: Composite_pattern
• WP: Decorator_pattern
• WP: Mediator_pattern
• WP: Adapter_pattern

• WP: Member_variable

• WP: Command_pattern

• WP: Resource_Acquisition_Is_Initialization

• WP: SOLID_%28object-oriented_design%29 - Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion

• https://news.ycombinator.com/item?id=14660895

• WP: Jeroo

• https://plus.google.com/101960720994009339267/posts/hoJdanihKwb - rob pike on oo
  • http://www.csis.pace.edu/~bergin/patterns/ppoop.html
• https://news.ycombinator.com/item?id=6909326

• http://blog.ircmaxell.com/2012/07/oop-vs-procedural-code.html

• http://harmful.cat-v.org/software/OO_programming/why_oo_sucks [133]
  • http://www.librador.com/2012/07/16/No-thats-not-why-OO-sucks/
• http://prog21.dadgum.com/156.html

• YouTube: Object-Oriented Programming is Bad - Brian Will

• http://raganwald.com/2014/03/10/writing-oop-using-oop.html

• http://wcook.blogspot.co.uk/2012/07/proposal-for-simplified-modern.html
• http://blog.codeclimate.com/blog/2012/11/28/your-objects-the-unix-way/

• http://lwn.net/SubscriberLink/548560/16388a4dbede3884/

• WP: Metaobject
• WP: Metaclass

• WP: Aspect-oriented_software_development

• http://web.media.mit.edu/~lieber/Lieberary/OOP/Delegation/Delegation.html [134]

• http://steve-yegge.blogspot.co.uk/2006/03/execution-in-kingdom-of-nouns.html

• https://news.ycombinator.com/item?id=6932089

• http://raganwald.com/2014/03/31/class-hierarchies-dont-do-that.html [135]

• https://news.ycombinator.com/item?id=8830794

• http://wcook.blogspot.co.uk/2012/07/proposal-for-simplified-modern.html [136]

• https://blog.inf.ed.ac.uk/sapm/2014/02/04/the-anaemic-domain-model-is-no-anti-pattern-its-a-solid-design/

Data-orientated

• WP: Data-oriented_design - a program optimization approach motivated by efficient usage of the CPU cache, used in video game development. The approach is to focus on the data layout, separating and sorting fields according to when they are needed, and to think about transformations of data. Proponents include Mike Acton and Scott Meyers.

The claim is that traditional object-oriented programming (OOP) design principles result in poor data locality, more so if runtime polymorphism (dynamic dispatch) is used (which is especially problematic on some processors). Although OOP does superficially seem to organise code around data, the practice is quite different. OOP is actually about organising source code around data types, rather than physically grouping individual fields and arrays in a format efficient for access by specific functions. It also often hides layout details under abstraction layers, while a data-oriented programmer wants to consider this first and foremost.

• https://news.ycombinator.com/item?id=20205694

• YouTube: CppCon 2014: Mike Acton "Data-Oriented Design and C++"

• YouTube: CppCon 2018: Stoyan Nikolov “OOP Is Dead, Long Live Data-oriented Design”

• Three Big Lies - CellPerformance

Declarative

• WP: Declarative_programming - a programming paradigm—a style of building the structure and elements of computer programs—that expresses the logic of a computation without describing its control flow. Declarative programming often considers programs as theories of a formal logic, and computations as deductions in that logic space. Declarative programming may greatly simplify writing parallel programs. Common declarative languages include those of database query languages (e.g., SQL, XQuery), regular expressions, logic programming, functional programming, and configuration management systems.

• http://latentflip.com/imperative-vs-declarative

We could do this in an imperative style like so:

var numbers = [1,2,3,4,5]
var doubled = []

for(var i = 0; i < numbers.length; i++) {
  var newNumber = numbers[i] * 2
  doubled.push(newNumber)
}
console.log(doubled) //=> [2,4,6,8,10]

We explicitly iterate over the length of the array, pull each element out of the array, double it, and add the doubled value to the new array, mutating the doubled array at each step until we are done. A more declarative approach might use the Array.map function and look like:

var numbers = [1,2,3,4,5]
 
var doubled = numbers.map(function(n) {
  return n * 2
})
console.log(doubled) //=> [2,4,6,8,10]

map creates a new array from an existing array, where each element in the new array is created by passing the elements of the original array into the function passed to map (function(n) { return n*2 } in this case). What the map function does is abstract away the process of explicitly iterating over the array, and lets us focus on what we want to happen. Note that the function we pass to map is pure; it doesn't have any side effects (change any external state), it just takes in a number and returns the number doubled.

• Design, Composition and Performance - Rich Hickey explores the nature of design and composition and how it impacts the software development practice and tools.

• Crash-only software: More than meets the eye [137]

Functional

• WP: Functional_programming

• WP: Purely_functional

• WP: First-class_function

• http://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming [138]

• Functional Programming 101 - With Haskell [139]

• λ Lessons - Pattern matching, first-class functions, and abstracting over recursion in Haskell. This is a short, interactive lesson that teaches core functional programming concepts. It was designed to transform the way you think about performing operations on lists of things, by showing you how functions are executed. [140]

• http://www.infoq.com/presentations/functional-pros-cons

• http://peteratt.com/programming-thinking-functional-way/ [141]

• https://fsharpforfunandprofit.com/posts/recipe-part2/ [142]

• A philosophical difference between Haskell and Lisp - [143]

• WP: Functional_reactive_programming

• The introduction to Reactive Programming you've been missing [144]

• http://stackoverflow.com/questions/327955/does-functional-programming-replace-gof-design-patterns
• http://www.dev.gd/20121224-understanding-map-filter-and-fold.html
• http://loup-vaillant.fr/tutorials/from-imperative-to-functional

• http://www.harukizaemon.com/blog/2010/03/01/functional-programming-in-object-oriented-languages/
• DrupalCon Munich 2012: Functional PHP

• "Controlling Time and Space: understanding the many formulations of FRP" by Evan Czaplicki

• Functional Reactive Programming · keera-studios/haskell-game-programming Wiki

• YouTube: "Transducers" by Rich Hickey [145]

• Clojure - Transducers

• WP: Applicative_programming_language

• WP: Typed_lambda_calculus

• https://github.com/orsinium-labs/rlci - crab λ Overly-documented Rust-powered Lambda Calculus Interpreter.

• http://technicae.cogitat.io/2012/12/the-secret-history-of-lambda.html
• https://gist.github.com/e000/1023982
• http://stevelosh.com/blog/2013/03/list-out-of-lambda/

• Functional Languages 101: What’s All the Fuss About?
• Functional Programming for the Object-Oriented Programmer
• Functional and Object-Oriented Programming

• Functional programming: A step backward
• Functional Programming is Dead, Long Live Expression-Oriented Programming

• Monads in Pictures - Aug 20th, 2012

• Google Video: Type-driven testing in Haskell - Simon Peyton Jones

• http://www.ibm.com/developerworks/library/j-ft20/

• http://cstheory.stackexchange.com/questions/1539/whats-new-in-purely-functional-data-structures-since-okasaki

• WP: Hindley%E2%80%93Milner_type_system

• http://www.infoq.com/presentations/functional-category-theory [146]

• http://www.chrisstucchio.com/blog/2014/computers_are_made_of_metal.html [147]

• http://bartoszmilewski.com/2014/12/23/kleisli-categories/ [148]

• http://www.jpaulmorrison.com/fbp/introduction.html

• WP: Functional_logic_programming

• https://news.ycombinator.com/item?id=11729270

• http://philipnilsson.github.io/Badness10k/posts/2016-08-10-functional-patterns-monoid-morphism.html [149]

• The Implementation of Functional Programming Languages - Microsoft Research

• Implementing functional languages: a tutorial - Microsoft Research

• A Short Ballad Dedicated to the Growth of Programs | Cognitive Computing

Concatenative

• WP: Concatenative_programming_language - a point-free computer programming language in which all expressions denote functions, and the juxtaposition of expressions denotes function composition. Concatenative programming replaces function application, which is common in other programming styles, with function composition as the default way to build subroutines.

• http://concatenative.org/

• The Theory of Concatenative Combinators - This article attempts to outline, in informal terms, a new theory of combinators, related to the theory of Combinatory Logic pioneered by Moses Schonfinkel, Haskell Curry, and others in the 1930s. Although not essential, an understanding of the classical theory of combinators may be helpful (see the links at the bottom of this article for some introductory material to combinators). This topic is one which no doubt ought to be subjected to the rigor of modern mathematics; there are many theorems from classical combinatory logic (e.g., Church-Rosser) which we conjecture have analogues here. However, what follows is only a rough, but hopefully, friendly, introduction to the subject. The inspiration for this theory comes from the programming language Joy, designed by Manfred von Thun. It would be very helpful if the reader is basically familiar with Joy. In Joy, data is manipulated through a stack (there are no variables); in this way, it is similar to the programming language FORTH. However, Joy goes one step further and permits (and actively encourages) pushing programs themselves onto the stack, which can then be manipulated just like ordinary data. In fact, the theory here is basically a subset of Joy in which programs are the only kind of data (i.e., numbers, string literals, and other kinds of data are not part of the theory here). To someone unfamiliar with combinatory logic, it might seem that no useful computations could be done without numbers, but it will soon be seen that numeric data can be simulated using concatenative combinators, just as they could using classical combinators. [150]

Dataflow

See Dataflow

• WP: Dataflow_programming - a programming paradigm that models a program as a directed graph of the data flowing between operations, thus implementing dataflow principles and architecture. Dataflow programming languages share some features of functional languages, and were generally developed in order to bring some functional concepts to a language more suitable for numeric processing.

Reactive

• WP: Reactive_programming - a programming paradigm oriented around data flows and the propagation of change. This means that it should be possible to express static or dynamic data flows with ease in the programming languages used, and that the underlying execution model will automatically propagate changes through the data flow.

• http://staltz.com/dont-react/ [151]

Flow-based

• WP: Flow-based_programming - FBP, a programming paradigm that defines applications as networks of "black box" processes, which exchange data across predefined connections by message passing, where the connections are specified externally to the processes. These black box processes can be reconnected endlessly to form different applications without having to be changed internally. FBP is thus naturally component-oriented. FBP is a particular form of dataflow programming based on bounded buffers, information packets with defined lifetimes, named ports, and separate definition of connections.

• https://news.ycombinator.com/item?id=25848542

• Apache NiFi is a dataflow system based on the concepts of flow-based programming. It supports powerful and scalable directed graphs of data routing, transformation, and system mediation logic. NiFi has a web-based user interface for design, control, feedback, and monitoring of dataflows. It is highly configurable along several dimensions of quality of service, such as loss-tolerant versus guaranteed delivery, low latency versus high throughput, and priority-based queuing. NiFi provides fine-grained data provenance for all data received, forked, joined cloned, modified, sent, and ultimately dropped upon reaching its configured end-state. [152]

Constraint

• WP: Constraint_programming

Logic

• WP: Logic_programming - a programming paradigm based on formal logic. A program written in a logic programming language is a set of sentences in logical form, expressing facts and rules about some problem domain. Major logic programming language families include Prolog, Answer set programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses and are read declaratively as logical implications.

• A Practo-Theoretical Introduction to Logic Programming -

Differentiable

• WP: Differentiable_programming - a programming paradigm in which a numeric computer program can be differentiated throughout via automatic differentiation. This allows for gradient-based optimization of parameters in the program, often via gradient descent, as well as other learning approaches that are based on higher order derivative information. Differentiable programming has found use in a wide variety of areas, particularly scientific computing and artificial intelligence. One of the early proposals to adopt such a framework in a systematic fashion to improve upon learning algorithms was made by the Advanced Concepts Team at the European Space Agency in early 2016.

Patterns

See also Organisation#Patterns, Development

• WP: Design_pattern

• https://github.com/kamranahmedse/design-patterns-for-humans/blob/master/README.md [153]

• WP: Software_design_pattern

• https://news.ycombinator.com/item?id=12849757

• WP: Architectural_pattern

• WikiWikiWeb - aka Wards Wiki

• Portland Pattern Repository
  • WP: Portland_Pattern_Repository

• http://c2.com/cgi/wiki?PatternIndex

• http://c2.com/cgi/wiki?CategoryPattern

• http://c2.com/cgi/wiki?CategoryAntiPattern

• • http://c2.com/cgi/wiki?ExtremeProgrammingRoadmap

"ExtremeProgramming -- all programming is maintenance."

• Design Patterns Library - a source for information about all aspects of software patterns and pattern languages. If you are new to patterns, James Coplien and Richard Gabriel have created a succinct pattern definition.Patterns and Pattern Languages are ways to describe best practices, good designs, and capture experience in a way that it is possible for others to reuse this experience. The Hillside Group takes pleasure in sponsoring many different PLoP conferences that are provided for the betterment of the pattern community.

• http://stackoverflow.com/questions/92225/what-are-the-best-resources-for-design-patterns-and-their-uses

• http://perldesignpatterns.com/?HomePage

• http://blog.plover.com/prog/design-patterns.html

• http://www.mcdonaldland.info/files/designpatterns/designpatternscard.pdf

• WP: Architectural_pattern_%28computer_science%29

• WP: Common_layers_in_an_information_system_logical_architecture

• WP: Module_pattern

• http://modulecounts.com/

• WP: Singleton_pattern - restrict the instantiation of a class to one object.

• https://programmers.stackexchange.com/questions/40373/so-singletons-are-bad-then-what

• WP: Behavioral_pattern

• WP: Actor_model

• https://news.ycombinator.com/item?id=26024085

• WP: Inversion_of_control

• http://c2.com/cgi/wiki?CollectionOrientedProgramming

• http://www.perldesignpatterns.com/?PerlDesignPatterns

• http://www.embeddedrelated.com/showarticle/455.php

• http://www.jroller.com/landers/entry/the_design_pattern_facade_pattern

• https://news.ycombinator.com/item?id=6790392

• http://ssdl-wiki.cs.technion.ac.il/wiki/index.php/Spartan_programming

• http://meyerweb.com/eric/comment/chech.html

• http://www.confreaks.com/videos/3337-railsconf-keynote-10-years - convention over configuration

• YouTube: Lambda Jam 2014 - Eric Meijer - The Lost Art of Denotational Semantics

• Repeat yourself, do more than one thing, and... - [154]

• The Catalog of Design Patterns - [155]

• WP: Flyweight_pattern - software design pattern refers to an object that minimizes memory usage by sharing some of its data with other similar objects. The flyweight pattern is one of twenty-three well-known GoF design patterns. These patterns promote flexible object-oriented software design, which is easier to implement, change, test, and reuse.In other contexts, the idea of sharing data structures is called hash consing. The term was first coined, and the idea extensively explored, by Paul Calder and Mark Linton in 1990 to efficiently handle glyph information in a WYSIWYG document editor. Similar techniques were already used in other systems, however, as early as 1988.

MV*

• WP: Model%E2%80%93view%E2%80%93controller
• http://c2.com/cgi/wiki?ModelViewController
• http://puremvc.org/content/view/67/178/
• https://news.ycombinator.com/item?id=6370343

• http://mvc.givan.se/ [156]

• http://mikepackdev.com/blog_posts/34-a-review-of-mvc

"create your views, express your models or develop a controller"

• http://martinfowler.com/eaaDev/PresentationModel.html
• WP: Model_View_ViewModel

• http://russelleast.wordpress.com/2008/08/09/overview-of-the-modelview-viewmodel-mvvm-pattern-and-data-binding/
• http://programmers.stackexchange.com/questions/114409/did-concept-of-viewmodel-exist-before-mvvm

• http://gee.cs.oswego.edu/dl/acs/acs/acs.html?1 - reactive [157]

Component-based

• WP: Component-based_software_engineering - CBSE), also called component-based development (CBD), is a style of software engineering that aims to build software out of loosely-coupled, modular components. It emphasizes the separation of concerns among different parts of a software system.

• WP: Separation_of_concerns - a design principle for separating a computer program into distinct sections. Each section addresses a separate concern, a set of information that affects the code of a computer program. A concern can be as general as "the details of the hardware for an application", or as specific as "the name of which class to instantiate". A program that embodies SoC well is called a modular program. Modularity, and hence separation of concerns, is achieved by encapsulating information inside a section of code that has a well-defined interface. Encapsulation is a means of information hiding. Layered designs in information systems are another embodiment of separation of concerns (e.g., presentation layer, business logic layer, data access layer, persistence layer).

• WP: Loose_coupling - In computing and systems design, a loosely coupled system is one; in which components are weakly associated (have breakable relationships, with each other, and thus changes in one component least affect existence or performance of another component, and/or; in which each of its components has, or makes use of, little or no knowledge of the definitions of other separate components. Subareas include the coupling of classes, interfaces, data, and services. Loose coupling is the opposite of tight coupling.

Service-orientated

See HTTP, Chat, Semantic, Feeds, etc.

• WP: Service-orientation - a design paradigm for computer software in the form of services. The principles of service-oriented design stress the separation of concerns in the software. Applying service-orientation results in units of software partitioned into discrete, autonomous, and network-accessible units, each designed to solve an individual concern. These units qualify as services.

• WP: Service_(systems_architecture) - In the contexts of software architecture, service-orientation and service-oriented architecture, the term service refers to a software functionality, or a set of software functionalities (such as the retrieval of specified information or the execution of a set of operations, with a purpose that different clients can reuse for different purposes, together with the policies that should control its usage (based on the identity of the client requesting the service, for example).

OASIS defines a service as "a mechanism to enable access to one or more capabilities, where the access is provided using a prescribed interface and is exercised consistent with constraints and policies as specified by the service description".

• WP: Service_description - In computer science, a service description could be any of:
  • Interface description language – Computer language used to describe a software component's interface
  • Web Services Description Language – XML-based interface description language
  • RESTful Service Description Language – XML description of HTTP-based web APIs
  • SOAP Service Description Language – Messaging protocol for web services
  • Service Mapping Description – Proposed standard for describing web services available at a particular endpoint using JSON

• WP: Service-oriented_architecture - an architectural style that focuses on discrete services instead of a monolithic design. By consequence, it is also applied in the field of software design where services are provided to the other components by application components, through a communication protocol over a network. A service is a discrete unit of functionality that can be accessed remotely and acted upon and updated independently, such as retrieving a credit card statement online. SOA is also intended to be independent of vendors, products and technologies.

Service orientation is a way of thinking in terms of services and service-based development and the outcomes of services. A service has four properties according to one of many definitions of SOA:

• It logically represents a repeatable business activity with a specified outcome.
• It is self-contained.
• It is a black box for its consumers, meaning the consumer does not have to be aware of the service's inner workings.
• It may be composed of other services.

• WP: OASIS_SOA_Reference_Model - The OASIS Reference Model for Service Oriented Architecture, SOA-RM, is an abstract framework for understanding significant entities and relationships between them within a service-oriented environment, and for the development of consistent standards or specifications supporting that environment. It is based on unifying concepts of SOA and may be used by architects developing specific service oriented architectures or in training and explaining SOA.

In this context, a reference model is seen as a venue to provide a common semantics that can be used unambiguously across and between different SOA implementations. The relationship between the Reference Model and particular architectures, technologies and other aspects of SOA is illustrated below from the specification.

• Web Services, Service-Oriented Architectures, and Cloud Computing

Push/pull

• WP: Publish%E2%80%93subscribe_pattern

• WP: Push_technology

Graphics

See Graphics, UI, GUI, Wayland, 3D

• WP: Layout_engine - a computer program that combines content and formatting information for electronic or printed display. It is not a stand-alone program but a core component of larger programs. There are different types of layout engines. One is the web browser engines used in web browsers and email clients. Another type is the layout managers used in widget toolkits.

• WP: List_of_layout_engines

to sort

SDL

• Laurence Tratt: An Editor for Composed Programs - [158]

• Eco - a prototype editor for editing composed languages. It is not feature complete, it is not intended for production, and it does have bugs. Eco is distributed under a BSD/MIT license.

Noise

• Visual Noises @ ramesaliyev - [159]

• https://github.com/smcameron/open-simplex-noise-in-c - Port of Kurt Spencer's java implementation of open simplex noise to C -- Note: This is NOT Ken Perlin's Simplex noise algorithm.

Optimisation

• LWN.net: Who's afraid of a big bad optimizing compiler? - [160]

Areas

See also Games#Software, AI, Audio, etc.

• https://bithublab.org

Command-line

• WP: Read%E2%80%93eval%E2%80%93print_loop

Compression

• Data Compression Explained - Matt Mahoney

Network

• Beej's Guide to Network Programming - Using Internet Sockets

• WP: Distributed_hash_table

• https://news.ycombinator.com/item?id=8565161

• https://news.ycombinator.com/item?id=8674825

Graphics

• YouTube: How "oldschool" graphics worked. [161]

• http://www.objc.io/issue-3/moving-pixels-onto-the-screen.html

• http://www.johncostella.com/magic/ [162]

• http://devmag.org.za/2012/07/29/how-to-choose-colours-procedurally-algorithms/

• https://www.libavg.de/site/projects/libavg/wiki

• http://pixelshaders.com/
  • http://pixelshaders.com/proposal/

• http://doc-ok.org/?p=1057 [163]

• http://opensurfaces.cs.cornell.edu/ [164]

• http://mattdesl.svbtle.com/drawing-lines-is-hard [165]

• http://patriciogonzalezvivo.com/2015/thebookofshaders/ [166]

3D

• YouTube: Principles of Lighting and Rendering with John Carmack at QuakeCon 2013

• http://fabiensanglard.net/rayTracing_back_of_business_card/index.php

• http://programmers.stackexchange.com/questions/60544/why-do-game-developers-prefer-windows/88055#88055

• http://adriansampson.net/blog/opengl.html [167]

• http://antongerdelan.net/opengl/

Virtual / augmented reality

• http://www.hitl.washington.edu/people/person.php?name=tfurness
  • WP: Thomas_A._Furness_III

• WP: X_Reality_(XR) - defined as: a form of “mixed reality environment that comes from the fusion (union) of ... ubiquitous sensor/actuator networks and shared online virtual worlds....”. It encompasses a wide spectrum of hardware and software, including sensory interfaces, applications, and infrastructures, that enable content creation for virtual reality (VR), mixed reality (MR), augmented reality (AR), cinematic reality (CR). With these tools, users generate new forms of reality by bringing digital objects into the physical world and bringing physical world objects into the digital world.Its meaning has more recently been broadened to include technologies of extended ("cyborg" or wearable) intelligence in regards to the IEEE Council on Extended Intelligence (CXI).

Distributed

• WP: Distributed_computing

• https://github.com/madd86/awesome-system-design - A curated list of awesome System Design (A.K.A. Distributed Computing) resources.

• WP: Computer_cluster

• WP: Single_system_image

• WP: CAP_theorem

• https://github.com/henryr/cap-faq [168]

• https://research.microsoft.com/en-us/people/mickens/thesaddestmoment.pdf [169]

• http://the-paper-trail.org/blog/distributed-systems-theory-for-the-distributed-systems-engineer/ [170]

• https://www.youtube.com/watch?v=1eew8BngN7Y#t=3m14s

• https://news.ycombinator.com/item?id=10446835

• http://jvns.ca/blog/2016/02/09/til-clock-skew-exists

• https://pdfs.semanticscholar.org/d00b/0af865c0ee7389ecbf0be09044e569dbcfee.pdf

Virus

• http://www.symantec.com/avcenter/reference/hunting.for.metamorphic.pdf [171]

• https://vxheaven.org/ [172]

Social

• http://snipplr.com/

• https://couchdb.apache.org/conduct.html

• WP: Authorization

• https://news.ycombinator.com/item?id=11151790

to sort

• https://github.com/grahamjenson/list_of_recommender_systems

For kids

Scratch

• http://scratch.mit.edu/
• http://ase.tufts.edu/DevTech/ScratchJr/ScratchJrHome.asp
• http://programmingisterrible.com/post/76953953784/programming-with-building-blocks

• https://scratch.mit.edu/discuss/topic/326861 [173]

Snap

• http://snap.berkeley.edu/

• https://news.ycombinator.com/item?id=17056444

to sort

• http://www.robomind.net/en/index.html
  • http://www.in-the-attic.co.uk/2012/10/04/teaching-my-5-year-old-daughter-to-code/
• http://dancali.io/blog/a-74-step-account-of-my-7-year-old-daughters-first-programming-experience [174]

• http://www.sesameworkshop.org/our-blog/2012/12/17/sesames-best-practices-guide-for-childrens-app-development/

• http://blog.minibloq.org/

• http://squeak.org/ - smalltalk

• WP: ToonTalk

• https://www.alice.org/

• http://www.aisforarray.com/

• https://github.com/maryrosecook/islaclj

• http://www.gethopscotch.com/

• https://www.makewonder.com/ - robot

• https://news.ycombinator.com/item?id=8127491

• http://www.bbc.co.uk/news/technology-28984411

• http://changelog.complete.org/archives/9269-my-boys-love-1986-computing [175]

• http://www.nicolasbize.com/blog/30-years-later-qbasic-is-still-the-best/ [176]

• http://blog.makewonder.com/evolution-programming-for-kids/ [177]

Future

• Alan Kay: Doing with Images Makes Symbols Pt 1 (1987) 1 - 3

• Learnable Programming - Designing a programming system for understanding programs - Bret Victor

• "The Future of Programming" - Bret Victor
  • http://glamour-and-discourse.blogspot.ch/p/the-future-of-programming-bret-victor.html

• http://www.omarrizwan.com/cruncher/ [178] - bret victor inspired

• http://blog.comealive.io/Working-Toward-Bret-Victors-Learnable-Programming/ [179]

• http://www.vpri.org/pdf/tr2014003_callbymeaning.pdf [180]

• The Future Programming Manifesto [181]

• https://github.com/witheve/Eve
  • https://news.ycombinator.com/item?id=10073578

• Ask HN: Which people and groups are researching new approaches to programming?

• http://blog.csta.acm.org/2015/10/01/accesscs10k-quorum-programming-language-and-evidence-oriented-programming/ [182]

• Studying the Language and Structure in Non-Programmers’ Solutions to Programming Problems [183] / https://news.ycombinator.com/item?id=11513818

• The future of software, the end of apps, and why UX designers should care about type theory [184]

• http://unisonweb.org/2015-05-07/about.html#post-start

• https://blog.ycombinator.com/harc [185]

• The Phenomenal World | The "Next Big Thing" is a Room

• https://github.com/pel-daniel/mind-bicycles - List of future of programming projects

• https://news.ycombinator.com/item?id=24581674

Performance

• http://www.networkperformancedaily.com/

• http://searchenterpriselinux.techtarget.com/definition/high-performance-computing

• http://flowvr.sourceforge.net/FlowVROverview.html

• WP: Cyclomatic_complexity - a software metric (measurement), used to indicate the complexity of a program. It is a quantitative measure of the number of linearly independent paths through a program's source code. It was developed by Thomas J. McCabe, Sr. in 1976.

• WP: LINPACK_benchmarks - a measure of a system's floating-point computing power. Introduced by Jack Dongarra, they measure how fast a computer solves a dense n by n system of linear equations Ax = b, which is a common task in engineering. The latest version of these benchmarks is used to build the TOP500 list, ranking the world's most powerful supercomputers. The aim is to approximate how fast a computer will perform when solving real problems. It is a simplification, since no single computational task can reflect the overall performance of a computer system. Nevertheless, the LINPACK benchmark performance can provide a good correction over the peak performance provided by the manufacturer. The peak performance is the maximal theoretical performance a computer can achieve, calculated as the machine's frequency, in cycles per second, times the number of operations per cycle it can perform. The actual performance will always be lower than the peak performance. The performance of a computer is a complex issue that depends on many interconnected variables. The performance measured by the LINPACK benchmark consists of the number of 64-bit floating-point operations, generally additions and multiplications, a computer can perform per second, also known as FLOPS. However, a computer's performance when running actual applications is likely to be far behind the maximal performance it achieves running the appropriate LINPACK benchmark.

• TOP500 - The TOP500 project was launched in 1993 to improve and renew the Mannheim supercomputer statistics, which had been in use for seven years. Our simple TOP500 approach does not define “supercomputer” as such, but we use a benchmark to rank systems and to decide on whether or not they qualify for the TOP500 list. The benchmark we decided on was Linpack, which means that systems are ranked only by their ability to solve a set of linear equations, A x = b, using a dense random matrix A. Therefore, any supercomputer – no matter what its architecture is – can make it into the TOP500 list, as long as it is able to solve a set of linear equations using floating point arithmetic. We have been criticized for this choice from the very beginning, but now, after 20 years, we can say that it was exactly this choice that has made TOP500 so successful – Linpack therefore was a good choice. And there was, and still is, no alternative to Linpack. Any other benchmark would have been similarly specific, but would not have been so easily available for all systems – a very important factor, as compiling the TOP500 lists twice a year is a very complex process.

Quantum computing

• http://math.nist.gov/quantum/zoo/

• How the quantum search algorithm works -

• https://www.youtube.com/playlist?list=PL1826E60FD05B44E4

• https://news.ycombinator.com/item?id=8421263

• http://www.bristol.ac.uk/physics/research/quantum/qcloud

• http://news.mit.edu/2015/3q-scott-aaronson-google-quantum-computing-paper-1211

• https://news.ycombinator.com/item?id=13559391

• https://news.ycombinator.com/item?id=16797193

• https://github.com/QCGPU/qcgpu-rust - Open Source, High Performance & Hardware Accelerated, Quantum Computer Simulation in Rust [186]

Cool

• YouTube: RiftSketch: Live coding in VR with the Oculus Rift, Firefox WebVR, JavaScript and Three.js https://news.ycombinator.com/item?id=8411638

• https://news.ycombinator.com/item?id=11510649

• https://cosmicos.github.io/index.html

• Quine Relay is a Ruby program that generates Scala program that generates Scheme program that generates ...(through 50 languages)... REXX program that generates the original Ruby code again.
  • https://github.com/SilasX/QuineRelayFiles/tree/master/output_files
• http://mamememo.blogspot.ca/2010/09/qlobe.html

• https://github.com/mame/radiation-hardened-quine

• http://runme.org/

• http://www.digitalcraft.org/?artikel_id=292 - elegant fork bomb
  • https://stackoverflow.com/questions/21186724/why-is-whitespace-needed-for-this-to-be-parsed

• Computer programming as an art [187]

• http://c2.com/cgi/wiki?PerlPoetry
• WP: Black_Perl [188]
• http://www.perlmonks.org/?node=Perl%20Poetry
• http://www.perlmonks.org/?node_id=45213
• WP: Just_another_Perl_hacker

• WP: Mez_Breeze#Code_poetry
• WP: Software_art

• WP: Obfuscated_code#Recreational_obfuscation
• WP: International_Obfuscated_C_Code_Contest
• WP: Obfuscated_Perl_Contest

• WP: Live_coding

• http://www.ibm.com/developerworks/linux/library/l-japh/index.html

• http://ruben.verborgh.org/blog/2013/02/21/programming-is-an-art/
• https://blooki.st/BlookElement/ShowTextPhoto?blookElementId=1962

• http://www.ioccc.org/1990/westley.c [189]

• http://code-poems.com/
  • http://www.wired.co.uk/news/archive/2012-10/12/code-poems-book

• https://github.com/airbnb/javascript/issues/102

• http://stanford.edu/~mkagen/codepoetryslam/#1.0_wu
  • http://news.stanford.edu/news/2013/december/code-poetry-slam-122013.html

• https://codegolf.stackexchange.com/questions/18093/write-an-aphorism-using-valid-code/ [190]

• http://jsbin.com/OhisIQAW/1/edit [191]

• https://news.ycombinator.com/item?id=8305935

• https://github.com/inconvergent/differential-line [192]

• https://news.ycombinator.com/item?id=10478248

• http://tamahive.spritesserver.nl/ [193]

Humour

• A Brief, Incomplete, and Mostly Wrong History of Programming Languages
• http://tjathurman.tumblr.com/post/64695616290/molesworth-1
• The Evolution of a Programmer

• http://www.reddit.com/r/programmerhumor
• http://www.reddit.com/r/programminghorror
• http://www.reddit.com/r/ProgrammerCringe
• http://www.reddit.com/r/shittyprogramming/

• http://thedailywtf.com/
• http://codecrap.com/
• http://www.devsigh.com/

• http://twoproblems.com/

• What is your best programmer joke?
• http://stackoverflow.com/questions/184618/what-is-the-best-comment-in-source-code-you-have-ever-encountered

• http://ferd.ca/beating-the-cap-theorem-checklist.html

• https://news.ycombinator.com/item?id=7036214

• https://github.com/reinderien/mimic

• https://news.ycombinator.com/item?id=12949114