take a look at a completely new and
super weird programming language called
Luna that was just just hit wonder old
beta
I am mpj and you are watching fun fun
function all right so the studio is
slowly coming together I’ve got some
cool nano leaf Aurora lights and I’m
sure if we’re gonna keep them but I
don’t know I there are there and there’s
a chair gonna get some little better
lighting in the background maybe a
little table with a lamp
maybe a plant if it’s not too
distracting we’ll see alright so Luna
one part of me here’s a person that I I
like JavaScript because it’s the most
popular programming language in the
world and you can do so much with it and
I really like that it’s an established
platform and you know the lingua franca
of the internet but I also have an
interest in the future of programming
and whenever somebody does something
really really wild and interesting and
futuristic I kind of want to take a look
and I think that Luna is one of those
languages if I was forced to describe
Luna in the limited experience I’ve had
with it is it’s a kind of a Haskell that
is visual designed for data processing
it is kind of wild if you go to Luna
Lang org this is what you get you get
this video where they show these cool
graphs where you can move things around
you connect nodes and there’s like you
can go into nodes you can change stuff
in them and live updates it feels like
it’s really really getting a lot of
feedback when you’re programming and
scrolling through stuff I don’t know
even if this video is is looping either
way it looks really really cool hey mpj
haven’t you said repeatedly over the
years that visual languages are
incredible
that is a great point I have I
have said that many many times but you
know like maybe I could be wrong maybe
like there is a visual language that
poor ones works but it turns out that
Luna is not completely a visual
programming language it is a programming
language that has a dual syntax it has
both a visual visual way of expressing
things and a text base based language
you can write things in both text and
and the visual way of doing things and
when you update the visual part the the
textual part updates so they are like
everything can be expressed as both
which is pretty funky and the text-based
part looked a lot like Haskell it’s very
heavily Haskell inspired and Haskell is
it in some ways a very very nice
language all right so let’s scroll down
here and see what we what we can find
so overview you and data immediate
connection Luna is the data processing
and visualization environment built on a
principle that people need an immediate
connection to what they are building it
provides blah blah blah blah this
immediate thing is something that I am
super interested in and I think that is
going to be like the next big leap frog
in programming after you know what we
had with object-oriented programming and
iid ease and static typing and what what
is coming next and I think that having
immediacy having kind of like going from
the right now I feel that we as the
developers are where people that edited
movies back in the day when you have had
to you had these physical strips of
eight millimeter film is that it where
you would cut them with a knife and then
tape you use a little tool to tape them
back together like right now for if
you’re writing movies you have like this
super real-time experience where you can
view things exactly where the car is and
you can very very quickly preview your
settings even if you did like advanced
color grading and stuff it’s very
impressive so there’s any immediacy in
it you don’t have to if you’re a full
market maker you no longer longer have
to simulate things in your brain that
the computer will do that for you
however as software developers our
tooling like the norm is that we have to
execute a lot of the code in our hands
and that is that is sort of a required
skill for a software developer at this
this point you have to be very good at
simulating the execution of things in
your head if you can’t do that really
well and really fast it’s going to be
hard for you to be a software developer
but I think that there is a great future
in programming tools that just
constantly gives you feedback shows you
immediately what is happening where
things are going wrong as you as you
type so with like you say and without
like not even waiting for a second
perhaps not even 100 milliseconds you
immediately get feedback on your work I
think that when you get a programming
experience like that you your goal
there’s a fantastic talk by a guy called
breath Victor he’s an x-acto employee he
has a talk called inventing on principle
it’s actually the talk is actually about
another thing completely but he
demonstrates these insanely cool
concepts for how we can do interactive
programming you’ve linked it there and
also in the episode description you
should really check it out it’s
absolutely mind-blowing and it gives you
an idea about where things things can be
taken the the person there was a person
that did a derivative on the talk like
an actual editor that was then
kick-started and eventually turned into
the programming language Eve which have
also done beta review on the channel for
a while back should probably do an
update of that and you can also check
out that and there and in the episode
description it’s pretty cool and that’s
a long way of saying that I’m super
interested about like this immediate
connection to the data that we’re
working with because that’s essentially
what a computer does it computes
daylight transforms data from one value
to another that’s what computing is
about Oh Lu notorious domains where data
processing is the primary focus such as
data science Internet of Things bayern
from adding graphic design and
architecture just to get that out of the
way this is not a web development
language this it’s not a language that
we use to build interfaces this is some
language that we use to create like
these data pipelines and stuff I have
this theory that data science is going
to be like the biggest field in
programming and the reason why I think
that is that every single company not
every needs this like not every single
company needs a needs an app not every
single company needs a website even but
every single company will have customer
data that they need to understand and
that they need to build processes the
processes around and in order to do that
the you’re going to need programming
somewhere like you’re gonna you’re going
to need a data science language in there
because eventually the data become so
bad that you can’t really do manual
analyses and like Excel or something
like that it’s just not going to cut it
really unless you’re programming in
Excel and then you’re programming well I
think that that is why I think the data
science languages are going to be
tremendously important and the biggest
feeling programming data flow graph
immersive Luna is also a powerful data
flow modeling whiteboard allowing you to
literally draw components and the way
that data flows between them visual
programming languages are
what-oh most are admittedly but for the
specific domain of moving transforming
data from one point to another and
building like a pipeline of flow of
things I think that there is some
potential to do this kind of visual
model its visualizing a pipe and a flow
might actually I think it might be
beneficial to do that in a in a visual
form over a purely textual form somehow
I I believe yeah but even if this
doesn’t work I think that this yes seems
pretty cool like listen to this you can
enter into any component or into its sub
components and move seamlessly from high
thru to low levels of abstraction at
will you can move all the way down from
a painting canvas to its underlying
bitwise operations that that’s pretty
cool ain’t it zoom out and harness the
complexity every component in Luna is
built out of other components the
hierarchical design makes it easy to
gradually change the abstraction level
zoom out to see okay so they’re suing
out here okay this looks pretty cool
zoom out to see data transformations
from a higher perspective zoom in to
fine-tune the individual components
behavior with a single keystroke you can
collapse the several connected
components it’s your new more powerful
one and share it with others so like
it’s an interesting concept of having
zoom ability in in a component based
architecture
I guess that is kind of what you’re
doing when it comes to things like react
but it’s not having it built into the
model and the IDE and the visualization
having everything tied together like
it’s a concept that is very appealing to
me visual debugging and profiling
network service outages and data
corruption are part of life but Luna can
also assist in analyzing these types of
problems when an error occurs Luna
tracks and displays its path through the
graph so that you can easily follow it
and understand where it comes from
moreover Luna records and visualizes
extensive information about performance
and memory
assumption allowing you to discover
bottle eggs just by looking at the graph
so that is what we’re seeing here on the
left it’s okay so they’re doing some
kind of Bitcoin thing are you like what
is happening oh okay
so this these things here they’re
turning red work at the speed of light
Luna was designed to focus on economics
and productivity visual components are
just code expressions which luna
analyzes and displays an interface for
oh yeah so that’s showing here like on
the on the right here they they show a
map and as you type it updates it so you
have this little every component can be
visualized so they turn on visualization
for the individual components and just
shows like what the data looks like in
that point of the flow which is pretty
darn cool modern purely functional
programming you have my attention sir
Luna is a general-purpose purely
functional programming language
incorporating many recent innovations in
programming language design such as
higher-order functions known strict
semantics algebraic data types object
oriented programming and sophisticated
type inference engine all that enclosed
in an expressive textual syntax that is
natural to read and write
okay so it’s purely functional
object-oriented using type inference and
I think it’s statically typed as well
yes static typing meets dynamic feel the
type inference engine tracks and
understands all data transformation it
also resolves ambiguities without
sacrificing the incredible safety lot
that purely functional languages are
known for however you can write our
types if you choose or ask the compiler
to write them for you for handy
documentation and here we also have
automatic parallelism Luna uses a
state-of-the-art Haskell GHC runtime
system enabling it to run thousands of
threads in a fraction of a second
moreover Luna automatically partitions
the program and schedules its execution
over
CPU cores yeah this is an advantage all
things being purely functional because
then it just all units are contained
that means that it’s very very easy to
paralyze so how hypothetically this can
be very fast as you will see it is not
very fast
yet the tool is super slow and super
alpha even though they call it a beta
that’s a live alpha but either way I’m
still very excited about this
it’s so cool to have something that have
all these features and like static
typing plus type for inference plus like
thinking about ergonomics because Pascal
has these things it’s just that I am NOT
the object oriented things but Haskell
has these things and it just they just
haven’t thought about economics at all
like the usability or Haskell is
dreadful the language could potentially
be very useful but as a user experience
it’s not fun the error messages are I
make your eyes pop out of your head but
that’s just me talking a lot about it
and looking at a webpage but actually
let me actually show you what it what it looks like