Dear viewer, these subtitles were generated by a machine via the service YouTube and therefore are (very) buggy. If you are capable, please help us to create good quality subtitles: https://c3subtitles.de/talk/2590 Thanks!
[Music]
well you can tell I'm uh well prepared
so so I'm Julia Longton I'm working on a
slicer so this is uh based on my work on
a uh hasal based
slicer so who am I why did I even start
this I'm a free software developer a
heavy hat Scher so I write hasle all day
whenever I'm not working um I'm the
maintainer of implicit CAD which is a 3D
modeling system that is written in
hasell and I'm also I've spent the last
three years developing a slicer which
I've unimaginatively called H slice um I
do work at wire.com but this
presentation has nothing to do with uh
any of the things I do with my
employer so I'm from Washington DC and
from Northwest Arkansas so I'm from the
United States both very nice parts of it
and very not nice parts of it so that's
part of why I uh work on things like
this I've lived in Berlin with my wife
for the last four years I am a
transhumanist a heavy Hasler and well I
wrote down cyberpunk Enthusiast which
really just
means
have
fun okay once more with feeling so that
really just means I spend too much time
watching Ghost in the Shell and other
cyberpunk uh anime and various movies
and thinking about how technology could
be uh improving my life hm
so I wrote a uh or I previously have
done some work that I presented at 31 C3
which was basically uh which was
basically using a microwave to produce
3D printed aluminum parts I have not
been doing that here since I have moved
to uh since I have moved to Germany but
that is part of what gave me the you
know impetus to the sort of the bravado
to think that I could try to write a
slicer so I'm here because I'm running a
new type of slicer it's I'm hoping that
a slicer a new slicer is going to be
able to help 3D printing technology be a
little more useful to you know not just
us who are designing 3D printed parts
and printing them in our printers but
the people who are actually using them
in the
end the reason I started this project is
if you remember about 3 years ago there
was some work on uh there was some work
on non planer slicing so slicing that
actually uh did not pile things on top
of each other like we're printing just
various weirdly shaped pancakes but
something that went down sides and down
edges so I'm wanting better slicers and
in the last three years since I've seen
that nobody has really uh nobody has
managed to get that into any of the main
Lin of any of the projects and it's
still kind of a uh kind of an experiment
that everybody uses
um I want parallel slicers so we all
have multi multi multi-core machines
nowadays but at the end of that we
uh we use a slicer that has mostly
single-threaded algorithms and single
threaded
components I want increased precision
increased speed because well I want
bioprinting that actually
works so before I started on this
project my 3D printer workflow basically
was open a text editor write a model of
a thing give it to my 3D modeling system
get out an STL see whether that STL is
anything resembling a resembling the
object I'm looking for if it is I hand
it to a slicer and that slicer
you know it generates the it generates
the print job but it takes a long time
and I mean I've spent quite a long time
waiting for a print slice and when I
looked at what was going on it's
basically just one CPU sitting there
being railed and none of the other uh
none of the other cores
operating so I take that out I put that
in my printer I print and that also
takes a long time but that's that's a
mechanical problem that's not a uh
that's not something that as a
programmer I can try to
solve so then I wait and I get a
thing so implicit CAD is kind of what I
started with it's my 3D printing stack
or the first half of my 3D printing
stack rather written in hasell there's
an online
editor source code is available it's all
agpl as as I think most of these things
should
be it it will take a description of my
object and it will produce a STL of it
which is basically just triangles on the
outside of where the object should be
it's highly parallelized because it's
it's a hasal program that uses a
marching cubes algorithm which we can
very easily parallelize so so I built a
system for myself for this that has like
28 cores 384 gigs of RAM just you know a
real machine to run it against but
whenever I try to run a slicer on that
it's using one
core so that was problems for me and
what's worse is to get 28 cores I went
and got like these little 1.7 GHz cores
so they're it takes a long
time so the job of a slicer is it reads
a file that contains one or more
objects the objects are as I said a set
of triangles on the exterior here it
defines the object into layers computes
instructions that fill in those layers
if it has different layer Heights that
gives you different different
roughnesses of the uh outside
surface so it also gives instructions
for managing the non- geometry parts of
the print making sure that the uh
plastic is at the right temperature and
flowing making sure the fans are on if
it's trying to do overhangs and it needs
something to solidify in the middle of
air and you know it writes a G-Code file
which is basically just instructions for
the printer that go from point A to
point B extrude this amount of material
move this
fast
so that is what slicers are you know
that's what a slicer job is but whenever
it's using algorithms that are single
threaded this becomes problematic cuz I
just sit there waiting
forever so why do we need better
slicers um performance scalability
number of CPUs is a really big one for
me right now since uh since my machine
just kind of sits there and stalls when
I need to go slice
something additionally the slicers that
we have are all written in imperative
languages this is causing uh problems
whenever we need to move it to something
like using a GPU to do your slicer or
using a fpga to do your slicing or any
of the
massive parallel tools that we
use um we also could use higher
Precision in our slicing so one of the
things that I've been experimenting with
is we have floating Point units in our
machines and we're all we're all stuck
with the same floating Point units but
there's different math you can use that
will utilize those floating Point units
in a more uh it'll utilize them more
more operations which will give you
higher Precision even though you're
using the same
Hardware um additionally I I want
printing to get more useful and in order
for that to happen we have to be able to
print larger things or at least more
complicated things the top one at my uh
you know the one that bounces off the
top of my head is always
bioprinting we're you know we are meet
machines we should be able to repair
those
machines so the reason that I you know
started work on this was I saw some non
planer slicing this is particularly the
uh the one that inspired this
work what did I think I would do
differently whenever I sat down to start
a slicer well I thought this this was
going to be a six-month
project this is year three and actually
it's about year three and a half and I
think I have about another year and a
half in front of me at this point so
one of my co-workers mentioned um that
you should maintain a budget of
innovation tokens if you make a decision
then that's going to cost you
tokens and you're going to have to pay
for choices that are more promising and
you know are risky when you run out of
tokens you should just generally do what
everybody else is doing in the industry
well my first Innovation token was I
used hll to do this it's a function
programming language it is lazy so it
does not perform an operation until that
operation is actually needed so it will
go back and do its homework whenever you
actually try to reference something it
separates pure from impure code so what
that means is that you know the pure
code I'm able to run or that you're able
to run on things like fpgas or gpus or
you know pure code does not have any
state that stays in it so every time you
call a function with exactly these
arguments no matter what happens you're
going to get exactly the same result
that is one of the nice things about
pure
programming I thought I would build my
own geometry engine so there are a bunch
of geometry engines that are in use by
other slicers they some of them date
back to the 80s and they have algorithms
that you know they they do date back
quite a bit so I decided I would write
my own try to use some more advanced
algorithms some of the some of the newer
techniques and
Technologies and that also let me avoid
interfacing with non-h hascal code which
means that my code could actually uh you
know take advantage of all the
parallelization and all of the and all
of the uh GPU acceleration or fpga
acceleration or I think honestly we can
probably do AI engine acceleration
nowadays so you can utilize those
components I also thought I would use a
new type of uh a new type of algebra
projective geometric algebra it uses one
more datum for every item that we're
working with so if you're looking at a
2d point you really have three values
this means you're doing math against
three values and since you're doing math
against three values generally I think
that we're going to end up with more
Precision there
that was my theory
anyway um this is the 2hour long talk
that actually convinced me to do this
somebody out there actually pointed this
out to me and uh yeah at at the point at
which I saw that uh
yeah it's good
stuff
so I also decided to use of course new
geometry algorithms specifically I'm
looking at get some stuff from uh
Christopher Sher I think that's how you
pronounce his name I don't actually know
welcome to the
Internet so how did I get started on
this step one I did not do this from
scratch I started by finding I did a
search for to see if anybody else had
actually uh actually done this before
written a Slicer in hasal and I found
one that written by a couple of uh
University students
and I went ahead and built on top of it
it already had a little bit of the math
I needed but as as as I'll show later it
was missing some uh some heavy
components like there was no test Suite
or I guess technically there was one
test but I have no idea what it was
supposed to produce
so that was a good test um it did fill
in layers of a print but it would not do
this if uh if the object had any sort of
any sort of jutting inward in the object
so as long as the object was basically
round or basically square or basically
you know a basic shape it was
fine so how did this process go well
obviously I'm standing here 3 years
later so I'm it didn't necessarily go
the
best um as I've maintained implicit CAD
for quite a number of years hascal
generally got out of my way
the floating Point rounding is a
separate Library which I did which is
only working on GHC 9 not 9.2 so I think
that was the roughest thing that uh that
using hll gave me was I didn't have the
type of precise control over floating
Point operations that I
wanted
um since I wrote this for three years
and hcll is something that uh something
that you learn as you go then I ended up
in in kind of a loop where I would go
back to a portion of the program and go
well who wrote this crap and it was
me so the compiler and type system were
working closely with me that was uh that
was nice about it and when I was
implementing a function I used a very
light implementation just Implement what
you know you need to get this test to
run and then aband then I'll hope call
the error function and you can build up
your test suite at
least when I went to add geometric
algebra there was no geometric algebra
library for hll so I wrote one and uh
that was a bit complicated because the
papers I was using they didn't really
detail what operators they were using or
more to the point they would use
multiply to mean a lot of things
and yeah trying to figure out what that
actually meant to to me well I'm you I'm
not a very highly educated in the math
type of individual so it took me a
little bit of
time um also there's a bug somewhere in
my code and the the origin point doesn't
work because of how I implemented all
this so just never put anything on z0
and you're
fine so resources to prevent the same
mistakes these are well first the bi
Vector P PDF that I show here has all
the geometric operators and there are
two versions of this out there in the
field one of which actually has all of
the how you implement the how you
implement the operators in it and that's
this one the other one kind of kept me
confused for a month because it was
missing one of the
columns also the code of course is on
GitHub
and it's all in one file so so there is
a single file implementation of
geometric
algebra so once I had the geometric
algebra working I could actually work on
the projective geometric algebra this
was a long and painful process it's
probably still a little bit incomplete
because I am still working on some of
the error handling in the floating Point
operations so I can throw a couple of
million operations at it and every now
and then something will
pop out and be
incorrect
so there are many papers which are all
written generally by the same guy who is
here in Berlin Charles Gun and he's
uh his papers are reasonable but he's
also a mathematician so it was a little
bit difficult for me to get through some
of this additionally there was a uh
there was the question of normalizing or
canonicalizing or you know it basically
was situations where okay I've done a
little bit of math and I have a result
in my hand and now I hand that result to
another function and before I can hand
that result to another function I had to
run this function against it in order
for it to be usable it was uh it was a
bit confusing so I used the type system
of hasal to only normalize or
canonicalize whenever it was required
this was handy and finding some of the
Symmetry breaking operations was ult
with this so one of the things that
they're particularly proud of is that
you can use the same operators on a
whole bunch of different objects and
they'll always give you an answer that
is sane but the problem here is that I
needed answers that were you know insane
so I needed to know whether a line was
pointing to the left of this line or a
line was pointing to the right of this
line or functions like this were
difficult to
find so the what I think is is the best
of Charles's papers is the first one
here there's also a uh geometric algebra
or projective geometric algebra
discourse so I've posted a couple of
questions there and you can get the uh
authors of the paper to respond which is
nice and again I implemented everything
in one single file so I have one file
that has all of my PGA operations in
it so then I went to the part where I
have to actually Implement new GE omry
algorithms this was yeah longer and
painful I had to get into an entirely
new area of math to me that I didn't
even know existed and
honestly I when I went to search for
other people who had developed slicers
part of the problem was I would find
that they had all gotten to about the
same point and then they looked at
straight skeleton algorithms and then
they abandoned all hope so there are
several different slicers out there that
got basically to that point and then
gave up so I found one paper on the
subject that's very approachable which
is who you know was actually useful for
what I was looking at which is uh
Christopher sh's work which is here and
hopefully this talk will be a bit on the
useful side for
this so what did I get when I was done
what do have to show for three years now
of uh three and a half years of late
nights so I have a slicer it has a
geometric algebra Library there's
floating Point error tracking on the
geometric algebra Library so I know
approximately how much error I actually
got each time I did an operation this is
nice um I have a the library supports a
mixed ukian and projective engine so
with that effective l means is we have
lines and we have line segments and they
are both in the library and can be
reasoned with at the same
time um there is a parallel straight
skeleton solver in there which uh I
haven't seen any real parallel straight
skeleton work at all and I'll show you
some of that here in a moment there's
it's implemented as a binary that tries
to emulate the command line arguments of
the cura slicing engine my hope is that
eventually I can just plug cira's front
end into this back end and have
something useful but that's still
hope there's just a hair more Precision
in what I've been doing so if I take a
file and I hand it to Cura and I slice
it and I give it exactly the same
arguments that I'm giving my program and
I slice that then I find that there's
just a little bit less filament being
used because all the lines are just a
hair straighter so there's just a little
bit more Precision in the approach that
I've been using which is honestly the
kind of uh the kind of precision I'm
looking
for so what is a scrap skeleton why do
we have to solve it why is any of this
uh why why do so many slicers die
here
so for the rest of this talk I'm going
to use a particular geometry displaying
engine this is a website that you can
just grab a section of math that is
written in JavaScript and throw it at it
and get reasonable uh reasonable
visualizations out
of so here you know I'm running a
rendering engine so here's a triangle I
can actually put out a triangle in my
rendering engine
huzzah so on this triangle you can uh
see there are of course three points and
there's also these lines that are going
through the uh through the bis sectors
of each one of the angles these lines
are the straight skeleton of this
triangle so they they are projected from
the from the bis sector of each one of
the points and they meet there at the
middle and there is a point there at the
Middle where they're always going to
collide so on uh oh where is that oh
we'll go
here so if I take that triangle and I
try to write a slightly smaller triangle
on the inside of it then you know I I
want to make sure that the new triangle
has edges that are a certain distance
away from the outside triangle because
if you're I mean if you sit down with a
piece of graph paper and you put a
square exactly on your graph paper
you're going to find that you know if
you measure that square it's going to be
off by just half of however wide the
pencil or the pen or the marker or the
crayon or the you know or the whatever
you
have it's going to be off by about half
of that on each side because what you're
putting down has a different has a has a
width to it so you have to inset
something in order to get the outside
point to be uh outside point of the
triangle in this case
to be exactly at where you have said I
want material I want this to be you know
1 cm and no wider not half a filament
wide or half of the marker wide or half
of the you know not half of any of the
components wide so the straight skeleton
is what you use to inset an
object toward its point so on this one
you can see that that line that we had
that came out of every point that line
always goes through a point of an inset
object
so here is the same thing with you know
many many triangles on the inside and
each one of those goes along the same uh
goes along the same straight skeleton so
all of the points of all those triangles
are always going to be on the straight
skeleton so here's a square same rules
apply right we have points on the edges
those points we BCT the angles there and
this gives us our straight skeleton of
the square and there is one point in the
middle that is its interior uh that is
an interior node where all of the lines
meet because they're always going to
meet in the middle for a square or or a
regular triangle or or any regular
polygon you're always going to have a
point in the Middle where all the Bice
sectors
meet so same rules apply here as the
square gets smaller the the bis sector
is actually what is part of the straight
skeleton and that is what you always
have to follow as it gets
smaller so okay so I make a thing and I
make it smaller why is this so
complicated so we take a rectangle and
do the same thing with it right well one
our points don't meet in the middle
anymore our points are actually a little
bit out to the side of the middle and
two the ratio that we have between the
top Edge and the side edge of that the
ratio differs so the ratio in the
outside rectangle is a different ratio
between the top and the side than the
one on the inside here so as the
rectangle is getting smaller it's sort
of getting its shape distorted it's no
longer you know it's no longer the same
rectangle and as we go toward a point
we're going to find that at the middle
of that there is just a line you know
each one of these sides here that those
are to uh where the bis sectors of those
triangles angles are meeting they're on
the left side and they're on the right
side those are interior nodes of our
straight skeleton and there is a you
know just a little line in the middle
which is where everything would
disappear
so drawing the straight skeleton of a
convex Contour so any Contour that we
have that does not have well if you put
a balloon around it the balloon's going
to touch all of the points right so when
you're drawing a straight skeleton you
can basically just go through and go
well what are the two if I intersect
every pair of rays in this what's the
two that are going to be the shortest
intersection and you start there you
take those you put a point where they
intersected you you throw away the nodes
and you repeat the process so for
instance with our rectangle here we
might try you know start with we know
that we have two intersections one on
the left of the center and one on the
right of the center so we pick an
intersection we go okay I'm going to put
a point there and forget about the nodes
that are behind it now I have a I have a
uh line being emitted or ar aray being
emitted from that new point and in this
case it is parallel to uh to the to the
axis here so it is pointing directly to
where the other two bis sectors
intersect so we could go okay that line
is a certain length and the other ones
are longer so we're going to put a
interior node there on the right hand
side
and and once we do
that then we have to deal with the last
uh the last angle the last bis sector
there so that last bis sector will
always intersect that node so we can
just use that and we have a straight
skeleton for this
rectangle so as I was saying convex
Contours it's reasonably reasonably easy
to figure out but whenever you end up
with some sort of a concave Edge on the
Contour what do you do with this so this
is where uh this is where the term
motorcycle starts coming into
play so the first thing I'm going to do
is I'm going to remove everything on
this figure that I don't need to do the
math so now we have just you know just
the downward angle itself and then we
have a wall which is where when we emit
a a uh Ray out of that downward angle it
runs into that wall that Ray There is
called a motorcycle in uh in projective
or in uh straight skeleton terminology
and is impossible to
Google if you try to Google motorcycle
you are going to get nowhere when it
comes to this
terminology so the motorcycle goes down
and it runs into the opposing wall and
they have a concept of speed for the
motorcycle what is the speed of a
motorcycle that is running into a
wall so the speed of a motorcycle that's
running into a wall they give it as the
distance that the motorcycle would
travel and then run into a point where
if you took one of its input line
segments and you wrot and you did a
uh if you took one of the the input line
segments to that motorcycle one of the
two line segments that is what produced
it and you moved it exactly one unit
away and you you know you have a line
there so that line is still going to
cross the motorcycle and then you
measure the distance in between where
the motorcycle was emitted and where it
runs into that line that is your speed
for this particular motorcycle now in
this case the speed of this is going to
be 1.41 something something something
something something which I run into way
too often in my math um and that is
because this is the square root of two
because we've created a triangle here
let me uh me find the math here
yeah so the line that is
parallel it runs into the uh runs into
the parallel line one unit away but
because it had to travel on a diagonal
because it was emitted at a diagonal
angle compared to that line you're going
to end up with effectively a 90° angle
and then you're Crossing that 90° angle
so you have a one on one side of the 90°
angle you're impacting it one away and
your and your distance is actually you
know A2 plus B2 equals something
something
something so the important thing is here
that the no let me get this up here so
the wall also has a speed I know this
makes absolutely no sense but it is true
in straight skeleton terminology the
wall itself has a speed and that speed
for this case is going to be one and it
is the the same rules apply here for the
speed of the wall as they do for the
motorcycle you make a you make a
parallel a parallel line one unit away
from the wall and then you measure how
long the the motorcycle traveled between
hitting the wall and hitting that line
and in this case since they're at 90°
angles with each other the answer is a
it's it's one because it came straight
down so there's a way using just these
two things to determine where the SC
skeleton has to follow which point it
goes through in order to go between the
left side and the right side of our
figure
you can calculate the point by using
just the ratio of the speed of the
motorcycle versus the speed of the
wall and then you can
also do the same thing to calculate a
line that goes through so this means
that we can from just the just the ratio
again exactly the same ratios exactly
the same math we take the the line
segment that that was on the way into
the motorcycle and we look at the line
segment that we impacted and we can use
that to determine what
the what the line in between is it will
intersect at the same point as these two
segments intersect and it will be the
ratio between those two points between
each other so in this case that's always
going to go through that same point
so what this does is this divides our
figure into two cells and the important
part here is that we can solve what's on
the left hand side and what's on the
right hand side separately because we
can determine what point the skeleton is
going to go through we can determine
what line it's going to come in on we
can determine what line it's going to go
out on and this means that we can solve
whatever comp complicated figure is on
the left hand side on one thread and
solve whatever complicated figure we
have on the right hand side on a
completely different thread so this
gives us a parallel system of solving a
straight skeleton anytime we have a
motorcycle and it makes it all the way
across we can divide that into two
threads which which divides up not only
our not only does it divide us into two
threads but it also means that each
thread can do less work because it no
longer has to look at the objects that
are on the other
side so projected geometric algebra how
did that help at all so you know all
that complicated math I just had to do
and probably did a very bad job of so
projective geometric algebra actually
gives us a
function a set of functions that will
just give you I have two points I want
the point in between them or more of the
point I want a point that has a ratio
between the two points which is our
ratio between the motorcycle speed and
the wall speed in this
case so there is a function you can use
just to get
that and you can do the same thing on
lines which is what gives us our line
segments so that complicated honestly I
couldn't draw that line in linear
algebra but projective geometric algebra
it just gives me a function that gives
me that line I just give it the ratio
and it tells me what the line should be
so I went through all this but I'm
running on a PC and there's a floating
Point Unit and this is giving me error
right floating Point units are the bane
of software
developers so I implemented PGA just the
same way everyone else does using i e
754 floating point which is a it's a
spec and it works but it has its
limitations the important part is that
on an x86 system we basically have a
couple of different modes we can use
when when uh when actually doing a
multiply we can say I want the real
answer or as close as you can get me to
the real answer we can say I want as
close as you can get but it's okay if
it's a little bit a little bit on the
high side and we can do the same thing
and go it's okay if it's a little bit on
the low side just make sure that
whatever the real answer is it's you
know above what you give me and this
means that we can use those to actually
get an error bar because we can what we
can do is we can ask for as close to the
real numbers you can get and it'll store
that but it'll be off by some amount and
then we ask for well go ahead and give
me the number that's a little bit higher
than that but just make sure that
whatever the real answer is isn't higher
than the number you give me
and then what we can do is we can look
at the What's called the unit of lease
Precision on uh on that higher
number so the unit of lease Precision is
basically you take the number and you
get just the last bit of it literally
the the last one of the bits of the
fraction and that will tell you
approximately what the error range that
you
that your math actually is so you will
get a you will get a small number but
that small number will be larger than
the amount of error that has occurred in
your
calculation
so so yeah that is the function that I'm
doing here get the closest answer to the
real answer get the closest answer that
is above the real answer store the
closest answer to the real answer and
store the unit of least Precision of the
closest answer above because that will
give you what your error amount
is
mostly so anytime you're doing an
operation you can look at this and
decide what your error bars are how much
error have I got in this operation and
the the complication here is of course
that since you know what your error bars
are you can you can try to do some
reasoning on that and you know my line
segment is so small that I'm trying to
work with here that the error bars are
you know they're so large I can't tell
the difference in between the beginning
of this segment and the end of this
segment and so what you can do is you
can call out to another Library
potentially you know use a fixed Point
function for that and this means that we
can hybridize and use both the
high-speed floating Point units that
we're used to having and also the you
know the slower fixed Point
representations of
these also what you can do is something
that uh something I kind of stole out of
watching too many videos about video
games which is you can basically put a
hit circle around what you're looking
for and go I'm going to get an answer
but it's not going to be the answer you
know it's not going to be exact so how
big of a circle around my endpoint do I
need to decide well it's close enough so
that means I hit it right so you
basically just use a hit box around it
or in this case a hit Circle because
you're using distance calculations there
will also be some error in your distance
calculation so that needs to hand you
back the error and then you take that
back into your Precision function but
you can know exactly how far away you
are or you know approximately how far
away you are enough to reason and that's
the point is being able to reason about
this sort of uh
geometry so as I said this is a hll
program so I can abuse laziness which
means I can actually call the function
and you know have a function do a piece
of math and then whenever the function
is done with that piece of math what I
can do is I can also at the same time in
that function call something that does
it in a fix Point engine and then look
look in box a and decide you know my
error amount for this is just too much
and then
dreference what's in box B without
having to go back and do the calculation
because has will do that for you it's
lazy it's not going to do its homework
until it's actually
due so how do I know any of this worked
because there's floating Point engines
and there's imprecision everywhere and
it gets
complicated so what I've been doing is I
use a I use property tests for all of
this I've been doing a property test
driven development system which is uh
well it's it's been three years now so
it's not exactly the fastest way to
develop software but it is the most
precise way to develop it so what
happens is uh you know I will I give a
function to my testing system and say
you know this function will generate a
square and and what you do is it will
generate a square given random
information anywhere so it'll generate a
square at a various angle it'll generate
a square in a random location and so
what you do is you give the testing
system a tool that says okay this is a
square well what what properties do a
square have well there should be four
sides to it those sides should have 90°
angles the the bis sectors of all those
angles should meet in the middle of the
object you know there are properties
that you can test even though you have
created this thing from completely
random input and so that's how a
property testing engine can be assisting
in this there are a ton of property
tests for this engine I think I've
written I think about 260 right now and
that's kind of been required just to
make sure that all the code stays
working while I go fix for the next test
and fix for the next test and fix for
the next
test so when I'm property testing
geometry what I've done is I create a
function which just takes a set of
inputs radian and distance so if I'm
creating a square I would use the same
distance and I would use radians that
are across from each other so I create a
function that takes radian and distance
and builds a Builds an object out of it
and then I use a property test against
that to test the
properties
so to summarize in order for 3D printing
to help more people we need to focus on
our slicers the companies that are
producing our 3D printers they you know
they're interested in selling you a
device they're not necessarily
interested in moving the
state-of-the-art
forward more parallel algorithms for
slicing are possible the math is a bit
complicated but it does work projective
geometric algebra can be used with you
know less Precision loss than Algebra I
think by doing uh by having sets of
three dams instead of two dams I think I
have more
uh
more yeah just at the end of it more
data so property testing is necessary if
you want to keep all of this working
because this is floating point and
floating point is hard and easy to
break and I want you to be able to write
a Slicer in less than the 3 years this
has taken in
me any
questions yeah you can applaud thank you
very
much so um as we are probably already
out of time because we started about 20
minutes late and we yeah would have
about 2 minutes for questions so I would
say if you have any questions you will
probably be around where where can you
anyone find you um food hacking base
food okay food hacking base so if anyone
wants to ask some questions or talk
about slicers please go and find Julia
and I think it was worth the wait so
thank you very much
[Applause]
again