path: root/TODO

priorities guidelines
-   documentation > community > applications > features
-   mobile > desktop


------------------------------------------------------------------- weeks Jan 4, Jan 11

0.3  goal: start of more public development
done:
- use travis ci
- timeout for tests
- docker image: lambdacube3d/lambdacube3d
- quake map viewer application works for a sufficiently small map  +Csaba
- update online editor to use the new compiler
- tooltip testing
- compiler: ranges in error messages +Andor
- subexpression type tooltips in the editor
- pretty print Exp's defined in CoreToIR.hs
- refactored Builtins.lc
- homepage review (what is lambacube, etc.)
- documentation: overview
- API documentation started
- Hello World example on Haskell
- show pipeline in editor

------------------------------------------------------------------- weeks Jan 18, Jan 25

0.4  goal: usable compiler
done:
- compiler: fix looping (primes, recursivetexture01)
- refactor test system
- support simple import lists (hiding + explicit)
- support type synonyms
- better tooltip ranges & types
- tried to speedup with cache max. de bruin indices
- multiple guards
- handle constructor operator fixities, also in patterns
- small language feature tests framework
- document Hello World example on Haskell
- compiler: review parser de-brunin index handling
- automated test env. for backends

------------------------------------------------------------------- week Feb 1
-- padding week

done:
- compiler optimization: separate types and values (vs. church style lambda)
- compiler optimization: separate use of neutral terms
- compiler optimization: erease lam var type
- compiler optimization: erease univ. pol. arguments of constructors
- compiler optimization: erease univ. pol. arguments of case functions
- compiler optimization: speed up 'eval' function
- compiler put internals and prelude automaticly to include path when using compiler as a library
- use less 'try' in parser
- desugar node definitions
- definitions are allowed in any order (not just bottom-up)
- support qualified module imports
- editor: move default program to normal examle what comes from the server
- quake3: fix character animations
- quake3: basic collision test
- documentation: sync getting started description with the example source code
- documentation: update lambdacube(engine) page on haskell wiki
- better API documentation
- documentation: improve documentation with explanatory diagrams
- release 0.4 compiler on hackage

------------------------------------------------------------------- weeks Feb 8, Feb 15

0.5  goal: improvement + linear time interpretation

