Embed code
Note: this content has been automatically generated.
um hoops before i start i uh would like to say that the
later or the end of the talk i will uh right
sure do some work that was done jointly with um a p. h. d. students essays are strong you can select the
idea a post doc the researcher trees but those uh and professor george kind they're all from e. p. f.
so this is a um traditional view i'm gonna show you of the network
um as we most of us learned a about it at school
so there is a set of and hose at the edge and then there is the network in the middle
and only interesting processing happens at the end of course
not at the network of course there are
um network devices right there switches and routers inside the network
uh doing some processing but the processing their dwayne is mostly
standardised and well understood so each network device would have eight data play
that the um whose role is to receive the packets uh look at their ethernet or i. p.
headers to decide where to send the packet next and then there would be a control plane
'cause role would be to uh run routing protocols like b. g. p. and always the f.
and populate the all the data structures the forwarding people's views by the data point
but the point is that there is this very very clear separation
between the and host at the edge and the network
uh and all the interesting processing again happens at the end holes and the network does nothing more than forwarding
in routing now the problem with these uh picture is that eight turned out not to be enough
so it turned out that a network has to do much more than forwarding in routing
um for instance it has to implement security functions
like fire walls the intrusion detection systems
uh traffic scrubbers it has to implement um performance optimisation functions like transparent caches
um load balancer is web accelerators it has to
implement a translation functions like network address
translation um or chance coders from various uh between value scheme manager video formats
um and also a lot of monitoring functions like for accounting or compliance monitoring
so tool uh satisfy all these needs a back in
the nineties the the research the networking research community
came up with a very beautiful vision of an active network so in that vision
of the world consists of inter connected we've network so we don't have
a head versus network and the idea is that these active networking owns can be
programmed to do not only forwarding and routing but anything we want to
and in fact they can execute call that is carried inside packets
so the idea was that a and and host would
start some computation story partial results inside the packet
send the packet out in the network where any network device could pick
it up and start executing you know complete the computation and soul
so this way we could program not only individual and host to complete individual tasks
but we could program the entire network as a whole to complete the task
so that was a very beautiful vision um
but it was controversial so the the research community was very very excited about it
but the network practitioners thought that it was scary and they thought that it provided way
more flexibility and programmability than what was really necessary so networks didn't really happen
um instead we got something completely different we got middle boxes
so little boxes are a little bit like active network nodes in that they are
sophisticated network devices located in the middle of the network that to processing um
but unlike um active networking owns they're not fully programmable so a um
traditional middle box these eight closed appliance that implements fixed functionality and
is located at the fix network point so if i
network operator wants to deploy new functionality or above a new
network location they need to deploy a new middle box
now the problem with little boxes is that they are m. s. so first of all there are tons of them
so a recent study show that about a third or more of network devices to date our mailboxes surprise me
um and it's they are really a pain to manage because of their
lack of programmability um so let me illustrate with an example
a very serious uh security fred a four networks today is the now of service
so in in our service at dark and a darker sense um large volume of unwanted
traffic and flights the network and disrupts the connectivity between the legitimate and host
so the way a network providers deal we've um canal service uh
attacks today is the use scrubbing little boxes so basic rubber
takes as input to the the um a flawed traffic any process it and
it separates the good packets from the backpack it's that's what it that's
now and network today typically it's offers many small denial
of service attacks even on a daily basis
and um let's say a massive denial of service attack every
few years or so depending on the kind of network
now the massive attack maybe rare but when it does happen of course it
has a significant cost not only because it takes time to deal with
but because it impacts the reputation of the network provider that's offers of everybody learns that network such and
such once was down for so many also for so many days and that can be very bad
so the first problem that network operators face is that they um that the the
nature of the of the denial of service traffic changes all the time
so they need to keep buying and learning how to use and testing and deploying new little boxes inside their networks
the other problem is that um well you don't know what kind of attack provision for
should you buy a big scrapping middle box to provision for the a rare
massive attack of multiple but you get bits per second that you may receive or
provision for you know the smaller the attacks a few megabits per second
and even when you make you to make that decision um it is not
easy to decide how to spend your security budget so should you
for instance by lots of smaller scrubbers and position one at each entrance into
your network in order to block the uh traffic as early as possible
or should you spend all your budget by a bigger
a scrubber place it somewhere central inside your network
these latter option is of course more flexible but at
the same time eight creates problems because it allows
the flight traffic the attack traffic to enter the network right he has to go to be
redirected to the central scrubber and then back to its
original destinations so this may introduce congestion into
the network and it may add latency to what the the users of the network experience
no latency is you know one of the key words of the they
kate everybody talks about latency for good or bad reasons um so
by the way this is not just a technical problem is very bad p. r. for network provider
so how to deal with all these shortcomings of middle boxes that have to do with their lack of programmability
a new vision for networks these emerging these days network function
virtually station or an f. b. so here the
idea is that instead of of switches and routers and
all different kinds of middle boxes inside the network
we have simply programmable network platforms sort of the network
operator on each of these platforms can drop
different network functions depending on what is necessary at that point for the network
for example if the network is under denial of service attack
uh the operator can deploy describing network function exactly at the
point where the attack traffic is entering the network
now if the attack changes so the attack traffic moves they start entering at another point
then very easily the operator can also move describing network function okay that's the idea
so this is what and if the net or function virtual decisions about um so in a way
um we're trying not to redirect traffic as we traditionally do traditionally
would we want to process certain kind of traffic in
a certain way we try to we directed to make it go to middle box where it can be processed
instead with benefit we're moving at the network functionality because we have all these network functions that are
floating around so we moved them to where the traffic that we need to treat he's
and it's called and if he virtually station sort of the net or functions are virtual
in the sense that they each of them is not tied to particular device begin float around the network
now many of you are thinking well but i was told that the new vision for networks is as the enter
softer define networking not interface so how this is the end relate to the story i am uh tell you
so i said earlier that in the traditional network the network devices or switches and
routers and they have the data plane which forwards packets and the control plane
which runs routing protocols in our place the data structures used by the data point
so that's a traditional network in the new kind of network that i'm talking about
we don't have all these things we have these programmable network platforms so the data
played of course runs whatever network function that we have dropped into it
but what about the control plane what is the control plane do this is what is the and tries to pass or
so one possible answer provided maybe as the envision is that
the control planes will move away from the network devices and
it will all be moved into this logically centralise controller
that would make the decisions for the entire network it will monitor the
state of all the the network links it will decide how routing
will happen throughout the network it will deploy virtual network functions as
needed inside the network it will configure the data structures everything
so what exactly how exactly the the this controller looks like it's
still up for debate by the research community and the practitioners
um but one way to think about it for those of you who
are into the cloud he's like a open stack neutron on steroids
so this is how the n. f. b. and as they envision come together
so and if the uh envisions programmable bigger planes were we can drop virtual
network functions and as the n. envisions a programmable logically centralise control plane
which among other things deplores network functions inside the network as needed
is this controversial less so than active networks work in fact
it is very much anticipated um by the practitioners
in fact the the researchers are still very excited about that or programmability and the practitioners still
find it scary but this time around the fee and they agree that it is necessary
so what is it that makes an s. v. a scary the
same thing that made connected networks carry two decades ago
it enables us to the the continues dating of network
functionality and continues updates necessary calm we've box
so imagine a network operator uh she has her network she has
dropped you know network functions into her programmable network platform
you know she drops a new network function bought this one has
about which means that if it receives um a specially crafted
back at a it crashes or you can sort flights the network
or he does other bad things that disrupt network connectivity
now crashing or hanging i mean we may be used lead as computer users right we're used
to our programs a crashing hanging and network operator though is a very different story
network operators or a notoriously conservative and for very good reasons and
network but can disrupt the operation of the network in effect
older users and that can be millions of users at the same time right which is a catastrophe for network operators
so they try to avoid this option is as much as possible um thing called like streets like they
provision backup network links they have hot standby routers
and switches the inside each router they have
hot standby supervisor engines the useful solvable line cards
they um most importantly evade very very rarely change the
functionality of the network they only do it when
they absolutely really really have to um and again as i said that's for very good reason
a few years the ago uh i i was giving a talk about better programmability um
to an audience of a router engineers and um none of them had any
objection to the technology was describing but at some point one of them
raise their hand and said well if this all sounds good but
if you open up the network like that and you make it programmable there
would be all these buttons and who's gonna deal with customer support
so the word of the the router engineers were really afraid that if they try to sell you know
programmable routers and programmable network devices to network operators those
would be very unhappy because who deal with
a customer support both at the network level and from the point of view of the rubber manufacturer
so how do we go from basic justifiably conservative culture of network operators
well world were virtual network functions are just floating around the network
what has changed since the time of active networks that makes such a move possible
so what has changed is that now we can call roost and
so there has been a lot of good progress uh
within the last a decade with a program analysis tools and
after all and network function is just a specialised program
so what we would like to have is a program analysis to
um that takes as input the code of a network function and it property that we would like to prove
for our network function and eats proves that these network
function satisfies or does not satisfy this product
i want all this problem arises to look like exactly depends on what our
network function looks like um and there are two possibilities to the
it could be that the network functions running on a specialist network processor in which case
of course it is written in that domain specific language that that process or understands
or it is the case that our network function rounds on in general propose the
c. p. u. like intel and then our network function as we can in
a general purpose language like c. or c. plus plus and it's typically using
a fast i all library like the p. d. k. or that yeah
so both of these options are interesting enter valley that are happening today um
building a a domain specific language is an art any sin double research core goal
but also i'm learning a studying how to write and how to underlies network functions that are returning to
treat complete language that people are using for all sorts of other things other than that or functions
is also a noble research goal and one that i personally i'm more interested in so this is what i'm i'm working on
network functions are a little bit special in the sense that they're always
read and then supper optimised for high performance hack unpredictable performance
you don't want one packet to take a ten times more than
another packet to be processed because that leads the network problems
so as a result of these optimisation for predictability in performance they have certain characteristics
um first of all relatively conceptually simple processing what does a
network function do well it takes as input a packet
um it read a couple of values from its headers and it may it would typically
look up these values in the data structure like a hash table or hash map
if anything they update some header values it may update a little bit of local state and send the packet on its way
so there are no or for instance no loops of undetermined duration
if there is any looping it is typically over packet uh headers in the worst case
over packet contents before doing something like encryption or uh taking a a texan
there is no dynamic memory allocation you know properly with the
network function um we typically reallocate all the memory
all the packet buffers that we need again to avoid
be unpredictable performance associated with dynamic memory management
and of course there's no recursion so all these characteristic uh
make it conceptually simpler to reason about the the
behaviour of the network function soul in principle network functions
should be good application domain for program nice it's
now what we write a program analysis to would develop
a program analysis tool there are three key aspects
one is the reader of the provided analysis um
can i use this tool to simply test my program
my network function with many different into packets
um or can i use the tool to prove that my network function will never
ever crash or and or an infinite loop no matter what input packet receipts
the other uh aspect is the nature of the properties that i'm
trying to prove um and my interested in low level
properties like crashed freedom or memory safety which are general and
apply to any network function no matter what it does
or i might also interested in higher level semantic a behavioural properties
that are very specific to the particular network function for example if my network function is
a firewall does it drop all the bad packet and does it keep overboard packets
and the last uh aspect is the level of human effort as rules that was saying i might pressing a
button and then wait for the analysis to complete or do i need to interact with the two
now i fully agree that interacting with the two can be you know a great experience and teaches you about your
program but at the same time there are scenarios as i will argue reducing this effort it does make sense
the only their trade offs between these three aspects for example the more readers the analysis we want and the
higher level the properties who want to prove the more human effort is required in order to do it
i'm interested in proofs nodding tests and both for a low level and
semantic properties and the question i'm trying to answer is um
what amount of human effort does it take to what extent can we would use the human effort that is necessary for these tests
so i will make a parenthesis here there is a lot of interesting work going on today that
people call network verification and i would like to relate that to the story and telling
and that would be very fire takes as input a a network topology
and configuration and a set of models for the network functions the
network devices so a model says how is sweet how router how
every single middle box that's in the network should be operating
and also i desired property and then it proves that
these network topology configuration satisfies or not this property
bought a network they fire relies on models of network
functions of network devices for its books so any
proof it produces easing complete unless we also prove that
the only involve network functions behave as intended
so this is one reason why i mean just improves and not tests of the behaviour
of network functions because it is a key piece missing from completing network verification
alright so these days when a non expert a program analysis try
their hand uh at a nice is the first call they
try the first thing they try is symbolic execution um which is in a way the brute force of program analysis
so a symbolic execution engine takes as input code
program code in our case the court of a network function and it has the
possibility that every single branching point to explore all possible outcomes so in principle
and symbolic execution engine can explore and get it can't analyse all
the possible instruction sequences that the network function may execute
does this doesn't require a lot of effort to choose to use a a such a simple integration angie
no not really you can actually press a button and wait for the analysis to complete
what kind of properties can we check definitely low level properties
like rice freedom uh absence of infinite loops but also
high level properties anything we can um anything we can uh
specify as a set of assertions on program state
what about a bigger so can we use symbolic execution only to test or also to prove properties
well i in principle we can prove with symbolic execution
so if i do it an exhaustive symbolic execution of my network function so
i explore all the possible instruction sequences and there's no infinite loop
well i have argued be proved that my network function ease a free of loops
however in product this um there is a very well known problem which is called f. explosion
so real problems and real network functions typically have
such a large number of possible uh uh instruction
sequences that maybe a executed that one cannot
explore all of them and reason about all of them in useful time so what
um people usually do to bypass the problem of symbolic execution is modelling
so when are symbolically executing a program or a network function
instead of executing the implementation of a certain function
one can replace that with a model unconnected a
simplified model of eight function and uh
this way i mean because this functions of the these these models are chosen to be very simple the entire process can
can finish no this is very helpful when using symbolic execution
especially with programs that maintains sophisticated state and network functions
typically do that for instance the meeting flow tables and so modelling is very useful um you also helps a lot by the way within far
right if you have an operating system libraries drivers uh that are your program is
making use of a you have to use models in or usable execution
um of course vase simplification comes at the cost of regard as you may be guessing so when
we are we placing an actual implementation of a function with a model of course where assuming
that the model captures all the interesting properties of the implementation that are relevant
to what we're trying to prove and this may not be the case
so to recap symbolic execution is a handy to each requires little human effort bought
that cam comes to get the cost of finger so using symbolic execution along
can not typically help to prove prove useful properties of a state full network functions
but of course i mean roost and spend all this time talking to us about interesting uh tools that
we can use for problem and i says so they're way more powerful tools out there uh
proof assistance that can help with anything that a human can prove about
a program i'm in principle and they do automatic groove checking
but of course here the cost is human effort like no matter how um
well designed the art hubble they are big do require a nontrivial amount of effort and expertise in order to use
so the question is of course can we have the best of both worlds can we somehow have their readers analyses
offered by the most powerful proof assistance combined with the little human effort uh an
expertise in program analysis required by something as brute force a symbolic execution
okay so now we'll talk a little bit about our uh approach so
a colleague of mine are said uh once that the only a data structure that networking
people need is a hash table and he's mostly right so uh if we
look at the network functions that we use today they all tend to uh be
who's a very few common data structures hash tables hash marks and sarah
i mean by offers a body that this if that is true then why not create a library
with all these common data structures and let's ask program a nice is experts to finalise them
using any tool they they want i if this is gonna take time of course an expertise but if we can
get all the or many network function developers to use this library then this cost will be calmer christ
and then by the network function developer can you use this library
and if i make sure that all the state that might network function maintains it is kept it is down
through this special verified library okay then um then i
can reason about my network function using symbolic execution
symbolic execution as we said does not deal well with state
but my network function does not handle steak directly
it has delegated this task to be special library that has already been finalised with more sophisticated needs
so the idea here is we take the network function and we a separate logically the
called into state focal handled by the library and state was cold so um
we use different techniques to uh underlies the different kinds of course all
state for it takes more time but that is our ties
the state was called it can be done more quickly and it can be done by the developer of the network function themselves
if we manage to pull off this combination then yes we will
have the best of both worlds so how can we do
in the first that um we are create our library of of data uh
structures and we're allies in particular for each library function alright formal contract
i'm showing an example here but the details don't matter what matters is that a formal contract
has preconditions impose conditions um like you being a listening to for the past hour ants
eat for my specifies what base library function should do how to behave um
the second in the second step we write the uh the network function and then
we we make sure to use the library to store all the state
uh maintain but is network function and then we underlies it in particular
we use uh first we replace all calls
to library functions with simplified models
and then we'd let's say an exhaustive symbolic execution of the entire network function
right so i'm showing here obviously a simplified example where we have replaced uh calls
to read and write functions these are library to read and write i'm
reading right uh functions to access data stored in the library data structures and
with we replace them with these models now the outcome of this that
he's a set of call traces they are all the possible um course sequences
of calls to library functions that this network function might execute so
in this particular example i'm showing their two possible a sequence uh of
calls or right to some data structure and read plus right
alright
a the last and uh the third and last that we finally prove
that the improve the the the desired property of our network function so we
take first of all we take every single a call trace every single call sequence
and then we check whether our desired property holes at the
end of the school sequence and if it does
then we go back and check whether the outcome of the model
the simplified model that we used for every single library function whether that
is consistent with what the corresponding formal contract for that function specified
i forgot to tell you that we uh in the first that we
prove that each of function implementation actually satisfies the
formal contract that we've written for it
alright so let me show you through a very simple example so let's say we have a network function that came
on other things eight uh it is supposed to drop
any packet receives that has destination port number nine
so the model we're using for the right function here um assumes
that indeed when the input the packet that alright this
input or network function reaches the end of the score sequence the the board can only nine this is the model
now the the contract uh that i'm showing next to to the model
does not say anything about board number nine of course what
it does guarantees that these particular function is not going to modify the back is not gonna do anything to change it
so i'll if i the the developer of the network function if
by this point i have done nothing to ensure that
packets with destination port night are dropped that might prove full
fail because our proof checker is going to say well
um if i look at what the contract says it cannot all for what the model
claims which is that the board will always be different on the destination point but
if i have done the right thing i the developer that is then the provable succeed because again what the
a model claims is supported by the formal contract so this is the the idea
so it was a beautiful idea that a us any harm and uh
one way to describe it is that we are not trying to
come up with the perfect model for every function a priori
because it's a very difficult tasks like my i know in advance which are all the features of a function that would be relevant
for particular proof and make sure that you capture them in the model so instead of trying to do that um we uh
we we write very simple models we write them carelessly if you will
but that's okay because after we use them before proves axes we
come back and we check was this model that we used
alright was it correct for the particular network function and the particular property that we were trying
to prove and that is much easier so this is what we call them lazy groups
so we use this approach um and we developed the a very fight
and network address translation translator that we call a big that
and to the best of our knowledge it's the first i'm not we can see that was formerly very fine
we proved using uh the technique i write outlined that it conforms to r. f. c.
a three zero twenty two which is the r. c. that specifies correct not behaviour
and very importantly we experimented with it and we found that it's performance was on par
so it was not significantly below the performance of a traditional and very fight to compute um
the good news is that it is possible to rigorously reason about
state for network functions with relatively little human effort if you
are a network function developer and you're willing to use a library
of data structures that has already been finalised by next
most importantly these does not have to come at the cost
of performance so when systems people hear about writing cold
in a way that is friendly politeness is there always scared that there will be a a performance cost
in other cases may be the case but with with network functions we have not found that to be the case and that's good news
of course there are challenges and open questions um
the first one is about the universality of data structures used by network functions so
the premise of this work is that we have many many network functions written
by many different developers but if it will all be using a relatively
small set of common data structures and we can put all these in the library right then and allies in our ties the cost um
will that be the case or if this vision takes off and
people develop even more more diverse network functions well when
you start optimising for performance you want to use a slightly different version of that hash map or hash table
and you change a bit interface you change it implementation and now the
very the the analysis effort needs to be done from from scratch
um so will this be the case or will it be the case that
will be able to incrementally reason about slightly different um uh data structures
so that's one one open question and another one is of course going
with further reduce the human effort required to reason about network functions
with lazy proves we certainly would used it a lot relative to uh the existing alternatives but um
very still human effort required in stitching together the results of the various analyses
that we do it so how much more can be reduced that
so if we work on these open questions and we address these open questions
that we are headed we were making progress toward having actually flexible network
now you may question whether that's necessary you may say well he's actually
flexible and programmable network a good idea do we want it um
i think so and we can debate on what particular functionality i or you would like the the the network
to uh to support but i don't think that's the main reason why we should want network flexibility programmability
so when one has these properties um that changes the way they do things and that brings about
a great unexpected things for instance um providers that all for all for software services to date
they're not conservative right they do not whenever they want to what i'm proposing your application or change uh on
or add features to their applications it's not like they do all these you know complicated studies and the
wait for years and they ask everybody do you want this new feature now they tried out the put
it out there like if people pick it up then that's good and everybody works and improve it
and that's great at least a very interesting and dynamic software world um
now imagine if we could have such a world um if we could
have such an open and dynamic culture but in the networking thank
questions about this great presentation uh for for some questions
oh yes
uh_huh yes yes a button which affirmative duty of the remote experience some
as gentle as you can imagine like to challenge a couple of
years some sh sh oh one that's used to it's just a
little bit yeah that's all that was just a recursive functions
well just give one example of ritual yeah that's true ritual as clients
which you must for itself is recursive protocol itself which use the
routing loop uh_huh so how to punish people for us
when you have rituals solutions but yes so thank you that's a great question so
when i i usually tend to separate you know data like function in
controlling functions and i know that uh we do they tend to
use the term via net for both of them but when i at least think about a. d. n. s. server or client
i don't think of that as a data plane network function so
that is not the kind of function where you know packet comes in you could do something to to send it out
i consider that a more sophisticated functions and that's not something i can reason about with the model i just described
so this is something for you know monitoring for accounting for weeks
cropping for fireballs format for transporters for these types of services
um because they have those very specific characteristics that i talked about like recursion now
that doesn't mean that's you know we shouldn't be working on you know a
verification environment for the kinds of things you're talking about but there
i just see a little bit less opportunity for the automation but i'm talking about
so i remember so this child or a between the human effort than
the level of automation and the the level of the properties
so i think that when it comes to this kind of services you're talking about it we
we we will have to strike a balance which further away from automation and more into interactive environments
like that was that was that was talking about you know like reasoning about impart protocol
what would your dream vision of individual network cable civility and such
rachel just ritual clinton's distributions rituals lips reasons one apostle vision loss to build you a
it helps you to to verify tools functions is is the majority
would freeze approach yet just matter is dictated we'll just yet
we used to have little pages will drop to voice your g. e.
you don't you don't you skills or when it's software engineers
who calls it already did the consistency should justin controller
well so i fully agree with you but i would like to separate the kind of vision i was talking
about where you can change you can drop network functions into the data plane from the one you're talking
about what we have you know as the n. galore out in its full version everywhere i'm i'm not
saying that that vision won't happen but i do agree with you that there are challenges and um
i think we should be working on it i don't quite see exactly the solution
yet so that's why i'm not going there but i'm saying something different um
you said that what you describe are the building blocks for making this vision come true
i don't think that's necessary so one can have a a lot more control
control environment so not the full fledged as the in control of the where
the research communities envisioning it but still have the ability to modify
the network functionality so the kind of building block some talking about our
for instance well my dream application is about checking forces the neutrality
are all the network i i believe very firmly that's you know the way we use
networks dates very importantly sure that people have equal access and so long right
so i'm having a transparent network that we can very quickly prove that is being
neutral it's behaving correctly to what everyone for me it's a big deal
these we can do if we have very fight network functions that we can drop at
the boundaries of network domains we do not need a full fledged as the end
controller that you know that's fancy things with the entire network in order to do that
not that we shouldn't be working on it but it's a slightly different thing
it's a little bit blinding yeah okay uh
so you're offered a question that we will be resuming the presentations it

