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 - use less 'try' in parser - desugar node definitions - definitions are allowed in any order (not just bottom-up) - support qualified module imports next: - better API documentation - documentation: update lambdacube(engine) page on haskell wiki - editor: editor socket reconnection - editor: highlight errors in editor - release 0.4 compiler on hackage - blog about release: - few sentences about the past events - meeting in december with every team member? - new members? Andor, he added support for travisCI and docker - we have a roadmap for the next 6 months? - links for the documentation - few words what to expect - new release in every 2-3 weeks - stable compiler with type class and frequency support (see TODO) - higher level abstractions in the graphics API - small game in app-store ------------------------------------------------------------------- weeks Feb 8, Feb 15 0.5 goal: improvement + linear time interpretation - docs: feature teaser, 2 min paper videos - testenv: performance benchmarks - compiler: (~) :: forall a b . a -> b -> Type - compiler: ConName --> Int - compiler: support let labels - compiler optimization: irrelevance + erasure - support local pattern matching functions - support recursive local definitions - mutual recursion (inference & reduction) - backend: generate let in shaders - backend: array support - backend: GLSL codegen doesn't support Vector and tuple patterns (not compiler frontend related): fragment02tuple fragment02vectorpattern fragment05uniform - backend: basic pipeline optimization (let-floating) - backend: setup texture sampler configuration - backend: setup viewport for render target size (purescript) - documentation: getting started: hello world on various platforms +Csaba - minimal quake videos 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) extra (dependent types): - evalXXX not wired in compiler - support dep. pattern matching - compiler: dependent prelude should work again extra (ambiguity checks): - re-enable 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 - move to megaparsec ------------------------------------------------------------------- weeks Feb 22, Feb 29 0.6 goal: type classes - docs: feature teaser, 2 min paper videos - open functions -> open type families - 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: add more structure to witnesses? - review all old disabled test cases - 100% test coverage of the parser - error messages lookup in other modules' source code, not just the compiled ones? ------------------------------------------------------------------- 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 ------------------------------------------------------------------- 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 ------------------------------------------------------------------- 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 - don't overnormalize (String => [Char]) - ... - compiler optimization: interpreted De Bruijn - docs: feature teaser, 2 min paper video ------------------------------------------------------------------- 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) -------------------------------------------------------------------- insert somewhere: - variable name normalization in the generated pipeline so that the same structures have to be equal - tail recursion -> GPU - completion in editor - support injective type families - generate warning messages for possible typos in names - warning on missing patterns - editor: show definition place & show use places of variables etc. - support pipeline storage serialization - command line flag for runTest: parse only (outputs SExp)