[<<][compsci][>>][..]

Computer Science. This is a collection of blog articles about misc computer science topics. Practically though, this is 50% about re-wiring the brain to learn functional programming (Haskell).

20190327 Decision Tables

State machines, groups and geometry

Statecharts

20190326 Metamorphic testing

20190325 Is all state just cache?

What are services?

Fold with cons into queue

20190313 representing algebraic data types as folds

20190228 glue code

20190220 Processor vs. generated state machines

20190209 difference structures

20181209 transforming blocking code into state machines: Rust Async transform

20180904 Glue code isn't "dirty"

20180823 Effects

20180805 optimizer generators

20180712 Incremental Relational Lenses

20180701 Monoids

20180630 Idris

Circuit netlists: structural and semantic operations

20180628 A theorem in a context

20180627 Haskell graphs

MyHDL

Representing I/O

Pattern matching netlists

20180531 Tree to DB

20180505 Transactions, diffs, editable views, lenses

20180415 Presentation model from #{}

20180409 Equality is relative

20180304 Loops: MIMO

20180228 Embedding Erlang in Haskell

20180222 Foldee?

20180219 Hans meeting

20180106 bloom filters

20171230 haskell dsp

julia

20171228 merging forks

20171226 category theory is type theory

contained vs. association

20171219 Transitioning

20171202 LALR parsers

Broadcast events are late binding

20171130 parsing

20171129 Are monads just sequential execution?

20171126 the real problem is integration

20171124 Fibers are not Threads

20171120 Functional vs. Idempotent

20171116 Unknowingly making the wrong assumptions

Treat things that are isomorphic as the same

20171110 Stream processing patterns

20171104 Dependent types and proofs

20171024 hans followup

20171023 source.erl vs unfold.erl

20171009 Re-inventing computing: no I/O

20170924 Why is cache invalidation so hard?

20170908 Twitter thread on "derivatives"

20170907 Trees vs. Paths: derivatives?

20170902 Trees vs. Paths

20170829 differentiating constructors

20170826 Declarative vs. OO

Paths: trees as flat key-value maps

20170825 Decarative vs OO

20170807 CCC Conal

foldable

20170717 Just put the constructors in a dictionary

20170715 Intersection between igen.erl and source.erl

20170711 definition control-dominates use

20170710 line assembler iteration pattern

20170705 Manual parser

6 Iteration structures

The most general I/O processor?

Parser combinators

recursive descent parsers

20170701 Code is data because of right fold

20170308 Extending timer capture values

20170306 State machines

State machine notation

Pi Calculus

20170221 Tree diffing

20170220 Nested folds and intermediate results

Sequences as Folds -> Fused Loops

20170211 GUIs: constraint vs. reactive

20170120 Make illegal states unrepresentable

20161231 Joscha Bach 4rth C3 lecture

20161207 event-driven systems

20161128 idempotency and desired state

20161125 Joe Armstrong & Alan Kay - Joe Armstrong interviews Alan Kay

device drivers

Eliminate the OS

20160829 TDM closed formulas and derivatives

Streams vs. coordinates (transposes)

Blocking tasks to state machines

20160825 Declarative distributed programming

20160820 Futures in Rust

20160708 why does printing code look so ugly?

20160605 unique identifiers

20160514 Distributed systems theory for the distributed systems engineer

20160428 CRDT: eventual consistency

20160324 A state machine language

20160322 Sequences vs. folds

20160226 USB and acks

20160223 LL,LR polish,reverese polish

20160212 Sequences as folds.

20151003 Ownership is Theft: Experiences Building an Embedded OS in Rust

20150905 CPS in Javascript

Two-object state?

20150812 Simplicity

20150718 LING: Erlang on bare metal

20150717 The How and Why of Fitting Things Together - Joe Armstrong

20150712 Reactive Programming

20150711 folds

20150102 Static actors

20141006 Mirage

20140928 LLVM haskell

State machines

20140920 The mess we're in

20140814 CoArbitary

20140627 State machine compiler

20140619 A rust project: blog database!

20140617 Qt Pyside layoutChanged recursion

20140525 Dynamic typing / eval and polymorphism

20140301 Data Direction and Control Flow: 2 x 2 = 4

20131229 Good Tech Blogs

20131213 Loop transformation algebra

20130921 Iterator Blocks

20130908 Objects are names for things you don't control

20130825 Salea Logic in Racket?

20130816 Tasks vs state machines

20130811 State machine translator - how to start?

20130806 Suspend / Resume syntax translation

20130804 State machine generator

20130803 MyHDL

20130802 State Machines

20130529 Computers for Cynics - Ted Nelson

20130510 Don't write a one-pass compiler

20130220 Love the Lambda

20130217 Promises

20130123 Ad-hoc polymorphism is higher order abstract syntax

20121225 ping-pong layouter in C

20121224 Problem with FP

Model-View-Controller vs. functional GUI

20120514 Representing self-delimiting numbers

Forth Direct vs. Indirect threading?

20120425 Params with defaults

20120423 Database (push vs. pull)

Resist structure

Compiling FRP to state machines

20120422 Real-world programming in Haskell