Share this talk: 


Conference program

Welcome address
Andreas Mortensen, Vice President for Research, EPFL
7 June 2018 · 9:49 a.m.
Introduction
Jim Larus, Dean of IC School, EPFL
7 June 2018 · 10 a.m.
The Young Software Engineer’s Guide to Using Formal Methods
K. Rustan M. Leino, Amazon
7 June 2018 · 10:16 a.m.
Safely Disrupting Computer Networks with Software
Katerina Argyraki, EPFL
7 June 2018 · 11:25 a.m.
Short IC Research Presentation 3: kickoff.ai
Lucas Maystre, Victor Kristof, EPFL (LCA)
7 June 2018 · 12:19 p.m.
Short IC Research Presentation 5: CleanM
Stella Giannakopoulo, EPFL (DIAS)
7 June 2018 · 12:25 p.m.
Short IC Research Presentation 7: Datagrowth and application trends
Matthias Olma, EPFL (DIAS)
7 June 2018 · 12:31 p.m.
Short IC Research Presentation 8: Point Cloud, a new source of knowledge
Mirjana Pavlovic, EPFL (DIAS)
7 June 2018 · 12:34 p.m.
Short IC Research Presentation 9: To Click or not to Click?
Mahsa Taziki, EPFL (LPD)
7 June 2018 · 12:37 p.m.
Short IC Research Presentation 10: RaaSS Reliability as a Software Service
Maaz Mohiuddlin, LCA2, IC-EPFL
7 June 2018 · 12:40 p.m.
20s pitch 2: Gamification of Rehabilitation
Arzu Guneysu Ozgur, EPFL (CHILI)
7 June 2018 · 2:21 p.m.
20s pitch 4: Neural Network Guided Expression Transformation
Romain Edelmann, EPFL (LARA)
7 June 2018 · 2:21 p.m.
20s pitch 5: Unified, High Performance Data Cleaning
Stella Giannakopoulo, EPFL (DIAS)
7 June 2018 · 2:21 p.m.
20s pitch 6: Interactive Exploration of Urban Data with GPUs
Eleni Tzirita Zacharatou, EPFL (DIAS)
7 June 2018 · 2:22 p.m.
20s pitch 7: Interactive Data Exploration
Matthias Olma, EPFL (DIAS)
7 June 2018 · 2:22 p.m.
20s pitch 8: Efficient Point Cloud Processing
Mirjana Pavlovic, EPFL (DIAS)
7 June 2018 · 2:23 p.m.
20s pitch 9: To Click or not to Click?
Mahsa Taziki, EPFL (LPD)
7 June 2018 · 2:24 p.m.
20s pitch 10: RaaSS Reliability as a Software Service
Maaz Mohiuddlin, LCA2, IC-EPFL
7 June 2018 · 2:24 p.m.
20s pitch 11: Adversarial Machine Learning in Byzantium
El Mahdi El Mhamdi, EPFL (LPD)
7 June 2018 · 2:24 p.m.

Recommended talks

The Lognormality Principle
Réjean Plamondon, Département de Génie Électrique École Polytechnique de Montréal
21 March 2016 · 2:05 p.m.
Keynote 2: The story of Pix4D
Christoph Strecha, Founder & CEO of Pix4D
6 Nov. 2014 · 1:01 p.m.