adamnemecek

This is an extension of "A Very General Method of Computing Shortest Paths" to use "open matrices".
This is from a paper "The Open Algebraic Path Problem" by Jade Master https://arxiv.org/abs/2005.06682

> {-# LANGUAGE TypeFamilies #-}
> {-# LANGUAGE TypeApplications #-}
> {-# LANGUAGE FlexibleContexts #-}
> {-# LANGUAGE StandaloneDeriving #-}
> {-# LANGUAGE AllowAmbiguousTypes #-}
> {-# LANGUAGE ScopedTypeVariables #-}
> module OpenStarSemiring where

adamnemecek

Definition of Truth

Jason the Goodman <jasonthegoodman@....com>:

How about defining "truth" with "stability" of the coupling loop between "the object" and the cognitive system coupling with the "object"? If the process stabilizes and an eigenvalue of the loop emerges, we say "a truth" is found. This would refocus our attention from the "object" itself to the nature of the cognitive system, which may include animals and robots in addition to humans. My tentative way to upgrade from first-order thinking to the second-order thinking. Then, instead of searching for "truth", we search for the "Lyapunov potential function" for the situation if we could find one...

Louis H Kauffman <kauffman@....edu>

Eigenform is important way to formalize a kind of stability. Truth is a special kind of eigenform, not just any eigenform. Truth means the truth of a PROPOSITION about something. So we need to have a language involved and the notion that the propositions are talking about some domain where it is possible to c

adamnemecek

Programming as Theory Building

Peter Naur

Peter Naur's classic 1985 essay "Programming as Theory Building" argues that a program is not its source code. A program is a shared mental construct (he uses the word theory) that lives in the minds of the people who work on it. If you lose the people, you lose the program. The code is merely a written representation of the program, and it's lossy, so you can't reconstruct

adamnemecek

For background and further references see: Entity Component Systems on Wikipedia

ECS by Scott Bilas (GDC 2002)

Entity->Components->Update

• entity = class: no logic + no data OR at most small set of frequently used data (ie position)
• component = class: logic + data

foreach entity in allEntities do
    foreach component in entity.components do

adamnemecek

-- credit goes to sigfpe
{-# LANGUAGE MultiParamTypeClasses
    ,TemplateHaskell
    ,GeneralizedNewtypeDeriving
    ,DeriveFunctor
    ,FunctionalDependencies
    ,FlexibleInstances
    ,UndecidableInstances
    ,FlexibleContexts
    ,Rank2Types #-}

adamnemecek

//
// MIT License
// Copyright (c) 2017 Lachlan Hurst
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

adamnemecek

Courses

• Learning from data, course by Professor Yaser Abu-Mostafa

• http://courses.cs.washington.edu/courses/cse446/13sp/

• http://cs.nyu.edu/~dsontag/courses/ml13/

• http://holehouse.org/mlclass/

• ML, level 1 by Prof. Andrew Ng: Machine Learning, Website

• ML, level 1 by Prof. Andrew Ng: Machine Learning, Website, Lecture Notes, Videos

• ML, level 1 by Prof. Nando de Freitas: Machine Learning & Data Mining, Website, Lecture Notes, Videos

• ML, level 2 by Prof. Nando de Freitas: Machine Learning, Website, Lecture Notes, [Videos](https://www.youtube.com/playlist?list=PLE6Wd9FR--EdyJ5lb

adamnemecek

enum Sharp: Int { case C = 0, G, D, A, E, B, F }

func sKeyForNote(n: Sharp) -> [Sharp] {
  return (0..<n.rawValue)
    .map{ n in (n + 6) % 7 }
    .flatMap(Sharp.init)
}

enum Flat: Int { case F = 1, B, E, A, D, G }

adamnemecek

enum Expr {
  case Lit(Int)
  indirect case Neg(Expr)
  indirect case Add(Expr,Expr)
  indirect case Mul(Expr,Expr)
  indirect case Sub(Expr,Expr)
}

let spaces = many(oneof(" \n\r"))
func token<P: ParserType>(p: P) -> Parser<P.A> {

adamnemecek

func encode<T>(var value: T) -> NSData {
    return withUnsafePointer(&value) { p in
        NSData(bytes: p, length: sizeofValue(value))
    }
}

func decode<T>(data: NSData) -> T {
    let pointer = UnsafeMutablePointer<T>.alloc(sizeof(T.Type))
    data.getBytes(pointer)