Luna is a developer’s whiteboard on steroids. Design, prototype, develop and refactor any application simply by connecting visual elements together. Collaborate with co-workers, interactively fine tune parameters, inspect the results and visually profile the performance in real-time.
Software design always starts with a whiteboard. We sketch all necessary components and connect them to visualize dependencies. Such component diagram is an exceptionally efficient foundation for collaboration, while providing clear view over the system architecture and effectively bridging the gap between technical and non-technical team members.
Unfortunately, it is impossible to execute the diagram itself, therefore the logic has to be implemented as a code. The traditional development involves writing thousands of lines of code scattered over hundreds of files, which makes the flow of data unclear and the application architecture hard to understand and extend. While there are many tools addressing the subsequent issues, such as UML architecture diagrams, they do not work well as they deal with symptoms, not the source of the problem. The diagrams tend to quickly become obsolete and they need to be manually updated, so that their consistency is hard to maintain. On the other hand, a pen and a whiteboard are still the most efficient way to design a software.
Luna is the world’s first programming language featuring two exchangeable representations: textual and visual, which you can freely switch at any time. It lets you keep your own coding habits, while giving all the advantages of graphical whiteboard-like interface.
The visual representation redefines the workflow ergonomy, drastically shortening the time needed for software development.
The visual representation reveals incredible amounts of invaluable information about the structure, behaviour and the flow of the data in the program. It allows for capturing big picture on any stage of a workflow, makes the navigation much easier, enables fast and interactive development and profiling. Detailed performance analysis and real-time visualisation of results enable rapid prototyping. All these advantages can be beneficial for both technical and non-technical people.
Luna provides a concise and expressive textual syntax that is elegant yet natural to read and write. It comes equipped with full power of purely functional programming style.
Collaboration is a natural property of software engineering involving many individuals working in a team: developers, architects, business analysts, graphic designers and operations people. Luna bridges the gap between collaborators of different professions. It allows to deliver production-ready software, yet it is easy enough to be used by non-technical team members. It opens up an entire universe of undiscovered ways of collaboration.
Visual profiling is the most efficient way to inspect and understand all the performance bottlenecks of your application. After enabling the debugging mode, Luna gathers detailed evaluation statistics including computation time, CPU / GPU memory allocation, network transfer and threading model. It can be visualised and interactively inspected using the Nodelab environment.
Although Luna provides notion of objects, it is not an Object Oriented language. Luna is a Category Oriented language instead.
Category Oriented Programming is a relatively new programming paradigm, developed as a result of our research on modern functional programming. You can think of it as a generalization of Object Oriented Programming mixed with purely Functional one in a world of dependent types. It combines the incredible type safety known from purely functional languages with widely approved convenience to model the world in terms of communicating objects.
After releasing public Luna alpha version we will also publish a detailed article regarding the Category Oriented Programming paradigm.
Luna is a general purpose, purely functional programming language incorporating many recent innovations in programming language design, including:
Higher-order functions
Incrementing every element of random generated list, while passing both random as well as + functions as arguments:
print [0..100] . each @random . each (+ 1)
Non-strict semantics and laziness
Computing every possible prime number and printing the first hundred to the screen:
def filterPrime [p|ps]:
p | filterPrime [x for x in ps if x.mod p != 0]
allPrimes = filterPrime [2..]
print allPrimes.take 100
User-defined algebraic datatypes
Implementation of Bool type within Luna standard library:
class Bool:
True
False
Structural pattern matching
Creating a Point object definition, its instance and reading its values using pattern matching mechanism:
class Point:
x y z :: Int
origin = Point 0 0 0
Point x y _ = origin
print 'Origin XY coords are ($x,$y)'
List comprehensions
Removing from list all words starting with underscore:
print [s for s in lst if s.head != '_']
Monadic I/O system
The Luna's type checker and inferencer understand which functions are I/O actions and which are pure:
def myTestFunction x:
print x + 1
>> typeOf myTestFunction
myTestFunction :: Num -> Num in IO
Data-flow error handling
Reading user's age from a file and asking about it when an I/O error occured:
fileAge = open 'age.txt' . to Int
age = fileAge.catch e:
print 'An error occured: ' + e
read 'Provide your age: ' . to Int
Strong dependent type system
Luna will accept the following code:
lst = [1,2,3]
print lst.head
But will reject the following one, cause it cannot guarantee it will not fail at runtime (unless you enable compiler option --types.partial.allow):
lst = [0..random]
print lst.head
Luna is a great environment for programming language polyglots. Foreign language interoperability is just as easy as creating new foreign node and pasting any Haskell or Python code inside. You can of course use foreign clause in the textual representation as well. Wide range of libraries are ready for an instant use with ease. Interoperability with C++ and JavaScript is in our schedule. Stay tuned!
Please keep in mind that unlike Luna, other programming languages are not designed with visual representation in mind and their source code cannot be expanded to a graph representation.
Luna is able to automatically partition a program and schedule its execution over every available CPU core in order to shorten the computation time as much as possible.
The final performance of a program depends largely on optimizations performed by the compiler, but not every language can be optimized the same way. Luna and its type system were designed to deliver all the necessary information to allow drastic compile-time optimization.
Luna facilitates running millions of threads in a fraction of second due to its light-weight thread model, which schedules logical threads onto available thread pool provided by the operating system.
The primary concurrency control mechanism which Luna uses is similar to database transactions but it works for shared memory. It is a better alternative to semaphore based synchronization, because it is safer and allows better composability.
Support for software transactional memory is an ongoing work which will be released as a library.
Luna ships with a state of the art compiler and an interactive interpreter written entirely in Haskell and Luna itself. The compiler produces either fast machine code native for Linux, OS X or Windows, or JavaScript targeting the web.
We will release the compiler as an open-source project as fast as Luna hits the public beta version.
Fill the form below and we will contact you. You can provide just your email address, but we would choose the first group of alpha-collaborators among those, who provide the details.