so uh this is uh a talk about um staples
Innovation lab but really it's about uh
I think the story of how closure helped
us um go from basically a two two person
startup to um you know helping some of
the largest e-commerce Merchants do
interesting things and then being
acquired by Staples so uh really quick
uh my name is Amit rur I've been using
closure for a while um and I've written
the closure in action book um as was
part of the founding team of this little
startup um and now
um thanks to the acquisition I'm VP
Staples um helping them do e-commerce
stuff and also run the Innovation lab so
this story starts in 2008 um and uh you
know e-commerce is a growing industry
it's growing by 20% a year um of a
trillion Market retail Market it's about
$200 billion a year in size in the US
Alone um but Amazon is absolutely
killing everybody in the space um and
conversion rates are really really low
and that basically means you know if
you're a merchant 1% of the traffic that
comes to your store ends up buying
something and most people most Merchants
spend money to get traffic they buy ads
they buy you know they spend on
marketing campaigns and 99% of these
dollars are wasted 9 9% of people that
come to your site don't buy anything and
Retail 101 teaches uh many Merchants how
to solve this problem you know lots of
them give away some form of price break
in order to help people buy more and of
course they leave money on the table
thanks to this because this is a very
old school way of doing things it's a
one- siiz fits-all you lower your prices
everyone gets the same load price you
know it's kind of what they had to do U
for many many years but in the age of
Big Data today and personalization of
everything um you know you can figure
out the individual's price sensitivity
in real time you can figure out where in
the buying cycle they are you can figure
out what their exact purchase intent is
um so there is really no reason to do
this uh terribly you know
non-discriminatory approach to uh
discounting and so this is where Runa
comes in and you know what we used to do
uh was to use this big data apply some
machine learning algorithms to it um you
know predictive models that would then
in real time figure out what to uh what
to do with individual Shoppers when
they're on the site um provide this as
an API essentially and that's what would
lead to profit
essentially um so this is sort of early
2008 we were a rail shop um and you know
start of in the mid 2008 time frame
start to hear about
closure and you know there's lots of
things to like obviously um it was a
lisp it was functional it's in the jvm
um so what's not to like um but of
course there were at that time a lot of
unknowns is no one was using it in
production um you know who was this rich
guy uh things like that um and then of
course Stu's book came out and that made
it production ready um so so thank you
for that um and we were in production uh
with closure later that year I think we
were probably one of the first few
companies to do it um and I remember
still that you know we used our build
used to actually check out closure uh
you it was frozen at this particular I
don't know tag or whatever they call it
uh for a long time and then in 2009 2010
we contined to do this had a lot of
success with a a small team we buildt
many more services on top of you know
using that um 95% of our code base was
and still is closure uh with some R and
python thrown in for the machine
learning
bits so at this point we were powering
350 small 2 mil uh retailers we had
about 500 requests per second load uh
thousands of predictor models um being
run in real time and all of this was
done with three engineers and one data
scientist uh running on a couple of
servers so again a huge Testament uh in
my mind to
closure pretty amazing results 10 to 30%
sales lifts which incidentally
translates to a much higher lift and
profit and if you're interested in how
that works we can chat about that
offline these are all incremental sales
so everything basically falls to the
bottom line um so you know it was great
and then the story basically continues
uh you know couple years later we've
bunch of large Merchants we powering
stuff for eBay Groupon Overstock
Target and we were doing about 10,000
requests per second over a million
predictive models in real time um with
six engineers and one data scientist
also running still on the same two
servers um again so now uh in mid 2013
um we started to work with staples turns
out is the second largest e-commerce
player in the world after Amazon and U
that was an interesting opportunity we
were doing some good work for them and
then later that year this year last
month we got acquired uh and stles
Innovation lab was born and uh I mean I
i' really have to thank everyone in the
community obviously Rich uh and others
to for all of this
awesomeness um so it was an end ofer for
us as Runa and we've been around in the
community for a for a while so you know
and you know Alison Wonderland used to
be our sort of naming everything was
named after stuff in there so but a
start of an error it's all moved over to
Hitchhiker's Guide uh as things should
um this is our logo you know sort of
named it zillion and it's kind of a
cycle that's starting again this is
early 2014 next year and you know Amazon
is still killing everyone and it's much
worse the blood bath is just ridiculous
and just to give you some sense I mean
Walmart uh as a company sold $480
billion worth of stuff last year and the
US economy the GDP is 14 trillion this
is a huge number and Amazon sold $150
billion but here's the thing Walmart's
growing at 2% Amazon's growing at
30% I mean this is what they're doing
and the reason they're doing that is
because they're a technology company and
they know how to and then and Jeff Bezos
is is a comes from a hedge fund
background he's uh you know thinking
longterm there's no way to compete with
these guys so that's where we in um the
idea is to continue what we kind of
tried to do at Runa uh just stay focused
on some very small key things within the
e-commerce landscape um and basically
build out the this next Generation uh
set of services and platforms for for
Staples and help them compete uh in this
Amazon world they're already late quite
frankly and uh we have to now accelerate
much more so than we would have had to
do so that's kind of where we're looking
to closure to help um they're also doing
a massive SK product expansion so
they're going to go up broad not just
the 35,000 Office Products they sold so
what are we going to be doing so lots of
things that Amazon knows and has been
doing really well um Dynamic pricing all
the recommendation stuff uh search whole
new search for Staples so that's kind of
the thing they've done this for a long
time our job is to you know take that
relevant bits of all of the learnings
that they've had and sort of do it in a
really compressed timeline of a couple
of years basically and the tools are
obvious
um and the people that you know we want
and that can do this are also quite
obvious I mean we going to build the
biggest badest team of closure engineers
and data scientists the world has ever
seen uh that's the plan um we were about
15 people when we got acquired we're
about 25 right now 50 people by q1 I'd
say um 300 over the next 2 or 3 years uh
this will be the biggest I hope the
baddest uh closure team and here here is
what we up against this is Amazon stock
chart Over The Last 5 Years okay almost
10x this is Staples over the same time
period a high to of 26 to 15 so the only
way to go is
up this is an opportunity and I think
with the right people with the right uh
you know team we can help you know and
participate in that upsite so but again
make no mistake you know this is a
ruthless ruthless CL uh you know
enemy um and you know traditional
Warfare has and will continue to fail
against them and so this is again an
experiment this that continues in the
power of small teams and uh you know 300
is not a very large number if you think
about it and the way we structuring that
is multiple teams doing uh you know
small teams doing uh interesting work um
each of them doing like a service or two
um inoperable apis and all of that and
uh that's kind of how we want to scale
that that human factor this is again
three 3 people small pretty small team
and up against this badass uh
Foe and so uh at this this 300 people I
mean you know it's kind
of this is the 300 um but again I'm not
under any
illusion because you know the Spartans
all
died so
uh I mean we may die too right right I
mean this is I mean startups are brutal
I've learned that and this is like a
startup but God damn it it's going to be
one hell of a fight so join us at this
uh for this thing thank
[Music]
you thanks mat I'm uh I should also
mention uh again that Staples Innovation
lab is a platinum sponsor of the
conference and uh so we thank them for
that their commitment to the closure
community so thank
you
yeah uh next up we're going to have uh
Marshall bakth van Vander talking about
parkour which is the closure
Hadoop stuff I'm sorry I don't actually
know that much about it so just released
last
week so I'm looking forward to hearing
more about
that
okay
Steve Miner are you around here
somewhere yeah oh okay you'll be up
[Music]
next yeah
they there you
go
all right all right this is Marshall
okay so I'm here to talk about parkour
which is a library for writing map
reduce jobs in idiomatic
closure uh so my motivation uh is
primarily that uh I think map reduce is
actually a really great Paradigm for
writing certain programs uh if you need
to do bulk data processing that is
linearly scalable then uh map ruce will
get you there um I also think map ruce
is actually an easy and comprehensive
ible way of thinking about programs uh a
lot of uh discussions of map ruce talk
about functions over individual key
value tupes and gluing those together
but really at least in hadoop's
implementation of map ruce you have uh
functions that are transformations over
collections of
tbal um now closure has a lot of really
great functions for transforming
collections so what I'd like to do is
write my map redu programs in
closure now if you were here 2 hours ago
at this point Point you're thinking wait
a minute doesn't calog already
exist um okay so there's that but uh
really so calog is great um I have used
and will continue to use calog but I
would contend calog is definitely not
map ruce uh calog is its own abstraction
which then as we just saw two hours ago
uh compiles to a number of different
platforms but using a paradigm which is
distinct from map reduce there are
things that you can do in map reduce
that are not easily expressed in Cask
log and by vice versa and I think it's
best to use the best tool for the
job so the primary thing that uh parkour
provides is Hadoop integration so I
explicitly want to contrast this against
rappers there's no like onetoone here's
a method in Hadoop here's a function in
parkour um and it's also not a framework
um parkour tries to go out of its way to
avoid introducing new abstractions the
idea is to take the abstractions that
are already in Hadoop and the
abstractions considering closure and
bring them together so that they work
harmoniously okay so parkour provides
some basic stuff to do things like
integrate hadoop's IO with closures IO
so Hadoop has its own distributed file
system using parkour you can use all the
standard closure iio operations directly
on things on the distributed file system
um there's some other low-l stuff like
um Hadoop has these configuration
mutable maps that we have nice functions
to access um but that's all pretty lowle
stuff more interestingly when you're
actually running a job Hadoop uses named
classes in order to implement what in
you know a functional language like
closure we just have as functions so
parkour contains the necessary Plumbing
to lift all that up so you do now just
write functions uh so this is the uh
parore version of the map and reduce
functions uh for the word count
application that uh we saw basically the
same thing that Sam Richie showed
earlier uh but so this version is you
know this runs as a map reduce job but
it's just plain functions no deaf
special def mapper no de reducer um you
write functions that then actually
literally call the normal closure
collection operations actual map cat
actual map to perform the work of that
task now in Java Hadoop um the classes
serve two purposes they hold the you
know what you're executing but they also
have names so that you can find them
when you know your code is suddenly
thrown across the cluster um in parkour
um we make this very nice onetoone
mapping so that where Hadoop wants a
class you can provide a VAR and uh this
is very nice for multiple reasons one
it's very um I think very seamless
because uh there's this clear like named
thing class named thing VAR going on but
also it's completely obvious when you
are transitioning from code that is
running locally to code that's running
remotely like you passive R because it
needs to be able to find that handle to
run it remotely there's no magic or
confusion going
on okay so configuration steps this is
the one thing where parkour comes close
to introducing a new
abstraction so in Hadoop you have a lot
of these like static methods or methods
on the job class that do things to
modify a job and you just kind of like
glue a bunch of them together in
sequence and that sets up your job
configuration
so what we do in parkour instead is we
Define a thing called a configuration
step which is pretty much literally just
a function like any function that takes
one argument which should be a job and
then it modifies it to apply parameters
which are captured through local
variables in a
closure what this does is it now means
we have a uniform abstraction for
describing things that we do to
configure a job and lets us invert the
control pattern so that we're able to
pass bits of configuration around in
order to build jobs as a composition of
things instead of having to have one
place that knows everything about what
goes into a
job so then using that this ability to
describe a job as just a sequence of
configuration steps there's an API which
lets you describe um in a nice
convenient functional DSL the
composition of the steps to form a
complete job um it has helper functions
for setting up all the stuff that you
need for a complete job input mapper
partitioner Etc um but then it has this
nice huge escape hatch where it's like
do anything you want to the job comp um
so anything literally anything that is
possible in raw Hadoop you can do in
parkour um without uh invoking any
additional
magic okay so when I said that
configuration steps were just functions
earlier I I slightly lied they're
actually um in my uh current favorite
trick they're a protocol which is
extended to ifn uh so any function of
one argument is a configur step but you
can actually have additional kinds of
configuration steps that have slightly
different Behavior so where this is
exploited in parkour is inputs and
outputs so a distributed sync is simply
a function which configures a Hadoop job
in order to Output to a particular
location using a particular output
format but it also has with it its
tandem of how to read from that uh that
location to configure a job to then
consume that output that was just
written so when you execute a job what
it returns is this tandem the DC
distributed sequence which then reads
from that same
location um and then that is again what
you pass here to the input so if you
have multiple jobs you can actually just
chain them together through composition
because the output of a job is then the
thing that you feed as the input to
another
job but by reifying distributed
sequences as their own thing not just
having them be purely these functions of
uh configuration steps we're also able
to give them additional behav Behavior
by allowing them us to reduce them
locally so here what we're doing is
we're actually taking some collection of
data that's on Hadoop and we're just
applying closure reduced to it and then
getting some local result so you can
apply exactly the same functions locally
to do local operations on that data in
your hdfs file system that you do in
your map reduce task when it runs
remotely and I needed to close that
parentheses I hope you all appreciate
that okay and uh that was all I wanted
to communicate so thank you very
[Applause]
much thanks it'll take us a sec here to
switch over uh but next up is going to
be Steve Miner talking about the way to
Eden is that his
phone
I'll mention while we're getting set up
tonight that uh the party is uh tonight
um so and that is the party is here uh
so anytime I think after 7 you can show
up and we'll start the trivia some
probably somewhere around 7:15 or
whenever a quorum arrives
uh and that should be an hour plus
however long it takes to get to uh uh do
that and then we'll be showing sneakers
after that and there will be Beverages
and uh good com rery and conversation so
please come and have a good
time ready to
go you use the podium mic if that'll
work all right I'm Steve Miner U I want
to thank the organizers for putting on a
great conference um and for giving me a
few minutes to talk here about uh little
project I've been working on so um you
know closure Community um often likes to
read old paper academic papers and get
their inspiration from uh that old work
um I feel that way about science fiction
so I watch old sci-fi shows in this case
this is an old Star Trek episode the way
to
Eden now these guys to me these guys
look like closure programmers
okay they got the hair I think that's a
that's the harmonic kit guitar
there so um so they were um in this
episode they were the space hippies were
looking for Eden and um you know they
wanted to communicate their values so um
so the Eden format was perfect for them
but uh and then there's a quote you know
there's no schemas in the Eden format
that's a good thing and steuart hway
talked to us uh yesterday about that
but schemas are useful and uh you know
we had a really good talk yesterday also
about Prismatic uh schema and um I'm
very interested in the schemas too so
it's the hippies here are looking for a
way um to describe the shape of their
data all right and they're trying to
communicate with other people and not
everyone understands what's what's going
on with
them so this is again you know the the
crew of the Enterprise is kind of uh uh
confused about what these hippies are
after what what they're talking about
um so my project is called Herbert that
comes from an insult that the the um
space hippies had for uh Captain Kirk
but uh Herbert was um a minor official
who's notorious for his rigid and
limited patterns of thought and so uh
that kind of I kind of was inspired to
own the insult there and U I was
designing a little schema language for
Eden so my goal was that I wanted to be
whiteboard compatible and I was really
starting um from a documentation point
of view I mean I was trying to just
document for myself what I was doing you
know what keys I was using what my data
structures look like and I just wanted
to have a kind of a simple tur and
readable notation so this is all in my
humble opinion about what what uh is H
simple and uh easy to
read I also once I got into this I
thought well we can make something
executable as well and actually test it
and um I kind of set up for myself a Str
that I wanted to do my Expressions about
Eden in Eden so um that's just a nice
property I don't know something feels
good when when you can express your
system in your own
system so I started with patterns um so
my schema language is kind of a pattern
matching language um the literals all
match themselves uh like you'd expect
symbols stand for something else that's
that's some way of testing things and I
I use you know very short terms so in
stands for integer and KW for keyword
and so on on um Maps um typically I had
you know literal keywords and then a
value type for the for um the
corresponding value U Vector notation
was for any kind of sequence so similar
to destructuring and then I added
anything in a list is going to be some
other kind of expression some some way
of combining other patterns and then the
obvious kind of or and or not all work
there and I think this is fairly
readable at least you can kind of take a
guess what things are are done um match
there we also added quantifiers um so
this is like regular expression
quantifiers um and they're typically in
a list notation but as a convenient
shortcut um I allow symbols with um a
suffix of one of those quantifiers it
means the same thing and then this is my
my um usual example so I'm taking a map
um and I'm specifying literal keywords
and then um types for the values um the
b in the middle there has a question
mark at the end that means that the B is
optional so if the B uh keyword is in
the map then it has to be a symbol the
value has to be a symbol but it might
not be there at all and then those are
just um some data values that would
match that
pattern okay and then for more
complicated patterns I have a grammar
and uh the idea is you can name kind of
um subpatterns and use those names as uh
as patterns in your main pattern pattern
so that's the first one and the last
form on this
um uh slide here is the Eden describing
itself in Eden so that's that that's
saying what a um valid expression would
be um for this grammar form so again
that's just a nice feeling that uh
things are expressible in Herbert that
uh I wanted to
express um we have a way of capturing
some of the match in bindings and then
you can reuse those symbols um to to
help help with other
constraints um for uh tags you I didn't
want to match exactly on classes because
I think that's a little I don't know too
brittle and Eden has this nice idea of
extending um the notation using tags so
I adopted tags as my way of kind of
doing the class match I we can do class
matching as well but this the idea here
is that if um if you say tag and then
some symbol we're going to match
anything that would have printed say
with that tag um and you know closure
defines a few um tags already for Eden
and like any of these date types all
match to inst and um I added a
convention for um records um so you can
kind of go from the record class name
into an appropriate tag and there's
another um um another Library called tag
that's used for printing if you want to
follow that convention and um at the
base of it there's a protocol so you can
if you implement this protocol any of
your Java classes or special record
classes can can participate in this and
match tags in Herbert so the API is
pretty simple there's one uh convenience
function um conforms question mark and
give it a pattern a value and it just
returns a Boolean the um the second API
call is conform with a pattern and that
returns a function that will do the the
match for you and it's with that
function a successful match actually
returns a map of The Binding so if you
have any any bindings in your expression
you can extract those bits um in the map
um and then nail if it
fails so that's Herbert um it's open
source and it's on um GitHub and on Clos
JS now so you can take a look if you're
interested and um I intend to make some
changes after seeing that great talk
about um Prismatic uh schema um I can
already integrate with them I I hadn't
heard about that you know before about a
month ago or so but um we can integrate
as predicates but I think um they might
be a good basis for doing my syntax on
top of their stuff and you know I can
kind of Leverage a lot of what they've
done and I want to thank um Eric Norman
I uses square peg um uh parser uh
library to um Implement some of my tests
and um few other things there um and
finally thank you to startrek for uh
giving that episode and inspiring the
name that's it thank you
thanks Steve I think it's uh uh Alan
you're gonna be up next um I think it's
really interesting how many talks we've
had at the conference about uh SCH
schemas describing data I should say let
me put it that way as someone who helped
out with the talk selection and
scheduling uh it was not obvious to me
that that was a theme of the conference
so it's surprising how often there's a
theme that is is
emergent Alan is going to be talking
about something called
girkin I assume everybody know is Alan
diert if not this is Alan
[Applause]
diaper everybody's heard of giren as
well it's like a little
pickle
everybody see
okay no right nobody can hear okay okay
how we doing yes hand sure whatever's
better for you okay it's on hello all
right cool so thanks everybody for
coming and seeing my my little thing
about you don't know what yet
um so uh we have this continual problem
pretty much anybody who uses a computer
has this issue where we're on Unix and
Unix gives us this thing called a shell
and um you know being a Linux user
myself I'm also kind of a
part-time uh Linux administrator and at
least as grumpy so um we have this issue
um Unix itself you know gives us
powerful Primitives to work with that we
leverage usually through the jvm or C
libraries and it also gives us this less
powerful and incredibly annoying
abstraction called the shell which is a
kind of uh disgusting non- language
that's glued together from just garbage
so but we use it all the time it's
everywhere um you know even our
beautiful closure and hcll programs are
ultimately hyper provis by some shell
script somewhere so um so what's in
Shell well it has good stuff I mean
obviously the the syntax of shell is is
optimized for for command line
interactive usage um which it's
unfortunate though that there's nothing
behind the syntax or in front of it
there's no way to extend the syntax
there's no way to access The Primitives
the syntax represents so in terms of a
programming language it's it's really
horrible but we often find ourselves in
positions where we need to write small
programs in bash because we can't count
on some dependency being there that we
need like the jvm or closure so even in
closure projects you'll often see
startup scripts or setup scripts or
install scripts written in bash and uh
they're incredibly brittle and and error
prone at least any of the ones I have
written so how do we replace
[Music]
bash so I wrote a list called girkin
it's a list one interpreter written in
bash 4 it's on on GitHub there and um
this presentation software is actually
written in girkin so we're celebrating
girkin right
now
um and uh yeah that's what it is what's
in it so it has string integers and
symbol
scalers um they're all tagged types and
it could easily support big number or
floating Point um at the bottom
everything is a string representation so
uh you know it's two string is actually
probably faster than Javas just pointing
that
out
um so yeah there you know we can do that
kind of stuff by shelling out to BC
unfortunately sub shelling and Bash is
uh very expensive because it whenever
you subshell or call a command and Bash
uh it copies the environment over which
is uh crap uh so it has garbage
collection Mark sweep uh garbage
collector pretty vanilla there it has
Dynamic binding facilties similar to the
way you create and update and do things
with closure vars has a lexical binding
facility with a fun special form uh that
does VAR addicts so you can you know you
can build destructuring on top of this
if you want and I think we all want
that uh it has you know a non-stack
consuming recursion situation inside a
fund primitive you can call recur
somewhere in tail position and not
consume stack so you can do uh a form of
TCO that way the same way you can
enclosure with a loop and it has you
know the beginnings of a namespaces
system I think uh for all you budding
girkin programmers we're going to want
to have some kind of uh you know way to
share a code uh I was thinking of like a
like a like a function you could type at
the reppel to ship off your whole world
to gist or something like hey check out
my library and just you know it's it's a
lot of free love in the girkin world
so um things it will have so it's got a
it has a de type construct in there um
it it's weird I when I learned about de
types and protocols enclosure they seem
like an add-on thing but since then I
realized having used closure script
that's there's tremendous value in
having them at the bottom and in fact in
lists like emac list which don't have um
uh a way to create a user type uh it
that complexity Works its way all the
way to the garbage collector and you'll
a lot of older lists have like separate
heaps for the different types and if you
have this user type mechanism then you
don't need to do that kind of stuff so
it it'll have macros that doesn't
currently but uh it's pretty
straightforward and there'll even be
first class so you can like write a
little anonymous macro it's pretty
sweet um it'll have a core async like
stuff built on top of the stuff that
shell gives you like fifos a fifo is
really a blocking uh uh Channel and you
can you can build CSP like stuff on top
of that which we'll
do um and then it'll have uh save world
and load world the entire state of The
Interpreter is in the bash environment
so trivially you can save your entire
you know con he Lis interpreter State
everything loaded into a.sh file that
you can then make executable
so I have a I have a vision for um you
know like I'm working on my little
program working working working I do
save world that gives me a file and then
I can send that to Amis that are booting
as a user data script um I don't know
because it's
cool things that you might consider
doing I mean you could write a closure
interpreter for it uh Spencer tipping
who is this gentleman he's not here he's
a factual guy but he wrote something
similar for bash that has actually a
concurrent garbage collector which I
want to steal um it would be a fun thing
to do in racket using their their
langing extension facilities um if I
have aliases for closure syntax we could
actually statically CH type check
gradually type all the fancy type stuff
our bash scripts which is obviously
value in that um and then uh I realized
the other day that make is kind of a
delimited form of prologue I mean it
unifies so I figure we can have like a
high performance embedded prologue that
uses
make
there are some things unfortunately it
can and will never have uh it's
impossible in bash in any shell that I'm
actually zsh has this but in bash and
any posix shell um you can't have any
kind of associative data and you don't
even have the Primitive you need to do
that which is a random access array so
it'll never have a real array it's only
linkless and Bash environment variables
it'll never have any numeric performance
whatsoever so it's not good for that and
really it's not fast in any
way but it will never ever
suck so this is you know obviously built
on a lot of prior art back to John
McCarthy but I think the number one uh
help was there's a guy Darius bacon I
think he has a really interesting GitHub
repo and uh he revived an implementation
of list Britain for a it was actually on
the list mailing list in 1994 he did
like a pretty cool update of it in 2001
and it was a good reference uh Spencer
tipping
uh he's like the most imaginative
programmer you've never heard of I
really recommend typing his name into
Google and and uh staying up all night
reading his amazing stuff he's got some
cool stuff Aaron Brooks a cooworker of
mine gave me some early feedback on the
reader uh and Aaron Griffith uh friend
of Aaron the other aand who I've never
met gave me more feedback and then Joel
Martin the other day you know I was
telling my co-workers about this and you
know nobody believed me at first but
then eventually they started helping
Joel Martin um he uh taught me a little
bit about readline so we have you know
readline down here so you can have
history which is actually better than
the closure reppel was for a long time
so um and then actually Joel Martin I
was like well you know wouldn't it be
cool if we could write web servers in
girkin but the problem is you can't bind
to his socket and Bash so Joel Martin
did something completely unexpected
which is he added that to bash and sent
a patch to
the so you know our platform is getting
there we're have pretty
sweet um so yeah I can do a little I'm
going to do a little uh demo here we're
going to switch over to the rapple and
I'll switch
microphones okay maybe I won't switch
microphones but I'll just go over a
little code um oh
thanks oh wow that's
service okay so there was a reppel over
here and that's the the readline repple
and you know you can type stuff in like
do stuff over here that's cool um but
you know you can also run it in an
inferior lisp and actually uh just to
show off the the startup time here Bo GK
repple boom
lisping uh and you know you can evaluate
some stuff so make some functions ink
well that's that's true and you know we
have you have functions with lexical
Scopes so you can do you know real legit
functional programming reduce plus 0 one
two
3
H uh and then you know everything else
you'd expect so you know it has this um
and of course ju an an essential like
primitive
um so yeah that's the whole thing it's
on uh oh so I guess a little bit if you
want to contribute good luck to
you so it's about a thousand lines of
bash I'm trying to keep it around a
thousand lines I I think that's we can
keep it there um but you know it's a lot
lot of stuff just kind of keeps
going uh yeah but it follows the pattern
of of oisp so you know how we evaluate a
special how we evaluate a A Primitive
and all that stuff is fairly split out
um I'd say 30% of the code is working
around like just weird bash stuff like
you can't have new line at the end of a
bash or you can't have white space at
the end of a bash variable it'll get
truncated when you store that variable
so there are places where I have to like
maintain Sentinels and of course the
star is unreadable because it expands
out to the like
the current stuff in the current
directory so that was like a fun little
thing
um but yeah it's all out there you know
have fun uh I hopefully the presentation
serves as a little road map if you're
interested in contributing I mean I
definitely don't want to write this
would be the last big bash script I ever
write this Pro this thing so um you know
if we can if we can get it to a point
where the interop story is good and it
starts up reasonably quickly and
generally rules then none of us will
hopefully ever have to write bash
scripts again so let's let's do that
[Applause]