20120418 Maybe and monoid

Updateable state by name

20120416 Monad transformers

Just update state.

20120413 Stateful iteration (for / forM) or unfold?

20120408 Monoidal

Experimenting with Applicative

Applicative Functors

Duality: values <-> continuations

20120407 Applicative and Functor in terms of Monad

Reverse State monad

foldr from traverse + monad

Left/Right confusion in mapAccum

Are state space models Applicative?

Applicative and sequential operations

Data.Traversable vs. Data.Foldable

20120406 forM

Why are "stateful maps" not part of standard functions?

Equations for box layout

20120405 Interesting Recursion Patterns

20120403 Product of State and ST?

Imperative programming in Haskell

20120401 Node binding (equation solving) : sequential approach

20120326 Indexing binomial combinations

The ST monad

Compile time mutable operations

20120325 Evaluation of equation network

The usefulness of local state / working with graphs in Haskell

Adding arrows to a network

Pierce's lenses - Bidrectional programming

20120324 Invertible nodes constraint solver: limitations?

Invertibility through sparseness

Relational, Logic, Constraint: CTM

20120323 Constraint programming, layout & choreography

20120219 Monad transformers

20120218 Forking a random number generator?

Functor in terms of Arrow

State Space Models: Arrow and generalized functors.

Reader monad and order

20120126 State machines / parallellism and resource allocation

20120125 State machines

20120111 Register Allocation

20111231 Mapping trees to integers

20111227 Functors

20111218 Continuation Monad & compilation

20111215 Composite return values in C

20111210 Condition Variables are not Semaphores

20111115 Elementary function evaluation

20111111 Integer Programming

20111107 Lifting & subclassing

20111102 Relational Databases

20111101 Ad-hoc syntax design

Edge filtering for Interrupt On Change

Generalized Arrows

20111031 DB normalization

Cross Stage Persistence

20111030 Continuations

20111028 Type Scoping

Functional Dependencies

20111027 Sussman: We Really Dont Know How To Compute

Invertible Functor?

Commuation

20111026 OverlappingInstances, IncoherentInstances

20111025 Zipper: data structure derivatives.

20111024 Monad transformers

Monads

20111015 Functional Dependencies and Undecidable Instances

20111013 Types

Lifting pure functions to dataflow functions

20111009 CBN & CBV

Haskell overlapping type class instances

20111007 Apply pure function in monad

Learning Haskell

20111004 Function arity

20111002 Inductive inputs / outputs

20110924 Embedded patterns and translation

20110923 Minimal erase binary counter for Flash memory

20110920 Protocol-oriented programming (part 2)

20110910 Logic

State Space model vs. Mealy Machine

a -> M b vs. M a -> M b

20110902 Cover Condition

20110830 Needing GHC extensions

20110829 The Essence of Functional Programming

20110826 The List Monad - Generate and Test

mapM

Haskell tuples vs. lists

Streams with extra input.

Are recursive signal processors applicative?

20110825 Stream transformers

Learning Haskell

Streams and the Reader Monad

Eliminating Existentials

20110822 Concatenarrow

NOT & CPS

>>= vs. >=>

20110821 Numeric Prelude

From Applicative to Num

Data.Typeable

ArrowApply and ArrowMonad

20110820 Existential Monad problem: solved!

20110818 Existential types

20110816 Monad from Kleisli Arrow

Arrows

Kleisli arrows

20110815 From Applicative to Monad

The Haskell Learning Curve

20110814 Existential types

Arrow = Applicative + Category

Applicative Transformers

QuickCheck as an API design guide

20110808 Flattening expressions using liftM2

Type-level computations / meta systems

20110807 SSA vs CPS

20110806 Generalized Algebraic Data Types

Phantom types

20110804 initial / final

Lambda or struct?

20110802 CPS vs SSA

Awesome Prelude

20110801 do notation algebra

20110724 Learning Haskell

20110723 Composing monads

Monad is a type class

Monads and evaluation order

20110722 Getting used to Monads

20110716 A letter to a C programmer

20110710 Referential transparency and object identity

20110616 intension / extension

20110614 Fault-tolerant, stateful code

20110522 Simple checksums

20110509 Haskell: functions vs. structures

20110505 Object Identity

Goldmine

20110427 Low-level C : Exceptions or error codes?

20110423 Protocol-oriented programming

20110415 Reforestation

20110409 Parser-oriented programming

20110406 0,1,2 stacks : 3 kinds of programming?

20110330 Filling in gaps

20110302 Merging

20110212 Functional Programming is Fantastic

20110114 Understanding Referential Transparency

20101202 Representation of impedance/admittance duality

Algebraic Datatypes

20101026 fexprs

20101019 Pure functional programming and object identity

20101010 Refactorer: dependency graph visualisation

20101008 Real Time GC

Pointer Reversal for Graph Traverse

20100927 Values and Transitions

20100925 void events

20100919 Mark-sweep GC

Always-on / Image-based computing

20100918 Treasure trove: Faré Rideau's pointers

20100826 Graphs without mutation

20100814 Coroutines

20100812 Condition variable vs. semaphore

