Skip to content

Main goals

Jump to bottom
vird edited this page May 25, 2017 · 19 revisions

Initial reason

  • I tired to rewrite same code 5+ times for different optimizations/languages.
    • I tired to make different mistakes in different implementations.
  • [Iced]CoffeeScript is dead. When i start to use it it was 5-year-ahead language. Now it's collaborationist in ES6-ES7 family. With not-so-good generator support, not making any new braking feature in 5 years.
  • I have enough experience to make tool for myself. I have 3-5 failed tools, I know my and my older tools good and bad parts.
  • Vuejs is 1 developer at start project with good success story. So I can too.
  • React is good example how to break compatibility with all other world and develop lots of new stuff in separate universe. So SS is the same separate universe.

Current direction

  • Easy compose of any-size blocks as Lego
  • "This was last time I wrote function that do X in env Y"
    • Connect MY service A to MY service B. Sync protocols. Ensure that all works.
    • Decide where code should be executed. Protocol. Start/restart/stop. Coordinator. Multithread management. Priority. Data locality. CPU cache hidden miss. Perf manual tuning.
    • Write OpenCL kernel
  • Prototype and real deploy should be close. Hardware is cheap. Coding time is expensive.
  • 80% performance can be reached using simple rules. Local microtuning is still possible.
    • Your data may not fit in your memory. Eat it piece-by-piece.
    • Know cost of operations in hardware (e.g. div, call+ret is expensive; branching, bank conflict on GPU is really bad)
    • Parallel, Async, Data oriented design is your friends.
  • Single machine is not enough. Multithreading must have but it's only beginning.
  • Single GPU is not enough. Managing multiple kernels on multiple GPU must be easy.
  • 2+? level design.
    • Top level pipe scheme
    • May be some intermediate level
    • Low level implementation of blocks
  • "Write once debug everywhere" is not bad. At last you "write once".
  • 1-space change semantics should be avoided
# NOTE. This can't be reached now
a +b
a + b
a+b

# NOTE. This is reachable by remove ? binary operator, remove a ? space syntax, and ban a? b func call.
a?b:c
a? b:c
a ? b:c
  • Sync and async operations on top level design make no difference.
    • Let compiler decides how to implement it.
    • You can fix it in monitoring.
    • [LATER] You can fix it in special annotations.
  • Blocks are not binded to some programming language. So theoretically is possible to do following:
    • FPGA firmware with existing pipeline
    • Generate board gerber files
  • Generic operations e.g. filter, sort come separately but can be optimized in source block.
    • Some similar stuff Halide do. You have 2 parts of your code: what to do, how to do.
  • NPE should be avoided by type inference.
  • Application scheme at top level should fit 52" 4k monitor. So long expressions is ok. Scheme formatting should be reasonably beautiful.

Compilation targets

  • Javascript
    • +optional asm js (no string support)
    • +optional GPU
  • Rust
    • +optional GPU
  • FPGA
    • Altera
    • Xilinx
  • ??? Xeon PHI

Scope

  • Bash script replacement
  • Web
    • Dynamic applications
    • SPA
    • Scraping
  • DB, pubsub
  • Image processing
  • Simulators, solvers, complex game assistants/stats-mans
  • Multi-threading, -machine, -architecture
  • High performance demand applications
  • Cryptography acceleration + fast prototyping

Clone this wiki locally