done:
- compiler: (~) :: forall a . a -> a -> Type
- backend: support sampler objects (opengl 3.3)
- backend: include compiler version in the generated pipeline as a string info field
- backend: support Texture2DSlot (purescript)
- editor: user texture support (no crossdomain support)
- reuse the same Exp data type in CoreToIR
- normalized variable names in the generated pipeline (so that the same structures have to be equal)
- move to megaparsec
- blog about 0.4 release
- testenv: add editor examples as backend tests
- error messages lookup in other modules' source code, not just the compiled ones
- shader pretty print (first version)
- don't overnormalize (String => [Char])
- compiler: support function recognition
- backend: generate functions in shaders
- backend: remove duplicate programs
- support local pattern matching functions
- support recursive local definitions
- testenv: performance benchmarks (time and memory consumption)
- tuples are heterogeneous lists
- names have Int identifiers
- move Quake repo to lambdacube github org
- webpage: package overview page
- webpage: feature list, screenshots
- webpage: put links to subpages for homepage
- register to stackage
- setup mailing list/forum for the community/update Q&A page (Community part) (https://groups.google.com/forum/#!forum/lambdacube3d-discuss)
- editor: highlight errors in editor
- add CHANGELOG
- pause/time input + slider on editor page
- compiler: somewhat better README: description
- remove MVP from examples
- webpage: create community page (link to the mailing list, ideas how to contribute)
- port to wl-pprint (another option was to port to pretty compact 2.0; required by stackage)
- document heterogeneous lists in language specification
- update getting started
- update overview

next:
- update API docs
- editor: more visible error ranges
- editor: wasd MVP (for spectator camera)
- editor: editor socket reconnection
- webpage: basic search engine optimization

release post:
- API clean-up:
  - tuples are heterogeneous lists (link) -> simplified the API a lot and made it complete
  - minor syntax change for unary tuples
- shader functions are generated (or variable bindings in general? need to test)
- parsec -> megaparsec (brought some performance improvements)
- communications:
  - opened forum / mailing list (goals: getting people to show their stuff and channel their requests/pleas for help)
  - API docs improved
  - language specs updated
  - introduced changelog for the compiler
- rescheduled tasks: separate the front-end earlier as a generic component
- current focus / what to expect: make the Quake example work

--------------------------------- re-schedule

- re-enable ambiguity checks
- show desugared source code on a tab in the editor
- compiler optimization: HOAS iterpreter

- backend: array support

- compiler: generate samplers (OpenGL 3.3)
- backend: setup texture sampler configuration (purescript)
- backend: setup viewport for render target size (purescript)

- backend: GLSL codegen doesn't support Vector and tuple patterns (not compiler frontend related):
          fragment02tuple
          fragment02vectorpattern
          fragment05uniform
- backend: basic pipeline optimization



- docs: feature teaser, 2 min paper videos
- minimal quake videos
- documentation: getting started: hello world on various platforms  +Csaba

extra (parser/refactoring)
- testenv: command line flag for runTest - parse only (outputs SExp)

extra (language features):
- support @ patterns
- support guards + where
- support pattern guards
- support view patterns
- support pattern synonyms
- properly support type annotations in where blocks
- properly support record fields (in any order)
- support injective type families

extra (dependent types):
- evalXXX not wired in compiler
- support dep. pattern matching
- compiler:  dependent prelude should work again

extra (ambiguity checks):
- really check type annotations
- prohibit constraints like    a ~ List a,  a ~ a -> a, etc.
- suppress univ. polymorphic ambiguity

extra (think about these):
- compiler:  recheck should not fail / coe missing?
- compiler:  (a ~ b) + (a ~ c)   --->   b ~ c        (fragment06tailrecursion)

extra (improvement):
- better persentation of types in editor tooltips
- pattern variable type tooltips
- eliminate V0, V1, ... in type tooltips

extra (refactoring):
- compiler: refactor pretty printing
- compiler: ConName --> Int

------------------------------------------------------------------- weeks Feb 22, Feb 29

0.6  goal: type classes

- docs: feature teaser, 2 min paper videos
- mutual recursion (inference & reduction)
- open functions ->  open type families
- move all lambdacube specific parts away from Infer.hs
- constraint types: uniqueness of witnesses for types with at most one elements
- injectivity inference
- compiler: type classes
- community: blog about compiler internals
- backend: generated backends
- user supplied cpu values like color values and rendering context
- compiler: (~) :: forall a b . a -> b -> Type   ?
- compiler: add more structure to witnesses?
- review all old disabled test cases
- 100% test coverage of the parser
- tail recursion -> GPU
- compiler optimization: irrelevance + erasure

------------------------------------------------------------------- week Mar 7
-- padding week

refactoring, cleanup, contact with people, etc.
- blog: c++ backend for opengl es 2.0 / generated backends
- blog: improved quake renderer, slowly turns into haskell quake engine
- blog: dependent type inference
- blog: type classes support
- blog: fast reducer
- move the website to github pages

------------------------------------------------------------------- weeks Mar 14, Mar 21

0.7  goal: frequencies

- apps: various prototype experiments (e.g. visual effects, high-level API, FRP)
- compiler: frequencies
- libs: fequencies in high level API
- docs: tutorial (like salesforce)
- docs: API documentation
- compiler optimization: compactified De Bruijn indices handling
- compiler optimization: use all other ideas already tried in the protype to speed up the compiler
- 100% test coverage of Infer.hs
- support pipeline storage serialization

------------------------------------------------------------------- weeks Mar 28, Apr 4

0.8  goal: high-level API

- libs: high level API (lambdacube library) (application driven)
- apps: various prototype experiments (e.g. visual effects, high-level API, FRP)
- compiler: better error messages
    - normalize  VecScalar 1 Float --> Float
    -   ...
- compiler optimization: interpreted De Bruijn
- docs: feature teaser, 2 min paper video
- completion in editor
- generate warning messages for possible typos in names
- warning on missing patterns
- editor: show definition place & show use places of variables etc.

------------------------------------------------------------------- weeks Apr 11, Apr 18

0.9  goal: experiment with FRP

- libs: begin experiments with FRP
- docs: tutorial (like salesforce)
- compiler:  better app typing
- backend: basic GPGPU support
- basic 3d graphics introduction with LambdaCube 3D, something like this: http://petercollingridge.appspot.com/3D-tutorial/generating-objects

------------------------------------------------------------------- week Apr 25

refactoring, cleanup, contact with people, etc.

- blog: pattern match compiler
- blog: frequency support
- blog: higher level abstractions in the graphics API

------------------------------------------------------------------- weeks May 2, May 9

1.0  goal: debug support

- editor improvments
- backend: basic debug support
- testenv: systematic micro tests (with quickcheck?)
- community: gamejam
- docs: feature teaser, 2 min paper video

------------------------------------------------------------------- weeks May 16, May 23

- backend: Unity plugin
- compiler optimization: coe / type class irrelevance switch
- docs: feature teaser, 2 min paper video

------------------------------------------------------------------- week May 30

refactoring, cleanup, contact with people, etc.

------------------------------------------------------------------- weeks Jun 6, Jun 13

- apps: demo for a demoscene party
- backend: profile-based optimization with machine learning
extra:
- write docs for the data definition language and also release the lib

------------------------------------------------------------------- weeks Jun 20, Jun 27

- apps: small game to App Store or Google Play
- docs: document/teach programming skills with dependent types
- community: contact people in industry

------------------------------------------------------------------- end of semester

refactoring, cleanup, contact with people, etc.
reviews, blogs

- plan the route
- blog: data definition language with support: Haskell, PureScript, C++


------------------------------------------------------------------- end of route

2.0
- involving more people
- backend: dynamic pipelines
- backend: dynamic input grouping/restructure for better performance
- Vulkan backend
- compiler: reflection (template Haskell)
- support nested data parallelism
- compiler: self-compilation
- domain-free compiler (move all lambacube specific parts into libraries & backend)
- compiler: Agda modelling
- strictness annotation (e.g. popups in editor)
- strictenss injection using machine learning
- inlining using machine learning
- pure haskell implementation of graphics pipeline (gpu primitives)
- book about pure functional graphics and game development, including pure FPS game (quake3) explained in details
- parallelize the compiler
- estimate pipeline's memory usage

--------------------------------------------------------------------

insert somewhere
- editor: input editor (add/edit new uniform values e.g. floats, matrixes and textures if possible)
- testenv: create comparison charts from the results
- measure shader performance
- compiler: parse haddock comments and generate api documentation from source
- fix variance shadow mapping

* New Quake map viewer
  - compiler: HOAS reducer

===== compiler
* Frequencies & type classes, recursion
* Extra language features
* amiguity check & other checks
* Better error messages
* Speedup

===== backend
* generate backend for OOP languages
    languages: C++, Java, C#, Python, TypeScript, ObjC, Swift
    APIs: GLES2.0, WebGL1.0, GL3.3
* array support & storage serialization
* feature tests for APIs
* feature complete APIs + redesign using row polymorphism
    APIs: GLES2.0/WebGL1.0, GL3.3, GL4.4/GL4.5 (required for GPGPU)
* CPU interpreter
    - change the background color in runtime
    - dynamic pipelines / frp
* try GRIN backend for CPU code

===== documentation/webpage
* getting started for every supported language
* showcase nice screenshots and effects on front page
* create demo videos
* create how to participate/open project page