20100807 Models of dataflow

20100805 What does that mean? -- Denotational semantics

20100511 S K combinators and the Reader monad

20100510 Tree Grafting (Monads)

Syntax directed vs. Semantics directed (fold vs. monad)

20100508 Left folds in Haskell

State monad with unit output

Map + state threading.

Data Parallel Haskell

20100506 Memoizing (==) in Haskell

20100504 Object identity in Haskell

20100425 Polymorphy & Functors (lifting)

20100418 Clock Calculus

Stream Fusion

20100417 Abstract Machines and Semantics

Lambda Calculus for Electrical Engineers

Functional Reactive Programming

20100411 Databases and Normalization

GUIs and modules

20100408 A History of Haskell: Being Lazy with Class

20100328 Bottom up vs. Top down

20100327 Functional programs / stateful debugging

Computation (pattern matching) vs. types

20100323 Clojure

20100319 The Arbiter Problem

20100317 Hardware Mapping

Mathematical Logic and Compilation

20100314 Ziggurat

20100313 State breaks composition

20100307 Writing compilers

System F vs. Hindley–Milner

Simply Typed LC is Strongly Normalizing

Arrows

20100303 The Actor model is not composable

20100224 Applicative programming with effects.

20100222 How to explain Monads

20100218 Generalized Algebraic Data Type (GADT)

20100217 Typeful symbolic differentiation of compiled functions

20100214 Haskell pointer equality

20100213 Recursion and Co-recursion for filters (s,a) -> (s,b) on a list [a]

Name my recursion pattern

20100130 Open, extensible object models

20100125 Scheme compilers

Indulge yourself: Scheme literature

Type aliases for Java Generics

Higher order functions in Java

Representing control: a study of the CPS transformation.

20100124 Convert a static library to a shared library

20100123 Relational lenses and partial evaluation (generating VMs)

20100122 Common expression elimination

20100119 Functional programming with GNU Make

20100115 Can functional programming be liberated from the von Neumann paradigm?

20100113 Beautiful differentiation

20100112 Recursive make Considered Harmful

20100110 Applicative Functor

20100109 Avi Bryant: Don't build stuff for developers

20100105 Java and CPS vs callbacks.

20100103 Two kinds of optimizations

20091221 Peter Landin

20091109 LL and LR parsing vs. binary protocol design

20091027 Language oriented development

20091024 Linearizability

20091014 Java vs. Other

20091012 OpenComRTOS

20091009 Componend Based Software Engineering

20091007 Linear types

Coq & Dependent types

20091004 Signal Processing Functions, Algorithms and Smurfs: The Need for Declarativity

The Two Towers.

Funmath

20091003 Formal methods

20090927 Logic

20090925 Pico

20090924 Scheme implementation

Recent Scheme papers from NU

20090923 FISh & Squigol

Staging & Typing

20090922 Constraint Programming from CTM Chap. 12

20090921 Partial Evaluation for the Lambda Calculus

Dynamic Programming

Understanding Expression Simplification

The Design and Implementation of Typed Scheme

20090920 Theorems for free!

DSLs as compiler hints

Software pipelining: An effective scheduling technique for VLIW machines

Galois Connection

Algebra of Programming

20090918 Controlling Effects

Sparse Conditional Constant Propagation

20090915 Proof Assistants / Constructive Analysis

20090914 Delimited Continuations and Staging

20090913 CPS vs. A-normal form

Control-Flow Analysis of Higher-Order Languages (Shivers)

20090911 Staging Control Flow

Bananas, Lenses, Envelopes and Barbed Wire

20090909 Environment / Continuation vs. Param stack / Return stack

Towards the best collection traversal interface

20090907 APL & J

20090906 Monads vs. delimited control

20090903 Local consistency

Metaprogramming Patterns

Types vs. Staging vs. Abstract Interpretation

20090831 Syntax vs. Semantics

Stackless Extensional Joy

Recent discussions with Dominikus about Concatenative Languages

20090830 Dynamic vs. Static Types

Dependent Types

Proof Calculus

Linear Type Systems

Linear Lisp and Uniqueness Types

20090828 Monads and shift/reset

Partial Continuations

Parser Combinators

20090827 Monad transformers / Arrows

20090824 Eager rewriting vs. ``something more general''

20090823 Tagless Interpreters

20090817 Concurrency

Synchronization

20090816 Finalizers

20090803 EWD concurrency

Task-based C interface

Engine vs. Coroutines

20090802 Connected Ideas

Managing External Resources

20090716 Constraint Programming

Small-step vs. Big-step operational semantics

20090715 Partial Evaluation

20090709 64bit

20090618 GC and Cache

20090615 Goodbye Smalltalk?

Filesystems as Graphs

Cached Continuations and Synchronized VMs

20090605 Stacks

20090504 The 2 x 2 of functional programming.

Futamura Projections

invertable data structure pack/unpack

20090408 Evaluation Strategies or Lambda Calculi?

20090403 CTM

20090322 data - codata

20090310 coroutines and "join"

20090227 YACC

20090216 Parsing and Automata

[Reply][About]

[<<][compsci][>>][..]