caneka

A programming langauge for streams and lifecycles

Caneka is based on a common computer science challenge: "How to handle something, and move on, when the order is not the same". The langauge automatically populates virtual stacks and queues to handle tasks that would otherwise involve extensive handling.

Consider a real world example:

How do you know the end of a movie...
When the credits role!

Notice that the differences could be the credits, blank screen, different music, the names of real people, or certain conditionals such as the titles only apearing after a period of time.

This is the case for every parser, and most lifecycle based computer science problems. If you're parsing mixed content such as "number 128938 is cool". The number will only be complete when you recieve the space after the second 8. Any numerical character, in and of itself, is not an indication that the numerical content has been fully encountered.

Example Caneka Code

    cycle Movie 
        new { 
            if(titles() and later() and realPeople()){
                @ending
            }else{
                @experience
            }
        } experience {
            sad() ->
                cry()
                hugFriends()
            happy() ->
                yay()
            political() ->
                shout("oh $!@t not again. 'merica").then(goVote())
            other() ->
                thinkDeeply()

            @new
        } ending { 
            turnOffTube()
            startTalking()
            goHome()
        }
    }

    watching = Movie()
    for scene in theMovie
        watching(scene)
    

What is Cycle Oriented Programming?

Cycle Oriented Programming is a paradigm of software development where the presence of periodic cycles is at the for-front of the system architecture.

This differentiates between the more physical-likeness paradigm of Object Oriented Programming and the pure-predicate based Functional Programming paradigms by focusing on the presence of jumps and cycles as a means of defining structure.

Here is a list of where you may have seen the foundational concepts of Cycle Oriented Programming in other paradigms

Cycle Oriented TerminologyStandard TerminologyWhere it's Commonly Practiced
Cycle ServiceCo-operative multi-processingFunctional Programming (OOP as well but it's more effective with Closures/Co-routines)
MatchesSimilar to Regular Expressions with CallbacksAll paradigms
Roebling ParserRouting within a set of MatchesProcedural Programming
PolymorphismMore or less the same (compile checked/runtime enforced)Object Oriented Programming
CursorsIterators with state hooksObject Oriented/Functional Programming
Callback ArchitectureHigher Order Functions and Co-RoutinesFunctional Programming
Data-Driven BehaviourFirst Class Functions stored in ArraysFunctional Programming
Memory ContextSimilar to mark/sweep, but more accurately place/dumpGarbage Collection

Status

In development: the language components are presently in prototype form while we draft a white-paper and seek additional funding. See unit test status on our company site for details.