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) - normalized variable names in the generated pipeline (so that the same structures have to be equal) next: - blog about release: - few sentences about the past events - this is the 2nd version (first rewrite) of the DSL using the learnings from the first one - we experimented with a few approaches to solve some given problems (quick reduction, pattern match compilation, type inference) - type inference is more expressive and faster - reduction: partial evaluation - 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 - more complete and better documentation - make it possible to write a small mobile game (Android or iOS) by the summer - we'd like (brave) people to try it and provide feedback - support local pattern matching functions - support recursive local definitions - mutual recursion (inference & reduction) - compiler: ConName --> Int - compiler optimization: irrelevance + erasure - compiler: support let labels - re-enable ambiguity checks - show desugared source code on a tab in the editor - testenv: add editor examples as backend tests - testenv: performance benchmarks (time and memory consumption) - command line flag for runTest: parse only (outputs SExp) - compiler: generate samplers (OpenGL 3.3) - backend: setup texture sampler configuration (purescript) - backend: setup viewport for render target size (purescript) - backend: array support - backend: generate let in shaders - backend: GLSL codegen doesn't support Vector and tuple patterns (not compiler frontend related): fragment02tuple fragment02vectorpattern fragment05uniform - backend: basic pipeline optimization (let-floating) - editor: highlight errors in editor - editor: editor socket reconnection - docs: feature teaser, 2 min paper videos - minimal quake videos - documentation: getting started: hello world on various platforms +Csaba 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 - support heterogeneous lists - 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 - 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 - 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 - error messages lookup in other modules' source code, not just the compiled ones? - tail recursion -> GPU ------------------------------------------------------------------- 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 - don't overnormalize (String => [Char]) - ... - 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 -------------------------------------------------------------------- insert somewhere - editor: input editor (add/edit new uniform values e.g. floats, matrixes and textures if possible)