Player is loading...

Embed

Embed code

Transcriptions

Note: this content has been automatically generated.
00:00:00
wow
00:00:09
i i i didn't expect it that's all
00:00:14
again that was like what what i did i
00:00:22
so uh i'm gonna be here too
00:00:26
give the welcome address for this tenth anniversary edition of
00:00:30
saturday's and i'm gonna talk mostly about a tour of
00:00:33
schuyler three but before i do that i also wonder shows some of the photos of us got that's really so
00:00:39
it was an l. much smaller building this building doesn't
00:00:42
exist yet a hundred fifty five people was packed with that
00:00:46
uh actually it was a really dangerous because here you
00:00:50
see me very close to actually the border of this podium
00:00:54
and in fact probably a second later so s. else
00:00:57
as self it between this thing and and the screen uh
00:01:01
and then resurfaced so he i already looked and it looks solid so i i hope it won't happen uh
00:01:09
that we all uh quite a lot younger than uh you can see and you can already see some of the
00:01:15
germs off the software that we uh that you we sort of our daily
00:01:19
life now so yeah i think that was probably the first presentation of a car
00:01:24
you're innocent later uh here you have my car uh
00:01:27
no doubt thinking about uh the all the grandiose designs of
00:01:31
s. p. t. that he had in mind here we have two miles uh i might was not yet working on shapeless
00:01:37
and i will keep silence on what what we did for that
00:01:44
there are some curious parallels between then and now
00:01:47
so in two thousand ten what was new for the old timers it's got about twenty remember
00:01:53
what was what was the hot new thing in two thousand ten well it was actually collection it's uh
00:01:59
it's got two point eight came out at that conference and to big new thing was essentially i complete
00:02:05
collections framework which at functional and a mutable collections
00:02:09
in the same framework before we had sort of odds
00:02:12
and ends some specific collections but not nothing completely general
00:02:17
rice and today well today we released yesterday to thirteen
00:02:22
and what's the highlight of two thirteen even data collections so this
00:02:28
might give the impression that collections have been up to constant topic but
00:02:31
actually no uh that was the first redesign since two thousand and
00:02:35
and i can attest that that's hundred percent can build from freight if
00:02:41
so it's got to thirteen they came out yesterday that big thing was
00:02:45
new collections uh even better than before i think nicer a clean and all
00:02:50
the signatures uh don't need can book from and that would be the
00:02:53
talk about that by age difference i go on wednesday a seventeen forty five
00:02:58
another thing that got updated was the futures implementation and that would be
00:03:02
a talk by that that's what like victor clan on wednesday forking thirty
00:03:07
a two thirteen was meant to be mostly a a release a a library really
00:03:12
it's very updated libraries but actually they manage to sneak in quite a few language changes
00:03:18
uh including literal types uh you're gonna see some of them on my slides later
00:03:23
passion unification the same as as i twenty seven twelve as well now on by the fart
00:03:28
uh by naming presents micro annotations and many
00:03:31
many polishing details overall uh we merge all
00:03:35
twelve sixteen hundred people requests from hundred sixty two contributions and a huge thank you i
00:03:49
thank you everyone who was involved in that and made it happen
00:03:53
that's another curious parallel between now and then in uh it it
00:03:57
in two thousand ten when you came up with um it's gonna to
00:04:00
point to it uh uh people criticising than says what it really
00:04:05
should have been it's kind of free because there were some breaking a
00:04:09
it changes in the language uh for instance the way we resolved
00:04:13
a package scopes a change so that was technically uh breaking language change
00:04:18
so we should have been the major version we didn't at the time
00:04:21
because we had announced got a two point eight already a year ahead
00:04:25
and this was a late change so we didn't really want to change the bread the
00:04:29
the brand of the language everybody was talking about two point eight so now nine years later
00:04:34
we're almost ready so it's kind of three point zero
00:04:36
has almost right uh finally uh ended but in the in
00:04:41
the in the ten years anniversary it would be really really trips so that's a big news uh you could say well
00:04:47
uh over over ten years for the sighted closes itself at the time it was something
00:04:52
that should have been three zero and now we present something that will be three zero
00:04:56
so the road map that we're looking uh i had until we had finished
00:05:01
three zero is uh it's be have we currently here june two thousand nineteen
00:05:06
all features have been fleshed out with implementations in the current
00:05:10
talk to realise that we have is that you're rolling really strain
00:05:13
right now we're at a zero sixteen uh we plan to go into feature freeze
00:05:20
uh later this year in fall of the written by when not yet in feature freeze is that
00:05:25
uh we want to really play with that ourselves uh before
00:05:29
we have freeze it and uh say it won't change anymore
00:05:32
and from basically today on our internal setup is such that
00:05:38
we will not build with that's got to anymore so that
00:05:41
means finally uh we have a bootstrap that will only bootstrap
00:05:44
from ourselves and we won't even runs gonna to when the tests
00:05:48
and that means we can finally we factor the compiler at the library
00:05:52
and the other code bases to use this kind of three exclusively and that
00:05:56
means we get we actually get to try out all the mikes features that
00:06:00
we have a trend often designed and implemented in our code base and before
00:06:06
we have done that we don't really want to freeze it and ship something that we might regret later on so it will take a little bit
00:06:12
longer uh and to fall this year and then we will be an actual
00:06:16
feature freeze and that will coincide with the release of scanner three milestone one
00:06:21
and then we want to give us those those you're about to talk to uh to get
00:06:27
the stabilisation right essentially pass all the tests a
00:06:31
flash out any remaining bugs that it's the uh
00:06:34
would be uh the whole thing is a standardised in this gonna improvement process probably uh that uh we
00:06:41
have to complete so the subcommittee did essentially initial
00:06:44
sweep over uh all the features in there and
00:06:48
uh prove most of them some of them uh
00:06:51
on probation uh essentially a rating for further uh okay
00:06:57
for for the consummation in actual use but we have to go
00:07:01
through all the proposals bit by bit come up with the spec
00:07:04
that vote on it and uh that way make it part of
00:07:08
the language we need a have to migrate the open source ecosystem
00:07:12
uh there's already some some are uh are very encouraging start
00:07:16
some of the packages have already started to have versions with happy
00:07:21
we need to flesh out the tests uh the community built and you have to work on compatibility and migration tools
00:07:27
so that all together should take about a year with things so that means we're looking at that's kind of three point zero final
00:07:33
in at towards the the and for two thousand twenty what's
00:07:37
a parrot to that uh this ongoing development in this gonna
00:07:42
to branch so ah at about this time we also hope
00:07:46
to have a two fourteen uh which uh was purpose will be
00:07:50
essentially to ease the migration to this new language three
00:07:56
so what's in it uh so what's in it for you
00:07:59
for the developers uh what's in the language it's actually i
00:08:03
rather big big envelope it's task for which features so i had to structure
00:08:09
it a little bit i thought i'd do a best office two or so
00:08:13
i won us essentially to oppress else got a three uh asking one has
00:08:18
what in my opinion are the nicest features of that's got the nicest new features
00:08:24
and they're of course it depends who you are a beginner might appreciate something which
00:08:29
uh an expert fun mindset boring and an expert might be uh might be you
00:08:34
blown away by a thing which is completely incomprehensible to begin so i have grave it it
00:08:39
to say one uh the this feature for beginners one for every day coding one for experts
00:08:45
so i'll give you for my personal ranking of the top three in each
00:08:48
category and also get a what does serve a uh last weekend aware of um
00:08:55
overall i think uh i got fifteen hundred or more responses so i respond on that what the public thought
00:09:02
the nicest features full because that's actually at at that level most of the language stays
00:09:07
the same so there's not that much but then have unless a few improvements worth mentioning
00:09:13
so the number three my opinion is that we we were going to drop new so you
00:09:19
have a class spent over a just a boring class it's not the case class or anything and
00:09:25
in the future you'll be able to write just thing though it b. c. or string builder
00:09:29
open parents close barons and that's the same as if you had put in the thing with you
00:09:36
so you still have new around the main reason is that it's you needed
00:09:41
to do something you ate a notably if you what you write is the apply
00:09:45
method let's say you have a you want to do some checking additional checking or
00:09:49
hash cancelling or whatever in the apply method of the string build a class then
00:09:54
if you just costing below without any arguments then you risk on yourselves which of course wouldn't do
00:10:00
that would give you a string dover sole they you have sort of the new with a fallback
00:10:05
is that we can still use this to create one but we anticipated generally new will be gone
00:10:10
uh because it's just nicer to to not to it and it doesn't add anything in the future
00:10:16
okay uh the uh one advantage of that discourse is that you don't need to define the case class anymore
00:10:22
just to get nice a constructor calls and there were quite a few people who did that
00:10:28
what's number two so for me number two is a top level definition
00:10:33
if operative emissions is essentially dropping a restriction uh
00:10:37
previously uh your top level definitions had to be objects of classes and now they can
00:10:42
be anything so you can inside a package or you can also leave out the package
00:10:48
and not do anything uh uh you can have type definitions small definitions uh uh the
00:10:53
method definitions uh all of these things so that means that package objects are no longer needed
00:10:59
and they will be phased out a replicated
00:11:02
in in future versions and afterwards finally say stop
00:11:07
that was number two so what's number one of clearly for me number one is intense
00:11:15
in um this is just such a nice and simple way to to find a new type
00:11:20
uh with a finite number values a construct so in on colour case red green blue finish
00:11:25
that's all you need and uh right now we're in in
00:11:29
in skylights it wasn't actually that's simple to set up something
00:11:33
like that where a a libraries that was an enumeration type
00:11:38
in the standard library that worked sort of uh there was a
00:11:42
package called intimate our drum that also works sort of but it's
00:11:45
just much much more straightforward to have this the language furthermore what you
00:11:50
have is not just the the the simple things so that was
00:11:53
the simplest example but you can actually add everything to it that a
00:11:57
java in um would to uh so you could can have the
00:12:00
numbers that have a parameters like this one here you can of cases
00:12:05
that pass parameters so yeah the planets give you the mouse and the
00:12:08
radius you can have a field to kind of methods in these in
00:12:13
and in fact you can be fully java compatible so
00:12:16
that's done here by just extending javelin in m. so
00:12:19
that's essentially signed to the compiler that the other compilers generate call up so that this in um use of
00:12:26
a for java a a a on is in um that it can you can use like any of the names
00:12:33
okay so this is again cool uh now we have parity there's java but we can actually go way so it
00:12:40
enhanced can not only have value parameters they also kind of type parameters like that's so you
00:12:46
can have any number option with the covariance type parameter t. and then two cases some and non
00:12:53
so that of course gives you what people call and actually back teletype or a d. t.
00:12:59
that's kind of so far was lacking a simple way to write an algebraic data type
00:13:04
what you had to do what is essentially what the compiler would translate this to so the
00:13:09
compiler would take this and eighty three that you've seen here and translated into essentially that's
00:13:15
and so far if you wanted something like that you would have written essentially the same thing
00:13:21
so uh sealed abstract classes you tried option with the case class that's one case
00:13:26
and here it's uh well but otherwise you could also use a case up to object as the other case
00:13:32
of um and that of course is completely workable uh
00:13:36
but it's kind of tedious on when scott i started the
00:13:40
main the ball one of the main motivations was to
00:13:44
avoid pointless boilerplate soul that's why case classes were invented and
00:13:48
a lot of other innovations that just made a bit
00:13:51
code more pleasant to write and more compact and java core
00:13:55
stand up at the time and uh it one has to recognise that during all these years
00:14:02
the software about has just that also a little bit and it's now much more functional than before
00:14:08
so an algebraic data type would have been something very foreign
00:14:12
at the time two thousand speed to some form and colour
00:14:14
came out but now it's pretty pretty common and people right
00:14:17
then and write more and more of them because also with essentially
00:14:21
more steady typing you where you want to write more and
00:14:24
more types of more more class hierarchy uh case iraqis and editing
00:14:28
is that just a lovely simple way to do that so
00:14:32
in the spirit of reducing boilerplate it seen it it it was
00:14:36
uh about time uh to have something that uh
00:14:40
makes this case simple and straight forward to express
00:14:45
but that's that's not even the end of it we can do more so we can also
00:14:49
do j. d. t.'s did it is it i'd generalised algebraic data types and that different from normal
00:14:55
eighty eighty tees in that the cases can inherit the base class at different types so you're
00:15:02
you it haven't you know i'm tree of t. v. and three cases tools falls in the zero
00:15:07
that extended that type boolean and two more cases that extended to type and and the
00:15:12
final case if that takes a a tree of new orleans and two three of the
00:15:17
the arbitrary and that just extends a tree at the
00:15:20
type where the then part and the else part extend
00:15:24
so this sort of thing is actually relatively advanced not that many line
00:15:29
have it and i believe there's not a single it is not the same whiteboard language
00:15:34
out there that has in arms eighties angie it it it's all in the same language feature
00:15:39
i think it has still has of course t. i. d. t.'s but the g. d.
00:15:42
t.'s with completely differently from eighty to use that different construct whereas here it's a natural progression
00:15:50
okay so that was my personal favourites uh what about the public so
00:15:54
the public actually agrees by and large so public like in m. s.
00:16:00
uh by a large margin a a drop new was second and top level definitions with third
00:16:06
so why in arms wide we all agree on in arms well a lot of use cases and they're becoming more common
00:16:13
it avoids boring repetitive boilerplate and it can grow from very very simple colour
00:16:19
red green blue to actually very very powerful for brown a. g. a. d. t.'s
00:16:24
uh that uh it can can extend the base types it different types and if
00:16:30
you take it that far then of course you would say well that's way beyond
00:16:33
the feature for beginners so it's a feature so that essentially takes a beginner until they
00:16:38
begin there is no longer but you know but uh a guy experienced or even an expert
00:16:44
so in on science teacher not just for beginners but definitely also for every day coding but now i've
00:16:49
already used by number one so nice other features assigned to us find other features for every bit coding
00:16:55
yeah actually lots and lots of candidates for this level of and it's
00:16:59
hard to even come up with a shortlist so even that was somewhat
00:17:02
arbitrary but uh and i tried nevertheless to say well what i well
00:17:07
it straight top innovations the uh for me number three is union types
00:17:12
uh so you have an example of a human typos first you have to
00:17:16
case classes user name and password here here and then you have to help function
00:17:22
that is an she can get some identification which is either a user
00:17:26
name or password and essentially depending on what it is uh you look up
00:17:32
the name or you look at uh the passport and uh so this
00:17:36
gives you essentially an ad hoc combination of two types user name and password
00:17:42
didn't have a common superclass the red designed that way but it doesn't matter you can just write the
00:17:46
union type user name or password right here we have it yeah so that's the vertical bar right here
00:17:56
so it gives you a very flexible way to model
00:17:58
pipes because subsiding so having fewer choices is up typing uh
00:18:04
and that means you can always essentially go from one
00:18:06
to the other very effectively the current alternative is uh so
00:18:11
in a sense a heavier in dark yeah that's the the alternative would be
00:18:15
to use an ida so you could of course right either user name and
00:18:18
password but that then you would have to inject it left and right and
00:18:22
you would have to extract and it's in a sense here not necessary because you
00:18:27
don't need a left and draw right there's an injection or extraction because the
00:18:32
class the classes are perfectly good to distinguish between the two you can in since
00:18:38
it's object oriented that just normal classes you can ask is it a user
00:18:42
name or is it a parts of course there's some situations where you need either
00:18:46
p. l. p. features you you need it in the generic setting on maybe sometimes you actually asked the same type on
00:18:52
the left and on the right and then of course you need an additional tackle unit type wouldn't work but in ninety
00:18:57
nine percent of the situations i'd i imagine in your unit
00:19:00
type would fit the bill quite well and i should say
00:19:04
there's no boxing high overhead like with either essentially the user
00:19:08
name or password the representation is literally what the underlying representation
00:19:12
it's so you don't need another object that essentially represents the alternative between one or the other
00:19:20
another nice uh with uh aspect of human types is that they
00:19:24
work with singles impacts so you can now defined a come on
00:19:28
it's a the command is either the string click that is an example of a little type that uh if sean you
00:19:34
into thirteen so little pipe we can just use little like that and say well that's that's it's the type that just
00:19:40
consists of the single string click and uh you have to
00:19:44
continue the example the command would be click or drag okey
00:19:48
press and then you could have an event handler that takes a come on so we know it's one of these three
00:19:53
and just has essentially a pattern match on those three things and we know that pattern matches exhausted
00:19:59
so this is nice if we handle event have taken a more general type like string you couldn't
00:20:04
verify that the pattern match was actually exhaustive somebody could come up with a different name um with miss
00:20:11
type a string and the result would be around ten thirty where is here everything is kept safe it
00:20:18
so that was number three form so what's better than union types but for me it's it's it's a toss
00:20:25
it says very close race but for me i would
00:20:27
put that number two extension methods of so extension methods are
00:20:32
a very neat way to uh just define methods uh
00:20:37
that can then be used in fix uh without any
00:20:41
big uh or low plato contortions so you say hey
00:20:45
um i mean this method actually exists uh and it's uh
00:20:49
implemented with an implicit class which are replaced by this feature
00:20:53
but if i've wanted to uh be redefined it myself so
00:20:56
i want to have that sort of thing which says well take a spring and a concatenated string with itself the number of
00:21:02
times that i give you sore star operator for strings so that was obvious way to write that would be to say well
00:21:09
i want to be final a star but it should come after us twenty two so i put an argument to the left
00:21:15
and the right argument isn't it so that the number of
00:21:18
times i want to that's going to repeat any given to constrain
00:21:22
and here's the implementation if excess lets them was equal zero
00:21:26
then it's the empty string otherwise it's it's times x. minus one
00:21:30
process so i can use this start immediately as in in six
00:21:34
operator here in hopes that i jumped ahead and gave it away
00:21:39
um so uh that makes it a lot easier to add method strings it to to existing class
00:21:47
and for that reason it's for me and number two uh the
00:21:51
other nice thing about extension method is it that it plays really well with
00:21:57
the number one feature in my that's the number one feature my list is delegates
00:22:02
so delegates are in no way to think about in places
00:22:06
impressions of course i everywhere it's gotta ninety five point something
00:22:11
uh put a a percent of all projects use some form
00:22:15
of impresses according to a survey so they are sort of the
00:22:20
bedrock of a of a programming it's gotta nevertheless implicit have a lot of
00:22:25
challenges people get confused people uh do it the wrong way people curse uh
00:22:31
that is that has to use other people's systems were in place it's with
00:22:34
set up wrong so uh we thought that it there should be a concerted
00:22:39
effort to get out the good parts of simpler sits and removes the uh
00:22:44
the traps and the pitfalls as much as possible and hard off the and
00:22:49
so for that not all of it but part of the answer for that
00:22:52
is syntax so the new way to define an implicit is here called delegate
00:22:58
so what you have here is a standard setup of implicit you have uh try to
00:23:02
work it has an extension method compared to put two things it has another extension method less
00:23:08
than that uses compared to like this one so that's my trite or and i want
00:23:12
to essentially have various implications of the straightened up here just show you a a single one
00:23:18
that encourages order so i have this and that here's what i write
00:23:22
that right yellow cake into or for order of in it and then
00:23:26
i give you the implementation of the compared to my for my implementation
00:23:30
of the less than method of course it's standing hurried uh as usual
00:23:35
and uh the last bit of the slide is i have a maximum method
00:23:39
it says well i want to get this stuff to use for
00:23:43
arbitrary element type he but there must be an order fifty that so
00:23:48
the order of t. must be implemented so for instance list of
00:23:52
into would qualify because yeah i haven't into work and here's the
00:23:55
implementation of maximum so it's up to use will reduce operate that
00:23:59
that uses less than operate at that it gets from the order instance
00:24:05
if you want to do the same thing but current implicit i challenge you i don't think you will fit to someone slide
00:24:11
it's possible uh but it's really hard in particular with uh in six
00:24:16
operators because you wouldn't need one implicit to send you set the pace
00:24:20
set up the basic type classes and then another to pull in the in
00:24:24
the uh yeah in six operators as a as a decorators and things like that
00:24:31
so this is a a much simpler way to talk about these things and it
00:24:36
actually turns out it works really well with type classes so you you see another
00:24:42
example typical type class thing where we have so many groups let's try to to
00:24:46
combine method of mono it's uh which uh you add a unit method so again
00:24:52
this is an extension of that there's a normal method and now we have a delegate for mono it
00:24:57
of spring so that that that like it can actually be anonymous uh i can leave out the name
00:25:02
and it gives you implementations of pose a the extension method here
00:25:07
that's a combined effort and the unit method over there and turn
00:25:13
then i can define that as some method that takes an arbitrary type
00:25:18
it must have one or if it's a context pounds so that's and
00:25:21
just as usual ah another way to say that there must be a mono
00:25:25
it of p. um a delegate of type one it of key and it
00:25:29
takes a list of teas and gives you backup p. and it uses of
00:25:33
old less where it starts with the morning read of t. documented so the
00:25:38
use basic is the same thing is implicitly slightly better it has uh has
00:25:42
like gives you more concise type uh so you say the moderator fifty documents
00:25:47
so that gives you the unit thing and then you call the combine function
00:25:51
so the reason why this works is actually i mean here it
00:25:54
all looks completely natural and simple but the reason by this worked
00:25:57
is is actually a a quite subtle so the reason
00:26:02
why this works is that uh the fact that i
00:26:05
can use an extension nets that hangs together with the
00:26:09
fact that i have a mono it instance in school
00:26:12
oh that's a rule for extension methods that say you a
00:26:15
if if they ah yeah defined in something for which you have
00:26:20
a delegate instance and scroll then you can apply not just you
00:26:23
don't need to just import it or bring it into school bother
00:26:27
so that's essentially a very we all uh
00:26:31
sought out combination off extension methods and these delegates
00:26:37
uh another uh nice aspect of delegates is that they train implicit conversions
00:26:43
so here you have an implicit conversion if you read an implicit tutorial force colour
00:26:48
then often it would start off with something like that into string or something like that
00:26:53
uh so you have to just fight implicit and then a definite string and it
00:26:57
gives you you're a token and that's and keywords what uh what's wrong with this picture
00:27:05
nothing really is is a perfectly good good good method uh but
00:27:10
but it's too easy actually because uh we have learned all that
00:27:15
writing a lot of these conversions is probably a recipe for disaster because they tend
00:27:21
to interact very badly one with each other and that just add too much implicit
00:27:26
so it's too easy to write compared to how dangerous
00:27:29
it is implicit as a modify will go away and
00:27:33
with that this kind of conversion so in the future these things will be first deprecated and then say so
00:27:39
so if these things are no longer nor unavailable what do you do then
00:27:43
to write the conversion but a big and so it's probably think hard whether you really need one because
00:27:50
like i said implicit conversions in ninety five percent of
00:27:53
the cases in my experience i really the wrong solution
00:27:57
but if you after this deliberation you decide that yes i do
00:28:00
need an implicit conversion and you can define it as a delegate
00:28:04
so again the idea is that now the only way to express
00:28:09
implicit conversions is as a delegate for a standard class courts cannot conversion
00:28:15
uh so here you have a cult conversion of string to token and
00:28:18
you can can we find a delegate for it which means that if
00:28:21
uh implicit search tries to find a term uh of this type conversion string to poke and and
00:28:27
the delegate would be essential qualified and would be chosen and the delegate would then have an apply method
00:28:33
because conversions are essentially functions uh add that it's an cheap that's what you need to do
00:28:39
what you can also do is you can make it a little bit uh shorter you can use and i'm just delegate
00:28:45
use can save you delegate for conversion string token equals new keyword on disk
00:28:50
so that would also work that would give you the same thing uh using same types as a mechanism
00:28:57
okay so that was the uh the my
00:28:59
personal uh banking delegates extension that's that's human
00:29:04
types let's see what the public set of well i meg actually paid union types for us
00:29:10
so it was uh the that my ranking was reversed extension that's that's second and revised in
00:29:16
places that's what i call them in the in the in the uh on the call that's it
00:29:23
so why do i realise that delegates are uh and nevertheless number one in this list well
00:29:30
like i said in places as got us most distinguished feature but they also
00:29:35
the most controversial feature really and delegates gives you a much simpler and safer alternative
00:29:41
the main difference if you think about delegates or
00:29:44
the traditional implicit says that delegates emphasise intend over
00:29:48
mechanism with the current implicit you said well you can slap it on everything on i'll on of our
00:29:55
or marlin about what they're foreign object on a class and it sort
00:29:59
of subtly changes the meaning of things uh in ways which are quite
00:30:04
logical i mean it's not it's it's not a mystical the specification
00:30:09
it's quite a precise about it but it was sort of us
00:30:13
and mechanistic mechanistic saying that people had to say well i want to
00:30:17
construct now this thing and here's how i do it it wasn't so much
00:30:22
that the expressed the intent to say well i haven't typed last and i
00:30:25
want to have an instance or delegate for this type class at this time
00:30:29
you could choose that but there are many many steps sometimes to get a a
00:30:34
two arrives there and having many steps to arrive they also means having many steps
00:30:38
to get it wrong so net that's essentially now kong uh at them they therefore
00:30:44
make the idea of german friends much more accessible instead of saying basically you have
00:30:50
five different meanings of the word implicit there's a single one for delegates so we only
00:30:54
have to teach a single thing and finally they discourage abusers i've already shown you that
00:31:00
essentially the easy way to write implicit conversions is gone there will also
00:31:04
tightened the belt for in imports which is sort of the other pit
00:31:08
problematic feature within plus it's where you say i don't know where my
00:31:11
impression to come in from some delegates as an answer for that as well
00:31:15
so the actually many improvements it's not just syntax over the current implicit
00:31:20
uh which i can't really go into details including a
00:31:24
names don't matter insect everything can be anonymous for him plus
00:31:28
it's because you want to essentially trade a term for
00:31:31
type you never want to know what the terms precisely corp
00:31:35
nesting significant uh which means that you can actually uh have a
00:31:39
simple way to achieve local coherence uh the no shadowing problems uh it
00:31:46
be restricted the implicit scope where impresses i searched
00:31:50
which avoids some nasty surprises as a more robust
00:31:53
prior authorisation uh then no accidental conversions that you
00:31:57
can get and we have better or error messages
00:32:02
the hardest thing for that was really not coming up with the design the design that's
00:32:07
been stable for about six months now that naming them uh what are these things called these
00:32:13
terms that i'd say well the compiler says i need an implicit of what types of then
00:32:19
comes up with the term what you call the tour or you can say implicit instance are
00:32:23
implicit object because it value that's what we said but that's a compound thing that's not that's
00:32:28
not a simple thing that you say well it's this and uh event actually too long list
00:32:34
of names my original proposal was witness that got shot down and then there was evidence and
00:32:39
implement instance and imply this human so and and in the anti settled on that like it
00:32:45
in the end i believe it won't matter as much it we just need a noun
00:32:49
that's easy to remember me the noun in eighteen because we want to talk
00:32:53
about these things that at last uh as a as a as a categorisation
00:32:59
right so that was the my number one for the everyday coding what about experts advanced
00:33:04
regions so since kind of three puts matter programming on a new basis yes actually lot
00:33:10
of advanced features to choose from and it's very difficult to pick a winner so i
00:33:15
could you again my my personal list and that number three i would put match types
00:33:22
so he is what we can do with match types of uh i've simplified things a little bit so let's say we have a couple
00:33:28
but uh you know i'm with two cases empty and yeah so uh
00:33:33
a a packed up oh i'm to topple a now wouldn't it
00:33:36
be nice if you could write a comcast function that concatenate arbitrary temples
00:33:43
uh before we write such a compact function we have to say
00:33:46
well what should what put that type of that can cut function be
00:33:50
of course it could return couple but that wouldn't be very specific what
00:33:54
you really would want to is that if you use the let's say if
00:33:57
i have a pair of intense training and i want to concatenate that with
00:34:00
a pair of boredom fraught then i would get in strained wooden fraught affordable
00:34:05
so i want to compute types uh at compile time uh by the
00:34:11
compiler so here's how i would do this now with using match types
00:34:15
so i can actually find a type calm cat that takes essential to
00:34:19
set types of topple so that would be my pair pipes or whatever
00:34:23
and then it i can have a match in the type which says well if the first of
00:34:29
this type is uh the empty topple then the result of concatenation is the second uh second uh
00:34:35
a parameter and if it's a pair raise an element type uh x.
00:34:41
and the second element type excess then it a result is again a pair
00:34:46
uh with the first element type here and a concatenation of the rest excess
00:34:51
and y. yes as a second and and so this is just like computing worse
00:34:56
functions up like you would probably right to come cut function but
00:35:00
on tax so the whole thing but some types um it's uh
00:35:05
you could say well that in principle that's not new we know how to do that it's
00:35:10
caught ageless i so in current colour this it's ages so what's the difference between this and agents
00:35:16
main h. list h. lists are a way to get fine implicit
00:35:21
so you can essentially a you can never talk about that type
00:35:25
being the concatenation of two other types what you can
00:35:28
say is it's a type terrible results and there's an h.
00:35:32
list implicit that takes essentially to the to input types and
00:35:36
the result type and puts them in relation to each other
00:35:40
so it's like the difference between logic programming which is what age this is really
00:35:44
you only have crosses that put things in relation and functional programming what this is
00:35:50
you have to have a function that defines the result
00:35:53
directly and the effect can be quite quite profile uh which
00:35:58
we will see when we apply match types in the other things on my ranking on on my rank somewhat somewhat to
00:36:06
so something number two is a type class derivation uh so we've seen
00:36:10
type classes will be very important uh there's so much nicer syntax for them
00:36:15
uh that's one problem though with type classes and that is that while it's
00:36:20
very easy for them in um or a class uh to extend an interface
00:36:26
it's a lot more board up lately and uh and and
00:36:30
cumbersome to have it e. d. reiser typecast to have it
00:36:34
implement a type class and it doesn't really have to do
00:36:37
that way because a lot of these type class implementations be it
00:36:41
for me quality or ordering or fair legislation actually pretty boring
00:36:47
they're very repetitive to do the same thing over and over again
00:36:50
for every case class that'd be fine so in uh in this kind of three what you can do here is it can
00:36:57
the final in um or class of the matter you can just say it derives equal and ordering him pick
00:37:03
and it can be right any type class including type classes that you would be fine
00:37:08
so what what does this device to keep your eyes uh
00:37:12
uh it's time to well it's actually quite simple just to generate simply three delegates
00:37:18
uh which all have the form that we say well the type teeny pop type
00:37:23
parameter team must be re 'cause if we have the same uh type class and then
00:37:28
it's it's angie it would give you an instance of the type classical ordering and picking
00:37:32
and the right hand side is always a image that dot the riots that must exist
00:37:38
in the type class so top derived is where you was
00:37:42
a library designer coming that's the function that you have to
00:37:45
define to make this all works also for this is essentially
00:37:48
just very nice sofa syntax for the user of the library
00:37:52
so that the use of a library can mix in the type classes without any contortions
00:37:58
so i should say how you do with the the equal dot derives there will be a talk uh
00:38:03
about this time i seven who were that says that you just finished shapeless three fourths got a three
00:38:09
uh that will essentially use this mechanism to derive type classes
00:38:14
but i wanted to give you a little glimpse sort of on
00:38:17
the on the the techniques used for that anyway so he is
00:38:20
sort of a single at the start of a thing to roll
00:38:23
it yourselves uh if you use my cell plus you can essentially contents that and martin you don't need to write all this
00:38:30
but it's actually a quite just just to give you a a
00:38:33
a and it should need clean of what this would look like
00:38:38
so here's the deal lived method for the e. q. a class so
00:38:42
it gives you a new instance of the type class it has to be
00:38:45
fine be equal method which takes two elements of the type and gives
00:38:48
you a boolean and what it also gets as a a a given closer
00:38:53
a parameter is essentially a mirror and the mirror is something that essentially
00:38:57
represents the type structure off uh the a. t. here we're off t. so
00:39:03
wanted to what then we would then say well what kind of mirror to uh have if it if it does some or is it the product
00:39:09
uh some is a sense yeah alternative a product is uh use
00:39:14
uh a case class typically uh and then i it would essentially do
00:39:19
something which is adapted to this kind of mirror so for some of
00:39:23
it would call a method in the mail which is called order now
00:39:26
so that gives you basically the case also the instance that excess so
00:39:31
it would say well what's the case number starting from zero avoid excess
00:39:37
and they would say well that must actually be the same as the wharton or flight because otherwise it couldn't be equal and
00:39:43
then we have to going to equal cases which is then
00:39:45
she will know again statically what are the element types of stuff
00:39:50
uh and it would go through that and if it's a product it will essentially go
00:39:54
to through equal elements and again it will know the element types of the product so
00:40:00
then to actually make work uh you have to dissect these
00:40:03
types and the way you do that is typically with match
00:40:06
types and what you've seen here uh both in line assets
00:40:11
so this whole essentially construction which works with a match types in
00:40:16
line methods macros uh is essentially the thing that makes it
00:40:21
all taken and shapeless three gives you essentially just a very very
00:40:24
nice cover on top of it so about the basics there
00:40:28
will be a talk by nicholas to keep on thursday eleven fifteen
00:40:32
so what's number one is actually number one is a suggestion for miles uh a number
00:40:38
one i think a good way to wrap number one up is to say functions everywhere
00:40:44
so what does that mean well it's kinda it's you know we asked my sense which are just
00:40:49
but you members of classes and objects and we have
00:40:53
functions which are objects themselves and that two different things
00:40:57
and there's a reason for that because otherwise essentially you'd
00:41:00
get you'd get an infinite recursion soul functions and values object
00:41:04
and methods are members of objects and so far
00:41:09
um and methods vary quite a bit more powerful than
00:41:12
functions methods could be dependent so the result type could
00:41:16
depend on the parameter types that could be porn norfolk
00:41:19
so they could expect parameters and of course the could be impressive that could take implicit parameters
00:41:25
the functions could be none of these things why not well because they were not types that could
00:41:30
express these things as function types you got only the normal function type a to b. u.
00:41:35
a. and b. two c. or whatever and uh that you couldn't express these dependencies polymorphism or impressive
00:41:42
and now it's got a three you can still use an example for dependent function sold you
00:41:47
you you start up let's say you have a graph and the test to member types node and
00:41:52
edge and then you want to frighten node extractor which is a function that takes a graph
00:41:57
and it gives you as a result a result of a a value of type g. don't know
00:42:03
so uh in the g. here refers to the actual parameter so that we call
00:42:08
a dependent method if it's a method or here it's the function type dependent function type
00:42:13
so it's kind of three uh you have dependent function types
00:42:17
that mirror the pen and that's that's a about polymorphic methods
00:42:21
uh let's say you want to give you the type of the identity function in pretty deaf
00:42:26
i would say well it's t. two t. for any t. in you i would respond yes but what
00:42:31
is the time how do you make that into a type so now you can what you need is
00:42:36
essentially a function type that says well for any type he gets skew it gives me t. two t.
00:42:42
so you have functions that can that's not only values as arguments but that can have types is i could
00:42:48
and finally for implicit some methods can be implicit and functions can be the same so
00:42:54
here you would have a a a type executable a that is a function type that says
00:43:01
it goes from execution context to t. v. but the execution to context is given or
00:43:07
implicit which means that whenever i have a value of that function s. for a given parameter
00:43:13
the argument will be synthesise automatically by the compiler
00:43:19
cool so that was the the my top three for the experts what about the public what
00:43:24
so public about actually by a large margin put type class television first uh but uh
00:43:31
maybe it was because i only had implicit function types so one third of the century
00:43:36
the functions everywhere mantra so if you add the other ones maybe that would have gotten
00:43:40
more support and match types uh where it it tight with implicit function types on second place
00:43:48
okay so one i want to conclude with one nice way to that
00:43:52
uh uh powerpoints to uh some of the synergies that it's features could have
00:43:57
so here the uh task as you want to enable that's some tax here so we want to be able to
00:44:04
write list of one two three top some of course
00:44:08
we can do that and then we want to use ensuring
00:44:11
so that's a post condition result equals six ensuring is
00:44:16
a method to include have a was used ensuring already
00:44:21
not that many more of you showed is a very very
00:44:24
useful method because it essentially lets you program with contracts um
00:44:28
d. but big problem so far was that ensuring couldn't really talk about the
00:44:33
result that uh uh the function added without put in making an amtrak here so
00:44:38
it had to say you know you basically result arrow result equals six another by
00:44:44
was to kind of clunky so it would it's feels much nicer to just has
00:44:48
essentially a name for it to say that the result should be six so how can we achieve that
00:44:53
by just essentially clever coding so here's what we would
00:44:57
do a you have to define the subject post conditions
00:45:01
uh so here's insurance it's an influx might uh it's uh it's an
00:45:04
extension method us because it's used essentially on arbitrary uh elements of type t.
00:45:11
um it and it takes a condition and the condition is one of the
00:45:15
is it important function types so it takes a rap t. so uh that
00:45:20
clearly within the n. b. that your result uh and to boolean
00:45:25
and what it says it says it's well just assert this condition
00:45:29
given makes uh so the axes is that should the result that would
00:45:33
it's lost into uh the the argument of this condition
00:45:37
so we pass the result to the condition and uh
00:45:40
de conditioned then will be sent you return true or
00:45:43
false and it must return to always get an exception violation
00:45:47
so what then is results this without that we caught by the
00:45:51
result is simply a a a a function that takes an implicit
00:45:55
parameter are of type rap of t. and gives you back a
00:45:58
t. and what is rap or rock is essentially is saying that
00:46:03
makes the whole thing size because with the four opportunities we don't
00:46:06
want to carry around implicit so it's a thing where we say but
00:46:10
that's essentially a wrapper for the type key that is only used
00:46:14
here in this context and uh in fact there's repartee uh it doesn't
00:46:19
do anything it is equal to t. it's the type ah yes but
00:46:23
it's an opaque type ideas that i've got no only in the setting
00:46:27
cool so now probably your head to some some of it's been uh i can't see
00:46:32
very well uh because of the lighting so and you ask yourself is kind of funny
00:46:38
a new language this all looks pretty wild and foreign to me
00:46:43
and the answer is yes uh so many language changes that will be feature
00:46:48
remove rules there are already many feature rules that would be more in the future
00:46:53
the new construct improve user experience and
00:46:57
on boarding quite dramatically in some cases
00:47:00
and the box of scott i will have to be rewritten so up a current pecans kind of
00:47:05
will feel dated for this new language but on the other hand you could also use answer now
00:47:11
because it's still it's gotta it still looks and feels
00:47:14
like it's gotta all of the core constructs remain in place
00:47:18
and the latin very practical common subset between schuyler and skylights colour to wince colour
00:47:23
three excess i know because our compiler code base it's written in the sense that uh
00:47:29
by by tomorrow probably will diverged because now we don't have to
00:47:32
do with anymore but until now it was within the subject it wasn't
00:47:36
a say in the stuff that in wasn't paying for the dog
00:47:39
basically everything you have tons gonna to you can still use another the
00:47:44
a large software package actually larger much larger is gonna
00:47:47
compiler that compiles and both already it's it's got a test
00:47:52
it's all between yes and no i think the fairest answer is to say it's
00:47:56
really a process callously keeps most constructs of
00:48:00
schuyler else to thirteen alongside the new ones
00:48:04
and some constructs like old implicit and so on will
00:48:07
be deprecated in phase out in the three topics release trying
00:48:12
so that requires some temporary duplication in the language but the end result
00:48:16
should be a more compact and regular language so here's a list of
00:48:21
some of the replacements that i'm stores and some of the most of
00:48:24
the things you've seen so exports a experts we haven't seen top level definitions
00:48:29
uh would replace a package objects the
00:48:32
delegates replace implicit s. allows objects conversions extension
00:48:37
methods replace implicit classes and in line
00:48:41
staging next match types replaces the current macros
00:48:46
may i present that uh i hear sometimes uh complains
00:48:51
that says well why so many new features at once can't
00:48:54
you do it bit by bit over many many releases wouldn't that be a saying that way to do it well the
00:49:02
one four problematic pointy or the one constraint t. it's really
00:49:06
that's kind of three is when the box will be written
00:49:10
so essentially now all my box all my tutorials on cause
00:49:14
they're uh will have to be rewritten or re recorded because
00:49:18
things i mean you wouldn't want to start a tutorial
00:49:22
uh without the nouns or without a extension that's that's and
00:49:25
that's the these things these are things that are basic enough that you wanted to them even in the can of scorched
00:49:31
so that means that the features we need to get in now in three zero are features that
00:49:37
affect the foundations of us got out that simplify
00:49:41
leipzig in particular for learners because you don't want to
00:49:45
teach a more complicated version when instead of three point one a
00:49:49
simple replacement will come out and that will replace existing features you don't
00:49:53
want to write a book or a new version of the book with a feature that will be replaced in the next version of scholastic it's
00:50:00
so that also was for us a very strong guidance
00:50:03
what to put in this language really is we prioritised foundations
00:50:08
simplifications and restrictions that we did not prioritise so we be a
00:50:13
second settle where uh the features that gets added power to expert develop
00:50:19
it's and they work a lot of propositions about those of course potentially new forms of for expressions of
00:50:24
things like that new forms of pattern matching that makes
00:50:27
certain specialised idioms easier to express nothing's wrong with them
00:50:32
but we felt that we don't need to put them into sky that three point zero we have enough
00:50:38
uh uh uh to do already with all the simplifications
00:50:42
and restrictions and foundational editions that we want to do
00:50:47
so how do you how do we get there how do we get two
00:50:50
three zero uh if you have a source compatibility for very large comes up said
00:50:55
uh we will rely to some degree on the right tools uh tools that take
00:50:59
can handle much of the rest i'm quite confident that the situation is a lot better
00:51:05
than price and with which often this is often a compared to also because it's a
00:51:10
transition from two to three uh mostly because we have static typing and in in fact
00:51:16
we have taken great pains not to change the run time behaviour at all
00:51:21
uh that you'd really any changes be there would be would affect the
00:51:25
types so it would be things you crap like this at compile time
00:51:29
rather than why you'd be back your program a while you your software
00:51:33
is in production and uh because of binary compatibility so why binary compatibility well
00:51:40
already today we can make starting so the precursors
00:51:43
kind of three and scarlet to twelve or not
00:51:47
colour to thirteen some as soon as that that's uh that's essentially see a significant adoption
00:51:52
will switch to that so it means we can have a dotty was gonna three module that
00:51:56
sits on top of stella to library i'm can consume it no problem uh so
00:52:01
we're not we don't need to essentially bring everything up to three one can switch
00:52:06
but in the future this will actually go both ways uh so
00:52:11
uh we it will also be possible to have a dog to library module
00:52:15
that can then be consumed by it's gonna to module or else kind of remote
00:52:20
so that means you can really mix and match things on the binary level uh
00:52:25
as as you want and that means you don't need to bring the
00:52:27
whole ecosystem over two three as was the case in in price and three
00:52:32
it's so the reason why it all works it's called tasty type abstract syntax
00:52:37
trees i've already talked at length about them at previous conferences essentially what it
00:52:42
is is it's a way to zero lies your program in have form which
00:52:47
is which has all the types and all the impresses and everything is in
00:52:50
the everything is very very explicit in these things and but on on the
00:52:55
other hand it doesn't have any of the encoding problems that we need them
00:53:00
to map this on other platforms like the j. v. m. or j. yes
00:53:04
or uh or naked for things like that so it's basically a high i'd the
00:53:08
maximally explicit high level format of your program the amazing thing is
00:53:13
also very calm compact it's about as compact as source and the idea
00:53:17
is that then this would be the standard format that people could
00:53:21
uh extension map to and consume and that would make it a possible
00:53:26
uh there's a set of inter operability where we have two and
00:53:29
three modules talking to each other yeah that promise off this oh
00:53:34
ash and i should say that's a talk about the spike we
00:53:37
on my plants on wednesday ten fifteen uh if you're interested in
00:53:41
in hearing more about this and the other cool thing about tasty
00:53:46
is that it promises the solution is the partial solution to the
00:53:51
binary compatibility problem so the plan is to keep the tasty format
00:53:55
stable binary compatible over the whole three topics series unlike currently where but
00:54:02
unfortunately we have to break uh that that format with every a
00:54:06
a major version because essentially there's always a little to tweak or
00:54:10
another that doesn't work uh on the by the way b. u.
00:54:14
b. um we comply to byte codes so that means that compiled from
00:54:19
tasty then allows co to migrate without the current problems of binary
00:54:24
compatibility so uh i between three zero point three one that would
00:54:28
probably be still some some some shakeout something like that but the
00:54:32
hope is that afterwards you will have a completely different binary compatibility story
00:54:37
so you can try it out if they think that the dot e. e. p. f. l. dot
00:54:41
c. h. and thank you all for listening and
00:54:44
uh i think uh we or radio over time sorry
00:54:50
okay cool
00:54:55
okay
00:55:16
he
00:55:20
i just
00:55:36
well i actually sat and aquatic just place
00:55:55
it's not just

