User:Ruud Koot/Computer science


 * http://en.wikipedia.org/w/index.php?title=Special:RecentChangesLinked&limit=500&days=30&hidemyself=1&target=Category%3AWikiProject_Computer_science_articles
 * /Lambda calculus
 * Clean up User:Thepigdog's crap
 * /Metaheuristics
 * User:Ruud Koot/Computer science departments
 * User:Ruud Koot/Dutch computer scientists
 * User:Ruud Koot/History of computer science
 * /Curry–Howard correspondence
 * /ERCIM


 * Wikipedia talk:Articles for creation/subsumption lattice

Computational complexity

 * superexponential

Computational geometry

 * randomized incremental construction, backwards analysis (Mark, Mark & Mark; Kleinberg & Tardos)

Garbage collection (computer science)

 * Schorr-Waite graph marking algorithm

Data structures

 * Braun tree

Programming language theory

 * sequential composition
 * function equality, extensional equality, intensional equality, reference equality (http://www.cs.princeton.edu/~appel/papers/conteq.pdf)
 * currying, partial application, schönfinkeling, schönfinkelisation, schönfinkelization
 * purity (computer science)
 * while-program, while program, while (programming language)
 * functor (type theory), functor (functional programming)
 * mutable variable, assignable variable
 * storage location
 * amb operator
 * higher-order language
 * behavioural equivalence
 * name (computer science) (abstract syntax), identifier (computer science) (concrete syntax)

Formal systems

 * substitution (logic)
 * capture-avoiding substitution
 * simultaneous substitution (needs a hatnote)
 * explicit substitution
 * unification (computer science)

Lambda calculus

 * lambda calculus (needs a complete rewrite; start with outline in user space...)
 * simply typed lambda calculus (not surprisingly in a better shape than its parent, although still is somewhat unbalanced, giving too much weight to tangential topics)
 * strong normalization
 * logical relation
 * Curry-style, Church-style
 * weak head normal form, WHNF, lazy canonical form (Marting-Löf) Wikipedia talk:WikiProject Computer science/Archive 6
 * abstract machine (&lambda;-calculus style; current article might need to be merged with model of computation) (SECD machine, CEK machine, Krivine machine)
 * surjective pairing

First-class function

 * Make anonymous function, closure (computer science), first-class function, higher-order function, nested function, and non-local variable consistent.
 * non-local variable, free variable
 * closure rebinding (http://www.perlmonks.org/?node_id=315186, https://wiki.php.net/rfc/closures/object-extension)
 * Deal with function (computer science), identifier (computer science), name binding, scope (computer science), variable (computer science).
 * upvalue  (mutable non-local/static variables stored in a closure)

Denotational semantics

 * logical relation, Kripke logical relations
 * parallel-or, parallel or
 * divergence (computer science)
 * productivity (computer science)

Dependent types

 * observational type theory
 * phase distinction, phase separation
 * proof irrelevance
 * indexed type, index sort (Xi's Dependent ML, Zenger's Indexed Types), indexed data type (A Hierarchy of Mendler style Recursion Combinators)
 * views
 * universe construction, universes

Total languages

 * corecursion (co-recursion), codata (co-data), coinduction (co-induction)

Functional programming

 * anonymous function, first-class function, higher-order function, closure, continuation
 * non-local variable, nonlocal variable
 * generalized algebraic data type (first-class phantom type, guarded recursive datatype), phantom type
 * polymorphic recursion, nested type, nested datatype, non-regular type (regular type), non-regular datatype (non-regular datatype)
 * pattern matching (functional programming), (split pattern matching into pattern matching (functional programming), pattern recognition, ...)
 * lazy evaluation, space leak
 * futures and promises - lazy evaluation in a concurrent setting

Haskell

 * functor (functional programming), functor, bifunctor, profunctor
 * applicative functor (idiom (functional programming), sequence)
 * arrow (functional programming)
 * monad (functional programming), monad (category theory)
 * monad transformer
 * free monad (functional programming), free monad
 * identity monad
 * maybe monad (option monad, failure monad), error monad
 * list monad, non-determinism monad
 * state monad, reader monad (environment monad), writer monad
 * continuation monad
 * comonad (functional programming), comonad
 * algebraic effect
 * space leak
 * purity, idempotence, idempotence (computer science), referential transparency, referential transparency (computer science)

ML

 * value restriction, imperative type variable, weak type variable

Dependently-typed programming

 * decidable equality (http://ncatlab.org/nlab/show/decidable+equality)

Proof assistants

 * LEGO (proof assistant) (fr:LEGO (logiciel))
 * tactic (theorem proving)
 * positivity restriction, strict positivity requirement

Object-oriented programming

 * σ-calculus, sigma-calculus, sigma calculus (Abadi, Cardelli)
 * anonymous inner class, inner class, local class, nested class
 * multiple inheritance, repeated inheritance
 * synchronous active object (synchronous active objects)
 * message (object-oriented programming), method call
 * Featherweight Java
 * variance annotation
 * early binding, late binding
 * GRAIL system / RAND Tablet http://www.rand.org/pubs/research_memoranda/RM5999.html http://c2.com/cgi/wiki?GrailSystem https://www.youtube.com/watch?v=LLRy4Ao62ls

Type theory

 * base type
 * covariance and contravariance (computer science) (move to variance (computer science) or variance (type theory), rewrite lead section: subtyping in relation to functions)
 * evaluation (computer science), expression (computer science), type (computer science)
 * progress (type theory), subject reduction, substitution lemma
 * coinductive data type, codata
 * function type
 * ad-hoc polymorphism, parametric polymorphism ("type polymorphism"), subtype polymorphism ("polymorphism in object-oriented programming")
 * polymorphic recursion
 * nested type, nested data type
 * reflexive type (http://adam.chlipala.net/cpdt/html/InductiveTypes.html#lab30)
 * type equivalence (name equivalence vs. structural equivalence) (cf. Daniel M. Berry, Richard L. Schwartz, "Type equivalence in strongly typed languages: one more look", ACM SIGPLAN Notices 14:9 (September 1979))
 * type equality, type witness, equality type, equality witness, equality type witness, type equality witness
 * Arthur I. Baars and S. Doaitse Swierstra. Typing dynamic typing. In Proceedings of the Seventh ACM SIGPLAN International Conference on Functional Programming, volume 37(9) of ACM SIGPLAN Notices, pages 157–166. ACM, October 2002.
 * James Cheney and Ralf Hinze. A lightweight implementation of generics and dynamics. In Proceedings of the 2002 ACM SIGPLAN Workshop on Haskell, pages 90–104. ACM Press, 2002.
 * Stephanie Weirich. Type-safe cast: Functional Pearl. In Proceedings of the ACM SIGPLAN International Conference on Functional Programming (ICFP’00), volume 35(9) of ACM SIGPLAN Notices, pages 58–67, New York, NY, USA, September 2000. ACM Press.
 * bottom type, unit type, void type
 * bounded quantification
 * context (computer science), context (type theory), environment (computer science), environment (type theory)
 * principal type
 * refinement type
 * type-level fixpoint, type-level fixed point

Functional data structures

 * rose tree, generalized rose tree. finger tree
 * stream (type theory) (stream (computer science), stream (computing))

Polymorphism

 * let-bound polymorphism
 * row polymorphism

Homotopy type theory

 * identity type

Type system

 * strongly typed, weakly typed (in a strongly typed language all values have an associated type (Burstall, CCT) vis-à-vis languages where values are uninterpreted machine words.
 * strong typing, weak typing, strong and weak typing, Type_system
 * /Strong and weak typing

Program analysis

 * abstract interpretation
 * dynamic dispatch, dynamic dispatch problem
 * monotone framework
 * meet over all paths (MOP), meet over all valid paths (MVP), maximal fixed point (MFP)
 * type and effect system, annotated type system
 * type-based program analysis
 * annotated type, annotated type system
 * effect system
 * polyvariance, polyvariant
 * subeffecting, subtyping
 * widening, widening operator
 * k-CFA, uniform k-CFA. polynomial k-CFA, cartesian product algorithm, Cartesian Product Algorithm
 * context-sensitivity, context-sensitivity (program analysis), context-sensitive, context sensitive, context-insensitive, context insensitive, context-insensitivity, context insensitivity
 * flow-insensitivity, flow-insensitivity (program analysis), flow-sensitive, flow sensitive, flow-insensitive, flow insensitive, flow-sensitivity, flow insensitivity
 * call-graph analysis (vs control-flow analysis)
 * binding-time analysis, binding time analysis
 * Partial evaluation

Type and effect system

 * type and effect system, type and effect discipline
 * KFX (program), FX87, FX-87 (programming language, FX (programming language)

Non-standard type systems

 * dimensional analysis: F Sharp, Mathematica 9, Frink, Numeric.Units.Dimensional

Category theory

 * comonad (/Comonad)

Programming language design

 * expression problem
 * coroutine, generator (computer programming)
 * closure (computer science), combinator, supercombinator, constant applicative form (CAF)
 * thunk (clean up the mess)
 * nonlocal return, non-local return
 * http://en.wikipedia.org/w/index.php?title=Closure_%28computer_science%29&diff=490181440&oldid=
 * fat function pointer
 * automatic memory management (should not redirect to garbage collection (computer science)
 * parameterised module, parametrized module (by type, by modules)
 * type conversion, data representation, type hierarchy (merge class hierarchy and numerical tower)

Early languages

 * 1968: GPL (Jan V. Garwick, no:Jan Garwick, User:NevilleDNZ/Jan Garwick, "GPL, a general purpose language", "Programming Languages: GPL, a truly general purpose language")
 * 1969: BASEL, ELF, Extensible Language Facility ("On the basis for ELF: an extensible language facility")
 * 1974: EL1 (programming language) (Wegbreit)
 * 1978: Russel (programming language) (Demers et al.)

Type theory-based

 * Gedanken (programming language), Forsythe (programming language) (John C. Reynolds)
 * Quest (programming language) (Luca Cardelli) &mdash; Typeful programming?
 * Peble (programming language) (Rod Burstall & Butler Lampson, 1984)
 * CUCH (Curry-Church) (Corrado Böhm)

Design patterns

 * dependency injection

Metatheory

 * subject reduction
 * hereditary substitution

Logic

 * paramodulation

Books

 * Term Rewriting Systems
 * Term Rewriting and All That

Terminology

 * productivity (computer science)
 * left linear, left-linear, left linearity, left-linearity
 * higher-order rewriting, higher-dimensional rewriting

Systems

 * CafeOBJ
 * K Framework
 * ELAN http://elan.loria.fr/faq/index-faq.html

Concurrency

 * memory ordering, memory model (computing)
 * Mathematizing C++ Concurrency
 * You Don't Know Jack about Shared Variables or Memory Models
 * Hans-J. Boehm and Sarita V. Adve: Foundations of the C++ concurrency memory model. ACM PLDI'08.
 * Hans-J. Boehm: Threads Basic. HPL technical report 2009-259
 * lock elision
 * futures and promises - lazy evaluation in a concurrent setting

Quantum information science

 * Move Quantum computer to Quantum computing

Other

 * Böhm's theorem (Structured program theorem?)
 * flowchart theorem (David Harel, "On Folk Theorems")

Academia

 * Need sections in the main article on computer science...

Computers scientists
../Dutch computer scientists
 * Academic genealogy of computer scientists
 * Thierry Coquand
 * Marc van Kreveld
 * Jan van Leeuwen
 * Handbook of Theoretical Computer Science
 * http://www.ictonderzoek.net/3/assets/File/Archief%20Magazine/IO_februari2011.pdf
 * Alexander Schrijver, Lex Schrijver
 * Combinatorial Optimization: Polyhedra and Efficiency
 * François Pottier
 * Jean-Louis Krivine (fr:Jean-Louis Krivine)
 * Bart Jacobs
 * Jan Rutten
 * Jos Baeten
 * Gilles Dowek (fr:Gilles Dowek)
 * Dale Miller (computer scientist)

By bibliometrics

 * http://www.cs.ucla.edu/~palsberg/h-number.html
 * http://www.pnas.org/content/101/51/17599.abstract
 * Olivier Danvy
 * Oded Goldreich
 * Luca Cardelli
 * Tom Mitchell
 * Martin Abadi
 * Phil Wadler
 * Moshe Vardi
 * Peter Lee
 * Avi Wigderson
 * Matthias Felleisen
 * Benjamin Pierce
 * Noga Alon
 * John Ousterhout
 * Frank Pfenning
 * Andrew Appel
 * http://citeseer.ist.psu.edu/stats/authors
 * http://academic.research.microsoft.com/RankList?entitytype=2&domainID=26&last=0&start=801&end=900
 * http://www.informatik.uni-trier.de/~ley/db/about/prolific.html

Journals

 * http://www.elsevier.com/wps/find/subject_journal_browse.cws_home/P05?SH1Code=P05&showProducts=Y
 * http://academic.research.microsoft.com/RankList?entitytype=4&topDomainID=2&subDomainID=0&last=0&start=1&end=100
 * Find some reliable sources about popularity and prestige (e.g. the refs in Journal of the ACM)
 * http://aisel.aisnet.org/jais/vol5/iss2/1/
 * http://www.sciencedirect.com/science/article/pii/S1751157709000698
 * WikiProject Academic Journals/Danish journal list/38
 * WikiProject Academic Journals/Journals cited by Wikipedia/A3
 * WikiProject Academic Journals/Journals cited by Wikipedia/Missing1
 * http://www.informatik.uni-trier.de/~ley/db/journals/index.html
 * http://www.timeshighereducation.co.uk/story.asp?sectioncode=26&storycode=406557


 * List of computer science journals
 * List of scientific journals
 * Higher-Order and Symbolic Computation (formerly LISP and Symbolic Computation)
 * Journal of Universal Computer Science
 * Nordic Journal of Computing
 * Journal of Functional Programming
 * Journal of Functional and Logic Programming
 * ACM Transactions on Programming Languages and Systems (TOPLAS)
 * Mathematical Structures in Computer Science
 * Theoretical Aspects of Computer Software (conference?)
 * Science of Computer Programming
 * (Ex-)Elsevier
 * Journal of Logic Programming
 * Theory and Practice of Logic Programming
 * Journal of Logic and Algebraic Programming
 * Journal of Algorithms
 * Transactions on Algorithms
 * Journal of Topology

Books and series

 * Foundations of Computing
 * Handbook of Logic in Computer Science
 * Handbook of Automated Reasoning

Conferences and symposia

 * Create a navigation box (per subject, per organizer)
 * List of computer science conferences
 * http://www.haskell.org/haskellwiki/Conferences


 * FLOPS: International Symposium on Functional and Logic Programming
 * IFL: International Symposia on Implementation and Application of Functional Languages
 * ISMM: International Symposium on Memory Management
 * MPC: International Conference on Mathematics of Program Construction
 * PLDI: Programming Language Design and Implementation
 * POPL: Principles of Programming Languages
 * PPDP: International Conference on Principles and Practice of Declarative Programming
 * TFP: Symposium on Trends in Functional Programming
 * TLCA: International Conference on Typed Lambda Calculi and Applications
 * TLDI: International Workshop on Types in Language Design and Implementation
 * SAS: International Static Analysis Symposium
 * ESOP: European Symposium on Programming

Symposium on Principles of Programming Languages (POPL) Practical Aspects of Declarative Languages (PADL) Partial Evaluation and Program Manipulation (PEPM) International Conference on Functional Programming (ICFP) Implementation of Functional Languages (IFL) Programming Language Design and Implementation (PLDI) European Symposium on Programming (ESOP) Object-Oriented Programming, Systems, Languages & Applications (OOPSLA) European Conference on Object-Oriented Programming (ECOOP) Foundations of Object-Oriented Languages (FOOL) International Conference on Software Testing, Verification and Validation (ICST) International Symposium on Software Testing and Analysis (ISSTA) Software Engineering and Formal Methods (SEFM) Foundations of Software Engineering (FSE) International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS) International Conference on Verification, Model Checking, and Abstract Interpretation (VMCAI)

Denmark

 * BRICS: Basic Research In Computer Science

Category:Computer science awards

 * de:Konrad-Zuse-Medaille
 * ACM SIGPLAN Programming Language Achievement Award

History of computer science

 * Category:1986 in computer science

Early academic research and education

 * William F. Atchison, Samuel D. Conte, John W. Hamblen, Thomas E. Hull, Thomas A. Keenan, William B. Kehl, Edward J. McCluskey, Silvio O. Navarro, Werner C. Rheinboldt, Earl J. Schweppe, William Viavant, David M. Young: Curriculum 68: Recommendations for academic programs in computer science: a report of the ACM curriculum committee on computer science. Commun. ACM 11(3): 151-197 (1968)
 * Samuel D. Conte, John W. Hamblen, William B. Kehl, Silvio O. Navarro, Werner C. Rheinboldt, David M. Young, William F. Atchison: An undergraduate program in computer science - preliminary recommendations. Commun. ACM 8(9): 543-552 (1965)
 * http://www.cs.umd.edu/department/obituaries/atchison.shtml
 * Norman E. Gibbs

Plumbing

 * Improve Infobox scientist
 * dissertation_title
 * structured students (name, year, university)
 * structured institutions (name, period, position)
 * structured awards (name, year)
 * exchange data with:
 * DBLP
 * Mathematics genealogy
 * ACM Digital Library
 * Find and fix dual-tagged articles (e.g. "Computer science" and "Databases / Computer science", which really should be "Computer science / Databases") which causes assessment problems
 * Find and fix dual-tagged articles (e.g. "Computer science" and "Databases / Computer science", which really should be "Computer science / Databases") which causes assessment problems

Cleanup

 * Delete/refactor Category:Logic in computer science and Category:Mathematics of computing
 * 
 * India Education Program/Courses/Fall 2011/Data Structures and Algorithms, India Education Program/Courses
 * Category:Actor model
 * Hello world program examples
 * Wikipedia talk:WikiProject Programming languages/Renaming poll
 * User:Comps / Yoav Raz (User:ERfan111)
 * source code -> pseudo code / create ambox / check using a bot
 * cleanup sourcecode
 * WP:REFSPAM (e.g. ) &mdash; compare authorname/university with IP address
 * interwikis on Computer science, Informations science, Information technology, Information and communication technology, ...
 * MoS
 * User:Jdh30 ([])
 * Language list creep
 * User:JAnDbot:
 * data structure vs. data type
 * clean up the copyright violoations from Data compression and undo the merge from Video compression

Pseudocode

 * How to deal with broken source code:
 * How can we make sure pseudocode is correct?
 * Have a an obviously equivalent implementation.
 * Make pseudocode more difficult to edit, but easier to comment on. (Transclude via template, edit notices)
 * Make it easier to attribute pseudocode to a reliable source.
 * How can we make pseudocode more useful?
 * Provide a visible link to a library of implementations.
 * How can we use Lua/Scribunto/other extenstions?
 * Make pseudocode interactive.
 * Advanced typesetting/syntax highlighting.
 * Manual of Style: algorithms vs. programming language concepts
 * Algorithms: add some great examples of pseudocode on Wikipedia and in literature
 * Programming language concepts: promote the use of structured tables (á la First-class function, Function type and (soon) Anonymous function)
 * Also, nicer styling for GeSHi and pre
 * Linking to implementations
 * Write guideline
 * Describe problems
 * Incompetent spam cleaners
 * WikiBooks vs. Rosetta Code vs. Literate vs. Git(Hub)
 * Link through template

Community

 * User:Ruud Koot/Wikipedian computer scientists
 * Category:Wikipedian computer scientists
 * User:Brighterorange
 * User:NeilMitchell
 * User:Edward Z. Yang
 * User:KevinHammond
 * User:SparsityProblem
 * User:Txa
 * Merge WikiProjects (page view statistics, number of watchers, merge watchlists)
 * User:Ruud Koot/WikiProject statistics
 * Database reports/Most-watched pages
 * User:AAlertBot
 * Wikipedia talk:WikiProject C -> merge
 * WikiProject_Council/Directory/Science
 * Database reports/WikiProjects by changes, Database reports/WikiProject watchers
 * User:TinucherianBot
 * {WikiProject Computing|science=yes}
 * Integrate the archives of WikiProject Programming languages with WikiProject Computer science
 * User:TinucherianBot/Autotagg/WPCOMP
 * User:Jitse's bot
 * Wikipedia Signpost/2011-05-16/WikiProject report

Task forces

 * WikiProject Computer graphics