Computing
to very much further sort and understand.
General
- 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
Eric Steven Raymond;
- Pipe Logic - "In this model, a UNIX pipe acts like a wire, that is, a conductor with parasitic capacitance."
- 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
- The 5 Hardest Parts of Programming - Optimization, Networking, Security, Reliability, Scalability
Reference
- http://stackoverflow.com/
- StackMonthly - A monthly digest of the best questions on StackOverflow
- Hyperpolyglot - a programming language side-by-side reference sheet
- http://rosettacode.org/wiki/Rosetta_Code
- A Very Quick Comparison of Popular Languages for Teaching Computer Programming
- syntax across languages
- http://helloworldquiz.com/
- How do we tell truths that might hurt? - E.W. Dijkstra
- YourLanguageSucks
- 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.
- wikipedia:Backus%E2%80%93Naur_Form notation, for context-free syntax grammar
- The Packrat Parsing and Parsing Expression Grammars Page
- http://lee-phillips.org/lispmath/
- http://www.evanmiller.org/mathematical-hacker.html
- http://www.the-adam.com/adam/rantrave/st02.pdf
Books
- https://github.com/vhf/free-programming-books/blob/master/free-programming-books.md
- http://hackershelf.com/
- http://en.wikibooks.org/wiki/Computer_Programming
- WikiBooks: A-level Computing/AQA/Problem Solving, Programming, Operating Systems, Databases and Networking/Programming Concepts
- 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/
News and Blogs
Computation
- https://en.wikipedia.org/wiki/Computer
- https://en.wikipedia.org/wiki/Computing
- https://en.wikipedia.org/wiki/Digital_computer
See also Maths#Logic, Hardware
- https://en.wikipedia.org/wiki/Theory_of_computation - branch that deals with how efficiently problems can be solved on a model of computation, using an algorithm. The field is divided into three major branches: automata theory and language, computability theory, and computational complexity theory.
- https://en.wikipedia.org/wiki/Model_of_computation - the definition of the set of allowable operations used in computation and their respective costs. It is used for measuring the complexity of an algorithm in execution time and or memory space: by assuming a certain model of computation, it is possible to analyze the computational resources required or to discuss the limitations of algorithms or computers.
- https://en.wikipedia.org/wiki/Abstract_machine - abstract machines are often used in thought experiments regarding computability or to analyze the complexity of algorithms (see computational complexity theory). A typical abstract machine consists of a definition in terms of input, output, and the set of allowable operations used to turn the former into the latter. The best-known example is the Turing machine.
- https://en.wikipedia.org/wiki/File:Theoretical_computer_science.svg - Relationship between complexity theory, formal languages and computability theory.
- Theory of Computing - An Open Access Electronic Journal in Theoretical Computer Science
People
Automata theory
- https://en.wikipedia.org/wiki/Automata_theory - the study of abstract machines and automata, as well as the computational problems that can be solved using them. It is a theory in theoretical computer science, under discrete mathematics (a subject of study in both mathematics and computer science). The word automata (the plural of automaton) comes from the Greek word αὐτόματα, which means "self-acting".
Automata theory is closely related to formal language theory. An automaton is a finite representation of a formal language that may be an infinite set. Automata are often classified by the class of formal languages they can recognize. Automata play a major role in theory of computation, compiler construction, artificial intelligence, parsing and formal verification.
- YouTube: Computers Without Memory - Computerphile - They're called 'Finite State Automata" and occupy the centre of Chomsky's Hierarchy - Professor Brailsford explains the ultimate single purpose computer.
- https://en.wikipedia.org/wiki/Nondeterministic_finite_automaton
- https://en.wikipedia.org/wiki/Nondeterministic_finite_automaton_with_%CE%B5-moves
- https://en.wikipedia.org/wiki/Pushdown_automaton - type of automaton that employs a stack.
- https://en.wikipedia.org/wiki/%CE%A9-automaton
- https://en.wikipedia.org/wiki/Probabilistic_automaton
- https://en.wikipedia.org/wiki/Nested_stack_automaton - a finite automaton that can make use of a stack containing data which can be additional stacks.[1] Like a stack automaton, a nested stack automaton may step up or down in the stack, and read the current symbol; in addition, it may at any place create a new stack, operate on that one, eventually destroy it, and continue operating on the old stack. This way, stacks can be nested recursively to an arbitrary depth; however, the automaton always operates on the innermost stack only.
- https://en.wikipedia.org/wiki/Register_machine - a generic class of abstract machines used in a manner similar to a Turing machine. All the models are Turing equivalent.
- https://en.wikipedia.org/wiki/Mealy_machine
- https://en.wikipedia.org/wiki/Moore_machine - a finite-state machine whose output values are determined solely by its current state
Cellular automaton
- https://en.wikipedia.org/wiki/Cellular_automaton
- Cellular Automata - The mathematics of how life works
- https://code.google.com/p/ruletablerepository/
- https://en.wikipedia.org/wiki/Elementary_cellular_automaton - one-dimensional cellular automaton where there are two possible states (labeled 0 and 1) and the rule to determine the state of a cell in the next generation depends only on the current state of the cell and its two immediate neighbors
- https://en.wikipedia.org/wiki/Wolfram_code
- https://en.wikipedia.org/wiki/Reversible_cellular_automaton
- https://en.wikipedia.org/wiki/Block_cellular_automaton
- https://en.wikipedia.org/wiki/Second-order_cellular_automaton
- https://en.wikipedia.org/wiki/Billiard-ball_computer
- https://en.wikipedia.org/wiki/Stochastic_cellular_automaton
- https://en.wikipedia.org/wiki/Asynchronous_cellular_automaton
- https://en.wikipedia.org/wiki/Von_Neumann_cellular_automata
- https://en.wikipedia.org/wiki/Codd%27s_cellular_automaton
- https://en.wikipedia.org/wiki/Langton%27s_loops
- https://en.wikipedia.org/wiki/Nobili_cellular_automata
- https://en.wikipedia.org/wiki/Cyclic_cellular_automaton
- Game of Life
- https://en.wikipedia.org/wiki/Moore_neighborhood
- https://en.wikipedia.org/wiki/Speed_of_light_(cellular_automaton)
- https://en.wikipedia.org/wiki/Life-like_cellular_automaton
- https://en.wikipedia.org/wiki/Movable_cellular_automaton
- https://en.wikipedia.org/wiki/Continuous_automaton
- https://en.wikipedia.org/wiki/Continuous_spatial_automaton
- https://en.wikipedia.org/wiki/Lattice_gas_automaton
- https://en.wikipedia.org/wiki/Quantum_cellular_automata
- https://en.wikipedia.org/wiki/Quantum_dot_cellular_automata
Computability theory
to sort
See also Maths#Type theory
- https://en.wikipedia.org/wiki/Computability_theory - also called recursion theory, is a branch of mathematical logic, of computer science, and of the theory of computation that originated in the 1930s with the study of computable functions and Turing degrees.
The basic questions addressed by recursion theory are "What does it mean for a function on the natural numbers to be computable?" and "How can noncomputable functions be classified into a hierarchy based on their level of noncomputability?". The answers to these questions have led to a rich theory that is still being actively researched. The field has since grown to include the study of generalized computability and definability.
- Chomsky Hierarchy - Computerphile - Uncomputable through to finite state - Professor Brailsford explains Chomsky's hierarchy.
- Same Story, Different Notation - Computerphile - Finite State Automata meets Recursion. Professor Brailsford continues the story of computers without memory.
- https://en.wikipedia.org/wiki/Recursive_set - a set of natural numbers is called recursive, computable or decidable if there is an algorithm which terminates after a finite amount of time and correctly decides whether or not a given number belongs to the set. A more general class of sets consists of the recursively enumerable sets, also called semidecidable sets. For these sets, it is only required that there is an algorithm that correctly decides when a number is in the set; the algorithm may give no answer (but not the wrong answer) for numbers not in the set. A set which is not computable is called noncomputable or undecidable.
- https://en.wikipedia.org/wiki/Recursively_enumerable_language
- https://en.wikipedia.org/wiki/RE_(complexity)
- https://en.wikipedia.org/wiki/Recursively_enumerable_set - a set S of natural numbers is called recursively enumerable, computably enumerable, semidecidable, provable or Turing-recognizable if: There is an algorithm such that the set of input numbers for which the algorithm halts is exactly S, or equivalently; There is an algorithm that enumerates the members of S. That means that its output is simply a list of the members of S: s1, s2, s3, ... . If necessary, this algorithm may run forever. The first condition suggests why the term semidecidable is sometimes used; the second suggests why computably enumerable is used. The abbreviations r.e. and c.e. are often used, even in print, instead of the full phrase. In computational complexity theory, the complexity class containing all recursively enumerable sets is RE.
- https://en.wikipedia.org/wiki/Computable_function - the basic objects of study in computability theory. Computable functions are the formalized analogue of the intuitive notion of algorithm. They are used to discuss computability without referring to any concrete model of computation such as Turing machines or register machines. Any definition, however, must make reference to some specific model of computation but all valid definitions yield the same class of functions. Particular models of computability that give rise to the set of computable functions are the Turing-computable functions and the μ-recursive functions.
- https://en.wikipedia.org/wiki/Church%E2%80%93Turing_thesis - states that recursion, lambda calculus and the Turing machine are equivalent
- https://en.wikipedia.org/wiki/Turing_degree - or degree of unsolvability of a set of natural numbers measures the level of algorithmic unsolvability of the set. The concept of Turing degree is fundamental in computability theory, where sets of natural numbers are often regarded as decision problems; the Turing degree of a set tells how difficult it is to solve the decision problem associated with the set. That is, to determine whether an arbitrary number is in the given set.
- https://en.wikipedia.org/wiki/Curry–Howard_correspondence - the direct relationship between computer programs and mathematical proofs. It is a generalization of a syntactic analogy between systems of formal logic and computational calculi that was first discovered by the American mathematician Haskell Curry and logician William Alvin Howard.
- The Holy Trinity - "The doctrine of computational trinitarianism holds that computation manifests itself in three forms: proofs of propositions, programs of a type, and mappings between structures. These three aspects give rise to three sects of worship: Logic, which gives primacy to proofs and propositions; Languages, which gives primacy to programs and types; Categories, which gives primacy to mappings and structures. The central dogma of computational trinitarianism holds that Logic, Languages, and Categories are but three manifestations of one divine notion of computation. There is no preferred route to enlightenment: each aspect provides insights that comprise the experience of computation in our lives."
- Physics, Topology, Logic and Computation: A Rosetta Stone [8] - "In physics, Feynman diagrams are used to reason about quantum processes. In the 1980s, it became clear that underlying these diagrams is a powerful analogy between quantum physics and topology: namely, a linear operator behaves very much like a "cobordism". Similar diagrams can be used to reason about logic, where they represent proofs, and computation, where they represent programs. With the rise of interest in quantum cryptography and quantum computation, it became clear that there is extensive network of analogies between physics, topology, logic and computation. In this expository paper, we make some of these analogies precise using the concept of "closed symmetric monoidal category". We assume no prior knowledge of category theory, proof theory or computer science."
- https://en.wikipedia.org/wiki/μ-recursive_function - class of partial functions from natural numbers to natural numbers which are "computable" in an intuitive sense
- https://en.wikipedia.org/wiki/Primitive_recursive_function - class of functions defined using primitive recursion and composition as central operations, strict subset of the total µ-recursive functions
- https://en.wikipedia.org/wiki/Grzegorczyk_hierarchy - a hierarchy of functions used in computability theory (Wagner and Wechsung 1986:43). Every function in the Grzegorczyk hierarchy is a primitive recursive function, and every primitive recursive function appears in the hierarchy at some level. The hierarchy deals with the rate at which the values of the functions grow; intuitively, functions in lower level of the hierarchy grow slower than functions in the higher levels.
- https://en.wikipedia.org/wiki/Higher-order_function
- https://en.wikipedia.org/wiki/Fixed_point_combinator
- Where LISP Fits - [10] - "These simplifications made LISP into a way of describing computable functions much neater than the Turing machines or the general recursive definitions used in recursive function theory. The fact that Turing machines constitute an awkward programming language doesn’t much bother recursive function theorists, because they almost never have any reason to write particular recursive definitions, since the theory concerns recursive functions in general. They often have reason to prove that recursive functions with specific properties exist, but this can be done by an informal argument without having to write them down explicitly. In the early days of computing, some people developed programming languages based on Turing machines; perhaps it seemed more scientific. Anyway, I decided to write a paper describing LISP both as a programming language and as a formalism for doing recursive function theory."
- http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-fall-2010/video-lectures/ [11]
Turing machine
- http://en.wikipedia.org/wiki/Turing_machine - FSM with two stacks (left and right on tape)
- http://en.wikipedia.org/wiki/Turing_completeness
- http://www.felienne.com/?p=2974
- http://beza1e1.tuxen.de/articles/accidentally_turing_complete.html
- https://news.ycombinator.com/item?id=6693653
- https://en.wikipedia.org/wiki/Langton%27s_ant - a two-dimensional Turing machine with a very simple set of rules but complicated emergent behavior. It was invented by Chris Langton in 1986 and runs on a square lattice of black and white cells. The universality of Langton's ant was proven in 2000. The idea has been generalized in several different ways, such as turmites which add more colors and more states. [13]
Lambda calculus
- http://www.reddit.com/r/learnprogramming/comments/xzs76/lambda_calculus_explained_in_the_simplest_terms/c5r6otq
- http://www.reddit.com/r/compsci/comments/1t9yiv/does_anybody_know_of_a_good_text_book_for/
- https://en.wikipedia.org/wiki/Typed_lambda_calculus
- https://en.wikipedia.org/wiki/Simply_typed_lambda_calculus
- https://en.wikipedia.org/wiki/SKI_combinator_calculus
- https://en.wikipedia.org/wiki/%CE%BC-recursive%20function
- https://en.wikipedia.org/wiki/Lambda-mu_calculus
- https://en.wikipedia.org/wiki/System_F
- http://stackoverflow.com/questions/93526/what-is-a-y-combinator
- http://www.confreaks.com/videos/1287-rubyconf2012-y-not-adventures-in-functional-programming
- https://en.wikipedia.org/wiki/Process_calculus - or process algebras) are a diverse family of related approaches for formally modelling concurrent systems. Process calculi provide a tool for the high-level description of interactions, communications, and synchronizations between a collection of independent agents or processes. They also provide algebraic laws that allow process descriptions to be manipulated and analyzed, and permit formal reasoning about equivalences between processes (e.g., using bisimulation). Leading examples of process calculi include CSP, CCS, ACP, and LOTOS.[1] More recent additions to the family include the π-calculus, the ambient calculus, PEPA, the fusion calculus and the join-calculus
Computational complexity
- https://en.wikipedia.org/wiki/Blum_axioms
- https://en.wikipedia.org/wiki/Gap_theorem
- https://en.wikipedia.org/wiki/Blum%27s_speedup_theorem
- https://en.wikipedia.org/wiki/Decision_problem - a question in some formal system with a yes-or-no answer
- https://en.wikipedia.org/wiki/Complexity_class
- https://en.wikipedia.org/wiki/List_of_complexity_classes
- https://en.wikipedia.org/wiki/Big_O_notation
- SO: Plain English explanation of Big O
- https://en.wikipedia.org/wiki/Time_complexity
- https://en.wikipedia.org/wiki/Polynomial_expression
- https://en.wikipedia.org/wiki/NP_(complexity)
- https://en.wikipedia.org/wiki/Halting_Problem
- Scooping The Loop Snooper - A proof that the Halting Problem is undecidable
to sort
- https://en.wikipedia.org/wiki/Semantics_(computer_science) - rigorous mathematical study of the meaning of programming languages by evaluating the meaning of syntactically legal strings
- https://en.wikipedia.org/wiki/Denotational_semantics - approach of formalizing the meanings of programming languages by constructing mathematical objects (called denotations) that describe the meanings of expressions from the languages
- https://en.wikipedia.org/wiki/Operational_semantics - certain desired properties of a program, such as correctness, safety or security, are verified by constructing proofs from logical statements about its execution and procedures
- https://en.wikipedia.org/wiki/Axiomatic_semantics - define the meaning of a command in a program by describing its effect on assertions about the program state
- https://en.wikipedia.org/wiki/Algebraic_semantics_(computer_science) - a form of axiomatic semantics based on algebraic laws for describing and reasoning about program semantics in a formal manner.
- http://en.wikipedia.org/wiki/Programming_language_theory
- http://en.wikipedia.org/wiki/Automatic_programming
- https://www.youtube.com/watch?v=AD4b-52jtos&list=PL2FF649D0C4407B30
- https://www.youtube.com/watch?v=2Op3QLzMgSY&list=PL8FE88AA54363BC46
- https://www.youtube.com/watch?v=EKWGGDXe5MA&feature=youtu.be
Architecture
See also Electronics
- https://www.youtube.com/watch?v=Tg5gJxXBh8s 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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/Flynn's_taxonomy - a classification of computer architectures, proposed by Michael Flynn in 1966.[1][2] The classification system has stuck, and has been used as a tool in design of modern processors and their functionalities.
- 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.
Instructions
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/Opcode - the portion of a machine language instruction that specifies the operation to be performed.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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." [22]
Assembly
- https://en.wikipedia.org/wiki/Assembly_language - Human readable instructors to the assembler + data bytes + operators
- Rappel - assembly REPL. It works by creating a shell ELF, starting it under ptrace, then continiously rewriting/running the .text section, while showing the register states. It's maybe half done right now, and supports Linux x86, amd64, and armv7 (no thumb) at the moment. [25]
- https://en.wikipedia.org/wiki/Disassembler - a computer program that translates machine language into assembly language—the inverse operation to that of an assembler. A disassembler differs from a decompiler, which targets a high-level language rather than an assembly language. Disassembly, the output of a disassembler, is often formatted for human-readability rather than suitability for input to an assembler, making it principally a reverse-engineering tool.
- yasp is a fully functional web-based assembler development environment, including a real assembler, emulator and debugger. The assembler dialect is custom and very simple so as to keep the learning curve as shallow as possible. It also features some hardware-elements (LED, Potentiometer, Button, etc.). The goal of this project is to create an environment in which students can learn the assembly language so that they understand computers better. Furthermore it allows them to experiment without the fear of breaking something. The original project team of yasp consists of Robert Fischer and Michael "luto" Lutonsky. For more information take a look at the about-section in the IDEs menu. [29]
- Easy 6502 - how to get started writing 6502 assembly language. The 6502 processor was massive in the seventies and eighties, powering famous computers like the BBC Micro, Atari 2600, Commodore 64, Apple II, and the Nintendo Entertainment System. Bender in Futurama has a 6502 processor for a brain. Even the Terminator was programmed in 6502.
Processing
- https://en.wikipedia.org/wiki/Processor_(computing)#Computing
- https://en.wikipedia.org/wiki/Processor_design
CPU
- https://en.wikipedia.org/wiki/Microprocessor - a computer processor that incorporates the functions of a computer's central processing unit (CPU) on a single integrated circuit
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/Control_store - the part of a CPU's control unit that stores the CPU's microprogram. It is usually accessed by a microsequencer.
- https://en.wikipedia.org/wiki/Processor_register
- https://en.wikipedia.org/wiki/Memory_address_register
- https://en.wikipedia.org/wiki/Memory_data_register
- https://en.wikipedia.org/wiki/Register_renaming
- http://www.mikeash.com/pyblog/friday-qa-2013-10-11-why-registers-are-fast-and-ram-is-slow.html
- https://en.wikipedia.org/wiki/Instruction_pipeline
- http://lolengine.net/blog/2011/9/17/playing-with-the-cpu-pipeline [34]
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/Vector_processor - a central processing unit (CPU) that implements an instruction set containing instructions that operate on one-dimensional arrays of data called vectors
Coprocessor
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
DSP
FPGA
- http://forums.xilinx.com/t5/Embedded-Development-Tools/GPUs-vs-FPGAs/td-p/60112
- https://news.ycombinator.com/item?id=6305113
RISC
Power
- https://en.wikipedia.org/wiki/IBM_POWER_Instruction_Set_Architecture - older POWER ISA
RISC-V
- http://gigaom.com/2014/08/19/risc-creator-is-pushing-open-source-chips-for-cloud-computing-and-the-internet-of-things/ [38]
- 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 [39]
- 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.
CISC
x86
- https://news.ycombinator.com/item?id=7422703
- http://mainisusuallyafunction.blogspot.co.uk/2014/02/x86-is-turing-complete-with-no-registers.html [41]
- https://code.google.com/p/corkami/wiki/x86oddities
- http://www.cl.cam.ac.uk/~sd601/papers/mov.pdf [42]
- https://news.ycombinator.com/item?id=7680706
- https://en.wikipedia.org/wiki/Advanced_Vector_Extensions
GPU
GPGPU
- http://en.wikipedia.org/wiki/General-purpose_computing_on_graphics_processing_units
- http://gpgpu.org/
The Mill
- The Belt | Mill computing [47]
- The Mill - summary of first three talks
- http://ootbcomp.com/topic/introduction-to-the-mill-cpu-programming-model-2/ [48]
- https://en.wikipedia.org/wiki/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.
Memory
There are four major storage levels:
- Internal – Processor registers and cache.
- Main – the system RAM and controller cards.
- On-line mass storage – Secondary storage.
- Off-line bulk storage – Tertiary and Off-line storage.
- https://en.wikipedia.org/wiki/Random-access_memory
- https://en.wikipedia.org/wiki/Static_random-access_memory
- https://en.wikipedia.org/wiki/Dynamic_random-access_memory
- https://en.wikipedia.org/wiki/Synchronous_dynamic_random-access_memory
- https://en.wikipedia.org/wiki/DDR_SDRAM
- https://en.wikipedia.org/wiki/Nearline_storage - For example, always-on spinning hard disk drives are online storage, while spinning drives that spin down automatically, such as in massive arrays of idle disks (MAID), are nearline storage.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/Paging - a memory management scheme by which a computer stores and retrieves data from secondary storage[a] for use in main memory.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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,
- https://en.wikipedia.org/wiki/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
- http://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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).
- https://en.wikipedia.org/wiki/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://en.wikipedia.org/wiki/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?
- https://en.wikipedia.org/wiki/Pointer_aliasing - refers to the situation where the same memory location can be accessed using different names.
Storage
Other
Emulation
Security
ASIC
Operating system
See also *nix, Virtualisation, Distros, Android, Windows, Apple
- OSDev.org - wiki that provides information about the creation of operating systems and serves as a community for those people interested in OS creation
Kernel
Types
- Mirage OS is a library operating system that constructs unikernels for secure, high-performance network applications across a variety of cloud computing and mobile platforms. Code can be developed on a normal OS such as Linux or MacOS X, and then compiled into a fully-standalone, specialised unikernel that runs under the Xen hypervisor.
Implementations
See also *nix
- https://en.wikipedia.org/wiki/XNU - Darwin/OS X
Programming
See also Maths#Software_2
- Livecoding.tv - A livestreaming platform for coders to share their code and hang out
Syntax
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/Literal_(computer_programming) - a notation for representing a fixed value in source code. Almost all programming languages have notations for atomic values such as integers, floating-point numbers, and strings, and usually for booleans and characters; some also have notations for elements of enumerated types and compound values such as arrays, records, and objects. An anonymous function is a literal for the function type.
In contrast to literals, variables or constants are symbols that can take on one of a class of fixed values, the constant being constrained not to change. Literals are often used to initialize variables, for example, in the following, 1 is an integer literal and the three letter string in "cat" is a string literal:
int a = 1; String s = "cat";
In lexical analysis, literals of a given type are generally a token type, with a grammar rule, like "a string of digits" for an integer literal. Some literals are specific keywords, like true for the boolean literal "true". In some object-oriented languages (like ECMAScript), objects can also be represented by literals. Methods of this object can be specified in the object literal using function literals.
- https://en.wikipedia.org/wiki/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.
Data types
- https://en.wikipedia.org/wiki/Type_theory - any of a class of formal systems, some of which can serve as alternatives to set theory as a foundation for all mathematics. In type theory, every "term" has a "type" and operations are restricted to terms of a certain type.
- https://en.wikipedia.org/wiki/Data_type
- https://en.wikipedia.org/wiki/Type_system - a collection of rules that assign a property called a type to constructs such as variables, expressions, functions or modules—a computer program is composed of. reduces bugs by defining interfaces between different parts of a computer program, and then checking that the parts have been connected in a consistent way. This checking can happen statically (at compile time), dynamically (at run time), or as a combination thereof.
- https://en.wikipedia.org/wiki/Type_safety - the extent to which a programming language discourages or prevents type errors.
- https://en.wikipedia.org/wiki/Type_signature - type annotation defines the inputs and outputs for a function, subroutine or method.
- http://www.cs.unm.edu/~storm/C++/ProgrammingTerms/FunctionSignatures.html
- https://en.wikipedia.org/wiki/Type_conversion - typecasting, and coercion are different ways of, implicitly or explicitly, changing an entity of one data type into another. This is done to take advantage of certain features of type hierarchies or type representations. One example would be small integers, which can be stored in a compact format and converted to a larger representation when used in arithmetic computations. In object-oriented programming, type conversion allows programs to treat objects of one type as one of their ancestor types to simplify interacting with them.
- https://en.wikipedia.org/wiki/Type_inference - automatic deduction of the type of an expression in a programming language. If some, but not all, type annotations are already present it is referred to as type reconstruction. The opposite operation of type inference is called type erasure.
- https://en.wikipedia.org/wiki/Primitive_data_type - a basic type, often built-in, used as a building block for composite types
- https://en.wikipedia.org/wiki/Composite_data_type - any data type constructed using primitive data types and other composite types
- https://en.wikipedia.org/wiki/Object_composition - a way to combine simple objects or data types into more complex ones
- https://en.wikipedia.org/wiki/Type_constructor - feature of a typed formal language that builds new types from old, such as product types, function types, power types and list types
- https://en.wikipedia.org/wiki/Abstract_data_type - a mathematical model for data types where a data type is defined by its behavior (semantics) from the point of view of a user of the data, specifically in terms of possible values, possible operations on data of this type, and the behavior of these operations. This contrasts with data structures, which are concrete representations of data, and are the point of view of an implementer, not a user.
- https://en.wikipedia.org/wiki/Semaphore_(programming) - a variable or abstract data type that is used for controlling access, by multiple processes, to a common resource in a concurrent system such as a multiprogramming operating system. A trivial semaphore is a plain variable that is changed (for example, incremented or decremented, or toggled) depending on programmer-defined conditions. The variable is then used as a condition to control access to some system resource.
- The Little Book of Semaphores - a free (in both senses of the word) textbook that introduces the principles of synchronization for concurrent programming. [60] [61]
- https://en.wikipedia.org/wiki/Record_(computer_science) - also called struct or compound data, is a basic data structure. A record is a collection of fields, possibly of different data types, typically in fixed number and sequence. The fields of records may also be called elements, though these risk confusion with elements of a collection, or members, particularly in object-oriented programming. A tuple may or may not be considered a record, and vice versa, depending on conventions and the specific programming language.
- https://en.wikipedia.org/wiki/Tuple
- https://en.wikipedia.org/wiki/Dependent_type - a type that depends on a value
- https://en.wikipedia.org/wiki/Algebraic_data_type
- https://en.wikipedia.org/wiki/Product_type - a product of types is another, compounded, type in a structure. associated with logical conjunction (AND) in logic.
- https://en.wikipedia.org/wiki/Tagged_union - sum type. data structure used to hold a value that could take on several different, but fixed types. Only one of the types can be in use at any one time, and a tag field explicitly indicates which one is in use.
- https://en.wikipedia.org/wiki/Recursive_data_type - inductive data type, a data type for values that may contain other values of the same type. Data of recursive types are usually viewed as directed graphs.
- https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system
- http://c2.com/cgi/wiki?HindleyMilnerTypeInference
- http://www.lispcast.com/Hindley-Milner-in-Clojure [62]
- https://en.wikipedia.org/wiki/Duck_typing - style of typing in which an object's methods and properties determine the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface
- https://en.wikipedia.org/wiki/Latent_typing - type system where types are associated with values and not variables, requires run-time type checking
- https://en.wikipedia.org/wiki/Substructural_type_system - family of type systems analogous to substructural logics where one or more of the structural rules are absent or allowed under controlled circumstances. Such systems are useful for constraining access to system resources such as files, locks and memory by keeping track of changes of state that occur and preventing invalid states
- https://en.wikipedia.org/wiki/Type_constructor - a feature of a typed formal language that builds new types from old
Numbers
- https://en.wikipedia.org/wiki/Floating_point
- http://0.30000000000000004.com/ [64]
- Floating Point - Computerphile
- http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0491c/Babbfeda.html
- http://randomascii.wordpress.com/2014/01/27/theres-only-four-billion-floatsso-test-them-all/ [65]
Data structures
- http://www.cs.usfca.edu/~galles/visualization/Algorithms.html [67]
- http://en.wikipedia.org/wiki/Hash_table
- http://en.wikipedia.org/wiki/Array_data_structure
- http://en.wikipedia.org/wiki/Array_data_type
- http://en.wikipedia.org/wiki/Associative_array
- http://en.wikipedia.org/wiki/Set_data_structure
- http://en.wikipedia.org/wiki/Abstract_semantic_graph
- http://en.wikipedia.org/wiki/Bit_string
- http://en.wikipedia.org/wiki/Tree_(data_structure)
- http://en.wikipedia.org/wiki/Binary_tree
- http://en.wikipedia.org/wiki/Binary_search_tree
- http://en.wikipedia.org/wiki/B-tree
- http://en.wikipedia.org/wiki/Rope_%28data_structure%29
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.xanadu.com/zigzag/
- YouTube: Ted Nelson on Zigzag data structures - relationship vector, hyperthoginal
- http://en.wikipedia.org/wiki/Continuation
- http://en.wikipedia.org/wiki/Continuation-passing_style
- http://matt.might.net/articles/cps-conversion/
Mutability
Polymorphism
- https://en.wikipedia.org/wiki/Polymorphism_(computer_science) - the provision of a single interface to entities of different types
- https://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming
- https://en.wikipedia.org/wiki/Subtyping
Evaluation
An expression evaluates to a value. A statement does something.
x = 1 y = x + 1 # an expression print y # a statement, prints 2
- http://en.wikipedia.org/wiki/Evaluation_strategy
- http://en.wikipedia.org/wiki/Expression-oriented_programming_language
- http://en.wikipedia.org/wiki/Referential_transparency_(computer_science)
- http://en.wikipedia.org/wiki/Side_effect_(computer_science)
- http://en.wikipedia.org/wiki/Information_hiding
- http://en.wikipedia.org/wiki/Conditional_(computer_programming)
- http://en.wikipedia.org/wiki/Call_stack
- http://en.wikipedia.org/wiki/First-class_citizen
- http://en.wikipedia.org/wiki/Non-strict_programming_language
- http://en.wikipedia.org/wiki/Scope_(computer_science)
- http://stackoverflow.com/questions/6441218/can-a-local-variables-memory-be-accessed-outside-its-scope/6445794#6445794
- http://en.wikipedia.org/wiki/Recursion_(computer_science)
- How recursion got into programming: a comedy of errors [71]
- http://en.wikipedia.org/wiki/Modulo_operation
- Vimeo: Impossible Programs - Scottish Ruby Conf
Operators
- https://en.wikipedia.org/wiki/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.
Functions
- http://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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:[1] 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.[b] 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.
- http://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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.
- http://en.wikipedia.org/wiki/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://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspondence
- http://en.wikipedia.org/wiki/Currying
Control structures
- https://en.wikipedia.org/wiki/Conditional_(programming)
- https://en.wikipedia.org/wiki/Switch_statement
- https://en.wikipedia.org/wiki/For_loop
- https://en.wikipedia.org/wiki/While_loop
- https://en.wikipedia.org/wiki/Do_while_loop
- https://en.wikipedia.org/wiki/Foreach_loop
- https://en.wikipedia.org/wiki/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
Algorithms
See also Maths
- https://en.wikipedia.org/wiki/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.algosort.com/
- https://en.wikipedia.org/wiki/List_of_algorithms
- http://www.jjj.de/fxt/fxtpage.html#fxtbook [79]
- 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/ [80]
- http://www.comp.nus.edu.sg/~stevenha/visualization/ [81]
- 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/ [82]
- http://sorting.at/ [83]
- https://news.ycombinator.com/item?id=6093777 - bloom filters
- http://billmill.org/bloomfilter-tutorial/
Libraries
Module pattern
System calls
Concurrency
- https://en.wikipedia.org/wiki/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".
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/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.[1] 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.
- https://en.wikipedia.org/wiki/Deadlock - a situation in which two or more competing actions are each waiting for the other to finish, and thus neither ever does.
- https://en.wikipedia.org/wiki/Starvation_(computer_science) - where a process is perpetually denied necessary resources to process its work.
- https://en.wikipedia.org/wiki/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.
Macros
Metaprogramming
Monads
Aspect of functional. See Haskell, etc. for related.
Events
Messaging
See also Network#Messaging
- https://en.wikipedia.org/wiki/Message_queue - and mailboxes are software-engineering components used for interprocess communication, or for inter-thread communication within the same process.
- ØMQ \zeromq\
- The socket library that acts as a concurrency framework.
- Faster than TCP, for clustered products and supercomputing.
<tef> but glyph is the serialization format really :-)
- MessagePack is 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.
Futures and promises
Garbage collection
- Old New Thing: Everybody thinks about garbage collection the wrong way
Paradigms
- http://en.wikipedia.org/wiki/Structured_programming
- http://en.wikipedia.org/wiki/Procedural_programming
- http://en.wikipedia.org/wiki/Imperative_programming
Functional
- λ 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. [107]
- http://en.wikipedia.org/wiki/Functional_reactive_programming
- The introduction to Reactive Programming you've been missing [109]
- 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
- http://en.wikipedia.org/wiki/Applicative_programming_language
- http://en.wikipedia.org/wiki/Typed_lambda_calculus
- http://en.wikipedia.org/wiki/First-class_function
- 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
Object orientated
- https://en.wikipedia.org/wiki/Object_(computer_science)
- https://en.wikipedia.org/wiki/Class_(computer_science)
- https://en.wikipedia.org/wiki/Instance_(computer_science)
- https://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)
- https://en.wikipedia.org/wiki/Multiple_inheritance
- https://en.wikipedia.org/wiki/Prototype-based_programming
- https://en.wikipedia.org/wiki/Differential_inheritance
- https://en.wikipedia.org/wiki/Method_(computer_programming)
- https://en.wikipedia.org/wiki/Mutator_method
- https://en.wikipedia.org/wiki/Protocol_(object-oriented_programming)
- https://en.wikipedia.org/wiki/Delegation_(programming)
- https://en.wikipedia.org/wiki/Delegation_pattern
- https://en.wikipedia.org/wiki/Observer_pattern
- https://en.wikipedia.org/wiki/Template_method_pattern
- https://en.wikipedia.org/wiki/Factory_method_pattern
- https://en.wikipedia.org/wiki/Composite_pattern
- https://en.wikipedia.org/wiki/Decorator_pattern
- https://en.wikipedia.org/wiki/Mediator_pattern
- https://en.wikipedia.org/wiki/Adapter_pattern
- https://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29 - Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion
- https://plus.google.com/101960720994009339267/posts/hoJdanihKwb - rob pike on oo
- https://news.ycombinator.com/item?id=6909326
- http://harmful.cat-v.org/software/OO_programming/why_oo_sucks [113]
- http://prog21.dadgum.com/156.html
- YouTube: Object-Oriented Programming is Bad - Brian Will
- 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/
Patterns
See also Organisation#Patterns
- https://en.wikipedia.org/wiki/Design_pattern
- https://en.wikipedia.org/wiki/Software_design_pattern
- https://en.wikipedia.org/wiki/Architectural_pattern
- WikiWikiWeb - aka Wards Wiki
"ExtremeProgramming -- all programming is maintenance."
- http://blog.plover.com/prog/design-patterns.html
- http://www.mcdonaldland.info/files/designpatterns/designpatternscard.pdf
- http://en.wikipedia.org/wiki/Singleton_pattern - restrict the instantiation of a class to one object.
- https://programmers.stackexchange.com/questions/40373/so-singletons-are-bad-then-what
- http://en.wikipedia.org/wiki/Architectural_pattern_%28computer_science%29
- http://en.wikipedia.org/wiki/Common_layers_in_an_information_system_logical_architecture
- http://www.confreaks.com/videos/3337-railsconf-keynote-10-years - convention over configuration
MV*
- http://en.wikipedia.org/wiki/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
"create your views, express your models or develop a controller"
- http://martinfowler.com/eaaDev/PresentationModel.html
- http://en.wikipedia.org/wiki/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
Compilation and interpretation
to resort
- https://en.wikipedia.org/wiki/History_of_compiler_construction
- http://matt.might.net/articles/cps-conversion/
- https://en.wikipedia.org/wiki/Preprocessor - a program that processes its input data to produce output that is used as input to another program. The output is said to be a preprocessed form of the input data, which is often used by some subsequent programs like compilers. The amount and kind of processing done depends on the nature of the preprocessor; some preprocessors are only capable of performing relatively simple textual substitutions and macro expansions, while others have the power of full-fledged programming languages.
- https://en.wikipedia.org/wiki/Relocation_(computing) - the process of assigning load addresses to various parts of a program and adjusting the code and data in the program to reflect the assigned addresses. A linker usually performs relocation in conjunction with symbol resolution, the process of searching files and libraries to replace symbolic references or names of libraries with actual usable addresses in memory before running a program. Relocation is typically done by the linker at link time, but it can also be done at run time by a relocating loader, or by the running program itself. Some architectures avoid relocation entirely by deferring address assignment to run time; this is known as zero address arithmetic.
- https://en.wikipedia.org/wiki/Assembler_(computing) - creates object code by translating combinations of mnemonics and syntax for operations and addressing modes into their numerical equivalents. This representation typically includes an operation code ("opcode") as well as other control bits. The assembler also calculates constant expressions and resolves symbolic names for memory locations and other entities.[4] The use of symbolic references is a key feature of assemblers, saving tedious calculations and manual address updates after program modifications.
- https://en.wikipedia.org/wiki/Inline_assembler - a feature of some compilers that allows very low level code written in assembly to be embedded in a high level language like C or Ada.
- https://en.wikipedia.org/wiki/Compiler-compiler - or compiler generator is a programming tool that creates a parser, interpreter, or compiler from some form of formal description of a language and machine. The earliest and still most common form of compiler-compiler is a parser generator, whose input is a grammar (usually in BNF) of a programming language, and whose generated output is the source code of a parser often used as a component of a compiler.
The ideal compiler-compiler takes a description of a programming language and a target instruction set architecture, and automatically generates a usable compiler from them. In practice, the state of the art has yet to reach this degree of sophistication and most compiler generators are not capable of handling semantic or target architecture information.
- https://en.wikipedia.org/wiki/Interpreted_language
- https://en.wikipedia.org/wiki/Dynamic_programming_language
- https://en.wikipedia.org/wiki/Interpreter_(computing)
- https://en.wikipedia.org/wiki/Runtime_library - a set of low-level routines used by a compiler to invoke some of the behaviors of a runtime environment, by inserting calls to the runtime library into compiled executable binary. The runtime environment implements the execution model, built-in functions, and other fundamental behaviors of a programming language. During execution (run time) of that computer program, execution of those calls to the runtime library cause communication between the executable binary and the runtime environment. A runtime library often includes built-in functions for memory management or exception handling. Therefore, a runtime library is always specific to the platform and compiler.
pcc
- https://en.wikipedia.org/wiki/Portable_C_Compiler - an early compiler for the C programming language written by Stephen C. Johnson of Bell Labs in the mid-1970s, based in part on ideas proposed by Alan Snyder in 1973,[2][3] and "distributed as the C compiler by Bell Labs... with the blessing of Dennis Ritchie."
One of the first compilers that could easily be adapted to output code for different computer architectures, the compiler had a long life span. It debuted in Seventh Edition Unix and shipped with BSD Unix until the release of 4.4BSD in 1994, when it was replaced by the GNU C Compiler. It was very influential in its day, so much so that at the beginning of the 1980s, the majority of C compilers were based on it. Anders Magnusson and Peter A Jonsson restarted development of pcc in 2007, rewriting it extensively to support the C99 standard.
gcc
- GNU Compiler Collection includes front ends for C, C++, Objective-C, Fortran, Java, Ada, and Go, as well as libraries for these languages (libstdc++, libgcj,...). GCC was originally written as the compiler for the GNU operating system. The GNU system was developed to be 100% free software, free in the sense that it respects the user's freedom.
LLVM
- LLVM is a collection of modular and reusable compiler and toolchain technologies. Despite its name, LLVM has little to do with traditional virtual machines, though it does provide helpful libraries that can be used to build them. The name "LLVM" itself is not an acronym; it is the full name of the project.
- Emscripten is an LLVM to JavaScript compiler. It takes LLVM bitcode (which can be generated from C/C++ using Clang, or any other language that can be converted into LLVM bitcode) and compiles that into JavaScript, which can be run on the web (or anywhere else JavaScript can run).
Clang
- http://en.wikipedia.org/wiki/Clang - compiler front end for the C, C++, Objective-C, Objective-C++, OpenCL and CUDA programming languages. It uses LLVM as its back end and has been part of the LLVM release cycle since LLVM 2.6.
It is designed to offer a complete replacement to the GNU Compiler Collection (GCC). It is open-source,[4] and its contributors include Apple, Microsoft, Google, ARM, Sony, Intel and AMD. Its source code is available under the University of Illinois/NCSA License, a permissive free software licence.
Other
- Parrot is a virtual machine designed to efficiently compile and execute bytecode for dynamic languages. Parrot currently hosts a variety of language implementations in various stages of completion, including Tcl, Javascript, Ruby, Lua, Scheme, PHP, Python, Perl 6, APL, and a .NET bytecode translator. Parrot is not about parrots, though we are rather fond of them for obvious reasons.
- http://en.wikipedia.org/wiki/Lexical_analysis
- http://en.wikipedia.org/wiki/Syntax_analysis#Programming_languages
- http://en.wikipedia.org/wiki/Abstract_syntax_tree
- https://en.wikipedia.org/wiki/Yacc - a computer program for the Unix operating system. It is a LALR parser generator, generating a parser, the part of a compiler that tries to make syntactic sense of the source code, specifically a LALR parser, based on an analytic grammar written in a notation similar to BNF. Yacc itself used to be available as the default parser generator on most Unix systems, though it has since been supplanted as the default by more recent, largely compatible, programs.
- XMLVM is to offer a flexible and extensible cross-compiler toolchain. Instead of cross-compiling on a source code level, XMLVM cross-compiles byte code instructions from Sun Microsystem's virtual machine and Microsoft's Common Language Runtime. The benefit of this approach is that byte code instructions are easier to cross-compile and the difficult parsing of a high-level programming language is left to a regular compiler. In XMLVM, byte code-based programs are represented as XML documents. This allows manipulation and translation of XMLVM-based programs using advanced XML technologies such as XSLT, XQuery, and XPath.
History
- http://www.curtamania.com/curta/database/brand/olivetti/Olivetti%20Programma%20101/index.html - 1965 [126]
- https://en.wikipedia.org/wiki/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.
- https://en.wikipedia.org/wiki/Xerox_Star - 1981
- https://en.wikipedia.org/wiki/Pilot_(operating_system)
- YouTube: The Final Demonstration of the Xerox 'Star' computer [127]
- "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
- http://www.mission-base.com/tamiko/theory/cm_txts/di-frames.html - 1983
- http://en.wikipedia.org/wiki/Connection_Machine
People
Hacking
https://emily.st/2015/01/27/reverse-engineering/ [133]
Areas
Command-line
GUI
Compression
- Data Compression Explained - Matt Mahoney
Network
- Beej's Guide to Network Programming - Using Internet Sockets
Graphics
- YouTube: How "oldschool" graphics worked. [134]
3D
Audio
See also Audio#Programming
Distributed
- http://the-paper-trail.org/blog/distributed-systems-theory-for-the-distributed-systems-engineer/ [143]
NLP
Virus
Bots
Machine learning
- http://googleresearch.blogspot.be/2015/06/inceptionism-going-deeper-into-neural.html
- http://www.theguardian.com/technology/2015/jun/18/google-image-recognition-neural-network-androids-dream-electric-sheep
- https://317070.github.io/LSD/
- https://github.com/google/deepdream [150]
- http://ryankennedy.io/running-the-deep-dream/
- https://github.com/graphific/DeepDreamVideo [151]
Artificial intelligence
- OpenAI is a non-profit artificial intelligence research company. Our goal is to advance digital intelligence in the way that is most likely to benefit humanity as a whole, unconstrained by a need to generate financial return.
Since our research is free from financial obligations, we can better focus on a positive human impact. We believe AI should be an extension of individual human wills and, in the spirit of liberty, as broadly and evenly distributed as is possible safely.
The outcome of this venture is uncertain and the work is difficult, but we believe the goal and the structure are right. We hope this is what matters most to the best in the field. [157]
Gaming
- https://github.com/DaRaFF/jsgamewiki
- https://github.com/hughsk/game-modules/wiki/Modules
- http://html5gameengine.com/
Social
For kids
- http://scratch.mit.edu/
- http://ase.tufts.edu/DevTech/ScratchJr/ScratchJrHome.asp
- http://programmingisterrible.com/post/76953953784/programming-with-building-blocks
- http://www.robomind.net/en/index.html
- http://dancali.io/blog/a-74-step-account-of-my-7-year-old-daughters-first-programming-experience [161]
- http://squeak.org/ - smalltalk
Future
- Learnable Programming - Designing a programming system for understanding programs - Bret Victor
- "The Future of Programming" - Bret Victor
- http://www.omarrizwan.com/cruncher/ [163] - bret victor inspired
- http://blog.csta.acm.org/2015/10/01/accesscs10k-quorum-programming-language-and-evidence-oriented-programming/ [167]
Performance
Quantum
Cool
- 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.
- http://mamememo.blogspot.ca/2010/09/qlobe.html
- http://www.digitalcraft.org/?artikel_id=292 - elegant fork bomb
- http://c2.com/cgi/wiki?PerlPoetry
- https://en.wikipedia.org/wiki/Black_Perl [169]
- http://www.perlmonks.org/?node=Perl%20Poetry
- http://www.perlmonks.org/?node_id=45213
- https://en.wikipedia.org/wiki/Just_another_Perl_hacker
- https://en.wikipedia.org/wiki/Obfuscated_code#Recreational_obfuscation
- https://en.wikipedia.org/wiki/International_Obfuscated_C_Code_Contest
- https://en.wikipedia.org/wiki/Obfuscated_Perl_Contest
- http://ruben.verborgh.org/blog/2013/02/21/programming-is-an-art/
- https://blooki.st/BlookElement/ShowTextPhoto?blookElementId=1962
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/
- What is your best programmer joke?
- http://stackoverflow.com/questions/184618/what-is-the-best-comment-in-source-code-you-have-ever-encountered
to sort
- The language of languages - explains grammars and common notations for grammars, such as Backus-Naur Form (BNF), Extended Backus-Naur Form (EBNF) and regular extensions to BNF.
- https://en.wikipedia.org/wiki/Big_O_notation
- Lecture 2: Asymptotic Notation, Recurrences, Substitution, Master Method
- Stackoverflow: Absolute Beginner's Guide to Bit Shifting?
- RRDtool is the OpenSource industry standard, high performance data logging and graphing system for time series data. RRDtool can be easily integrated in shell scripts, perl, python, ruby, lua or tcl applications.
- Ask HN: What's the best technical talk you've heard?
- Bret Victor - Inventing on Principle
- YouTube: Extracting Energy from the Turing Tarpit - Alan C. Kay during the ACM A.M. Turing Centenary Celebration, June, 2012.
- https://code.google.com/p/semicomplete/wiki/Grok
- YouTube: Stanford Seminar - Google's Steve Yegge on GROK
modelling;
- QEforge is a web portal offering support to researchers active in the field of computer simulation and numerical modeling of matter and materials at the atomic scale. The most popular source code management (CVS, SVN or Git ) systems, mailing lists, public forums, download space, wiki pages, and much more are provided through the Gforge engine.
- UbiGraph is a tool for visualizing dynamic graphs. The basic version is free, and talks to Python, Ruby, PHP, Java, C, C++, C#, Haskell, and OCaml.
- Hunspell is the spell checker of LibreOffice, OpenOffice.org, Mozilla Firefox 3 & Thunderbird, Google Chrome, and it is also used by proprietary software packages, like Mac OS X, InDesign, memoQ, Opera and SDL Trados.
- NuPIC - the Numenta Platform for Intelligent Computing, comprises a set of learning algorithms that were first described in a white paper published by Numenta in 2009. The learning algorithms faithfully capture how layers of neurons in the neocortex learn.
- http://techland.time.com/2013/04/02/an-interview-with-computing-pioneer-alan-kay/
- Ask HN: Alan Kay says programing is pop culture. Where can I find the classics?
- Ask HN: What unknown technical blogs or sites do you read?
- Ask HN: What are your daily must-read sites?