Share this talk: 


Conference Program

Welcome!
11 June 2019 · 5:03 p.m.
169 views
A Tour of Scala 3
Martin Odersky, Professor EPFL, Chairman Typesafe
11 June 2019 · 5:15 p.m.
733 views
A story of unification: from Apache Spark to MLflow
Reynold Xin, Databricks
12 June 2019 · 9:15 a.m.
In Types We Trust
Bill Venners, Artima, Inc
12 June 2019 · 10:15 a.m.
113 views
Creating Native iOS and Android Apps in Scala without tears
Zahari Dichev, Bullet.io
12 June 2019 · 10:16 a.m.
103 views
Techniques for Teaching Scala
Noel Welsh, Inner Product and Underscore
12 June 2019 · 10:17 a.m.
Future-proofing Scala: the TASTY intermediate representation
Guillaume Martres, student at EPFL
12 June 2019 · 10:18 a.m.
Metals: rich code editing for Scala in VS Code, Vim, Emacs and beyond
Ólafur Páll Geirsson, Scala Center
12 June 2019 · 11:15 a.m.
178 views
Akka Streams to the Extreme
Heiko Seeberger, independent consultant
12 June 2019 · 11:16 a.m.
Scala First: Lessons from 3 student generations
Bjorn Regnell, Lund Univ., Sweden.
12 June 2019 · 11:17 a.m.
Cellular Automata: How to become an artist with a few lines
Maciej Gorywoda, Wire, Berlin
12 June 2019 · 11:18 a.m.
Why Netflix ❤'s Scala for Machine Learning
Jeremy Smith & Aish, Netflix
12 June 2019 · 12:15 p.m.
104 views
Massively Parallel Distributed Scala Compilation... And You!
Stu Hood, Twitter
12 June 2019 · 12:16 p.m.
Polymorphism in Scala
Petra Bierleutgeb
12 June 2019 · 12:17 p.m.
sbt core concepts
Eugene Yokota, Scala Team at Lightbend
12 June 2019 · 12:18 p.m.
Double your performance: Scala's missing optimizing compiler
Li Haoyi, author Ammonite, Mill, FastParse, uPickle, and many more.
12 June 2019 · 2:30 p.m.
1,002 views
Making Our Future Bette
Viktor Klang, Lightbend
12 June 2019 · 2:31 p.m.
104 views
Testing in the postapocalyptic future
Daniel Westheide, INNOQ
12 June 2019 · 2:32 p.m.
Context Buddy: the tool that knows your code better than you
Krzysztof Romanowski, sphere.it conference
12 June 2019 · 2:33 p.m.
The Shape(less) of Type Class Derivation in Scala 3
Miles Sabin, Underscore Consulting
12 June 2019 · 3:30 p.m.
195 views
Refactor all the things!
Daniela Sfregola, organizer of the London Scala User Group meetup
12 June 2019 · 3:31 p.m.
Integrating Developer Experiences - Build Server Protocol
Justin Kaeser, IntelliJ Scala
12 June 2019 · 3:32 p.m.
Managing an Akka Cluster on Kubernetes
Markus Jura, MOIA
12 June 2019 · 3:33 p.m.
Serverless Scala - Functions as SuperDuperMicroServices
Josh Suereth, Donna Malayeri & James Ward, Author of Scala In Depth; Google ; Google
12 June 2019 · 4:45 p.m.
How are we going to migrate to Scala 3.0, aka Dotty?
Lukas Rytz, Lightbend
12 June 2019 · 4:46 p.m.
Concurrent programming in 2019: Akka, Monix or ZIO?
Adam Warski, co-founders of SoftwareMill
12 June 2019 · 4:47 p.m.
108 views
ScalaJS and Typescript: an unlikely romance
Jeremy Hughes, Lightbend
12 June 2019 · 4:48 p.m.
117 views
Pure Functional Database Programming‚ without JDBC
Rob Norris
12 June 2019 · 5:45 p.m.
135 views
Why you need to be reviewing open source code
Gris Cuevas Zambrano & Holden Karau, Google Cloud;
12 June 2019 · 5:46 p.m.
Develop seamless web services with Mu
Oli Makhasoeva, 47 Degrees
12 June 2019 · 5:47 p.m.
Implementing the Scala 2.13 collections
Stefan Zeiger, Lightbend
12 June 2019 · 5:48 p.m.
Introduction to day 2
13 June 2019 · 9:10 a.m.
Sustaining open source digital infrastructure
Bogdan Vasilescu, Assistant Professor at Carnegie Mellon University's School of Computer Science, USA
13 June 2019 · 9:16 a.m.
Building a Better Scala Community
Kelley Robinson, Developer Evangelist at Twilio
13 June 2019 · 10:15 a.m.
Run Scala Faster with GraalVM on any Platform
Vojin Jovanovic, Oracle
13 June 2019 · 10:16 a.m.
ScalaClean - full program static analysis at scale
Rory Graves
13 June 2019 · 10:17 a.m.
Flare & Lantern: Accelerators for Spark and Deep Learning
Tiark Rompf, Assistant Professor at Purdue University
13 June 2019 · 10:18 a.m.
Metaprogramming in Dotty
Nicolas Stucki, Ph.D. student at LAMP
13 June 2019 · 11:15 a.m.
Fast, Simple Concurrency with Scala Native
Richard Whaling, data engineer based in Chicago
13 June 2019 · 11:16 a.m.
Pick your number type with Spire
Denis Rosset, postdoctoral researcher at Perimeter Institute
13 June 2019 · 11:17 a.m.
Scala.js and WebAssembly, a tale of the dangers of the sea
Sébastien Doeraene, Executive director of the Scala Center
13 June 2019 · 11:18 a.m.
Performance tuning Twitter services with Graal and ML
Chris Thalinger, Twitter
13 June 2019 · 12:15 p.m.
Supporting the Scala Ecosystem: Stories from the Line
Justin Pihony, Lightbend
13 June 2019 · 12:16 p.m.
Compiling to preserve our privacy
Manohar Jonnalagedda and Jakob Odersky, Inpher
13 June 2019 · 12:17 p.m.
Building Scala with Bazel
Natan Silnitsky, wix.com
13 June 2019 · 12:18 p.m.
Asynchronous streams in direct style with and without macros
Philipp Haller, KTH Royal Institute of Technology in Stockholm
13 June 2019 · 3:45 p.m.
Interactive Computing with Jupyter and Almond
Sören Brunk, USU Software AG
13 June 2019 · 3:46 p.m.
Scala best practices I wish someone'd told me about
Nicolas Rinaudo, CTO of Besedo
13 June 2019 · 3:47 p.m.
183 views
High performance Privacy By Design using Matryoshka & Spark
Wiem Zine El Abidine and Olivier Girardot, Scala Backend Developer at MOIA / co-founder of Lateral Thoughts
13 June 2019 · 3:48 p.m.
All the fancy things flexible dependency management can do
Alexandre Archambault, engineer at the Scala Center
13 June 2019 · 4:46 p.m.
ScalaWebTest - integration testing made easy
Dani Rey, Unic AG
13 June 2019 · 4:47 p.m.
Mellite: An Integrated Development Environment for Sound
Hanns Holger Rutz, Institute of Electronic Music and Acoustics (IEM), Graz
13 June 2019 · 4:48 p.m.
Closing panel
Panel
13 June 2019 · 5:54 p.m.