[Music]
[Laughter]
[Music]
so this talk is about the um the IDE the
integrated development environment or
the tool that you use to develop things
um with the ethereum uh framework I'm
going I say things what I actually mean
is deps
um the talk has been given a name by uh
sorry not the talk the IDE has been
given a name by Yan who is uh he started
development on it uh not long ago and uh
I got it right yeah
mix um that's the uh name for the uh or
the code name for the
project okay
so like all uh like all things it is a
um an attempt to solve a problem or at
least provide some degree of a solution
so the problem in this case is that
writing software is hard um we we have
ways of making it easier um Sven uh
mentioned some of those ways in his talk
as did Kristoff and we have we have
services that help us as well and we
also have uh various bits of Technology
um there are some examples but these
things are often uh quite kind of
disperate um for instance when I'm in my
editor um and I'm working on a feature
uh that does not directly integrate with
my feature manager which is uh at least
for me uh GitHub and specifically the
GitHub issue
system so the I of ID stands for
integrated and the idea of integrated of
course to bring all these things into
one
place now in addition to to just general
software development it turns out that
actually writing decentralized apps is
even harder so firstly it's harder
conceptually
because decentralized applications are
just not things that we're used to
developing right then there it takes
even a a seasoned programmer um a long
time to really understand how Bitcoin
works why it works um often uh you find
people asking uh when you talk about
Bitcoin blockchain technology in general
well hold on what about the security
what firewalls do you need to have in
place for Bitcoin to work it's like well
this isn't the right question you're in
the wrong Paradigm you got to you got to
shift your paradig and it's the same
with decentralized applications um and
for that I think I mentioned some of
stuff in in solidity and there's
actually another talk I did which I'll
probably give a again at some point
about uh uh having um different amounts
of information available to different
people and different uh different
decentralized applications and how they
all collaborate but any anyway it is a
different Paradigm so we have um a
diverse debugging environment we're not
dealing with a single language or a
single machine or a single set of State
um we have all of this stuff going on
it's very hard to collect it all
together as anyone who has used uh LF
zero to develop uh DS will will know and
and
hate
um yes the last point is uh is like the
what's what's happening on the on the
system it's really easy to get the state
of a system when you've got just a a
traditional system a system where all
the state it's basically memory and hard
disk right and when you've um when you
have that you can use a debugger you can
ask the debugger hey what's the what's
the value of this variable well it's a
bit different when you when you're
dealing with decentralized applications
because it might not be around it's hard
to set things up
exactly so with with decentralized
applications at least the decentralized
applications that ethereum 1. not will
be you know thinking about and
supporting and this notion of of uh of
web 3 and the collection of these three
sort of um
Technologies so we have the uh the
ethereum blockchain so they need to
um um to to launch a transaction but
debug the transaction but do so with the
blockchain in a particular State it's no
good if the blockchain can be in any
state because that could easily affect
what your assertions are with the
debugging um
environment similarly with uh with the
two other protocols whisper and SW SW
it's important that you you don't just
launch or debug or test your your
decentralized application on on just any
old um uh instantiation of whisper or on
the the present sort of live net whisper
or even the test net whisper because
there may be messages there that you
don't expect and that alter your base
assertions and assumptions with the uh
with the debugging environment basically
as we move to the notion of unit tests
we need to isolate things and we need to
have harnesses for these things and a
very easy way of operating with
them same with
swamp so we try and we try and solve
this so here's a uh a basic look at what
the um what a
first a first uh attempt first effort at
the ID could could look like um you got
your code this might be a solidity
contract that's that's what it is here
and then you've got uh what it looks
like um ultimately so maybe you're
hosting some HTML file on your on your
machine and it's just browsing that file
and this maybe this file um uh in some
way operates with this but it's very
hard to really understand how this is
working it's uh it would you'd have to
do a lot of the the grunt work manually
you would have to make sure that this
points at wherever this goes into the
blockchain pain you would have to submit
that to the blockchain of course and the
debugging would happen entirely
separately now the as I go on and show
more and more of what we
plan this stuff isn't necessarily
ethereum 1 Point not it will take some
time to develop out um of course we'll
be doing it in Milestones there are some
features that are higher priority than
others um in the same way that solidity
all of solidity isn't isn't one point
not it's we're not going to manage it by
Mark um certainly the uh the invariance
the static checking is going to sort of
run into the 2.9 schedule but yeah it's
uh it's
planned so first thing to do is to say
right um adap is something that is not
just a contract it's a bunch of other
stuff it's the JavaScript the the front
end stuff the stuff that holds it
together uh holds the user experience
together it's a bunch of HTML bunch of
CSS ultimately of course maybe if we
move on to a qml uh optional optionally
qml front end then you can swap some of
this out for qml at the moment we're
just dealing with web Technologies and
that's mostly strategic
decision so we want some sort of project
management we want some way so some way
of sort of um holding together the
contracts for a particular decentralized
application and then the other sort of
more um more front end uh things so in
this it's a bit blurry can we can can we
alter the focus slightly might
maybe uh no yeah that's not like it so
uh in this case we've got a couple of
contracts we've got a Javascript file
and then um and then we've got some
Styles and whatnot
notably the way that we want to take the
ID is to remove um the overburden of man
of file management so file management
was something that sort of invented in
the I don't know 60s or 70s I guess um
whereby we group lumps of data into
files and store them generally
hierarchically on a on a filing system
now that's fine when you need something
that's lowlevel but when we're dealing
with with you know highlevel Concepts
like projects and contracts we really
don't need to be falling back into
lowlevel Concepts like files and groups
of bites so um although it's very hard
to get around this for uh for the web
for the web technology stuff so it's
very hard to sort of reference something
like a apeg file without actually having
a file for the contract well we have a
name for a contract and so we can avoid
actually explicitly dealing with files
we can actually just just have contracts
by the name and if you rename your
contract then sort of hidden behind the
scenes maybe a file gets renamed
somewhere but you never need to
know so if we add a bit more a bit more
integration in you can see we've got
some a bit of extra stuff now we've got
this idea of Team Activity one of the
key things of uh of developing software
is is collaboration with other members
of a team that helps you develop
software um we have this notion of what
you're currently working on a developer
well maybe there's some awesome
Superstar developers that can de work on
two or three or four features literally
at the same time but in general we tend
to address one issue or one feature at
[Music]
once um so we have this idea of what
you're working on we also have things
like the documentation integrated um and
Contex sensitive if you notice we've
also gotten rid of the uh ah oh oh de
that's not good what happened
there uh we have this notion
of yes there we are um we have this
notion of what file we're at but we've
suddenly removed the Local Host stuff
because the ID is going to host the file
the project as a whole the DAP right and
we won't have to care about where where
it's hosting it because that's taken
care of by the ID kind of in the same
way that when you're in I don't know
Visual Studio whatever you hit F5 you
don't actually care about where in the
file system the executable happens to be
that's running the fact of the matter is
that it is running and that's all you
care about as a
developer add on a little more and we
can start to see things like the tests
that we have
now this all happens as you'll notice
there's no buttons right this all
happens and it's sensitive to as you
type so as you type as you update the
code as you add more tests as you remove
tests as you um as you change the uh the
code there um these update
automatically we have contact sensitive
information annotation actually built
into the textual representation of the
program in this case it's telling us
that uh the something wrong here that uh
number Founders is not a number it used
to be an
integer but it became not a number in
line nine so it's actually tracking the
state of variables as the debugging
happens so the idea is that as it's
debugging as you are not allowed to to
edit the thing the background turns
yellow and we we get context sensitive
information we get annotation directly
in the editor now we can do this um
basically because we have full compiler
integration one of the key points of the
solidity project was to separate the
compiler executable the thing that turns
some source code into some object code
and the um the as interface so the as
for those of you not compiler writers is
the abstract syntax tree and this is
basically a mid-level representation of
the actual program so we're used to
we're used to sort of we're used to
thinking of programs in terms of text so
if I ask an average brid developer hey
you know show me that show me the hello
program what they'll do is they'll write
out some text and they'll say there you
go
now that's kind of the program you might
argue it's a it's a projection or a
representation of the program but it's
not canonically the program one of the
reasons that you might use to argue this
point is that well I could alter this
program in numerous ways Whit space
removal for instance um yet it wouldn't
change what the program is it wouldn't
change if we're going to get technical
it wouldn't CH the as still all it still
gets passed and understood as the same
the same actual
program now there are group of um a
group of uh pieces of software that
actually deal withs and when you edit
the program you do literally edit the
program you don't edit the source code
so these are called structural editors
or language workbenches we're not going
to be doing a language workbench because
that's kind of outside the scope but
this may ultimately change into a
structural editor whereby suddenly we
won't have to worry about things like uh
White space or uh code formatting being
in the wrong way these things will
automatically get uh automatically get
rendered in the way that the user
actually wants to render them the
developer wants to render them and you
know it will default to some canonical
representation probably some some uh
basic representation that everyone
agrees on but ultimately it's something
that people can alter if you don't like
tabs if you like spaces then fine you
alter it and it it renders it as with
tabs and not spaces
if you prefer your parentheses to be on
the same line or on the next line you
can alter that as well the idea is this
is all transparent and the thing that
goes into GitHub is just the canonical
representation okay is
that not
working
no uh
ah okay right so that was that seemed to
be Google probably our iffy internet
connection okay so just to go over some
of these features in
turn document integration so as you have
I don't know cursor is over a
function or maybe as you're writing
you're calling into a function um you'll
get pop-up documentation now this is
this can be done by virtue of having a
contract sort of database decentralized
database for contracts that stores the
documentation so we heard some of the
ideas from Andreas a few days ago of how
this might be
implemented and the idea is that the ID
actually goes to this place it
understands through some sort of uh URI
system um and registration system what
the contract is um again in tandem um
this is this is achieved through using
the as um from the solidity library and
uh it's able to actually pull out the
documentation from that repository if
necessary it could go off on the
Internet or the decentralized network or
swarm or wherever and grab the
documentation the idea is of course that
it also is able to pull out the
documentation for the for the program
and tell you hey hold on you've only
documented three out of the four
functions or this invariant you just
added you didn't document it properly or
you know maybe you're missing a
parameter maybe there's a parameter for
the function and your documentation
actually doesn't utilize the value of
that parameter in documenting it to the
user and that's obviously a a grave
error because the user probably wants to
know it's probably quite
important test integration tests along
so so initially tests will be a very
important part of contract development
hopefully eventually we'll move over to
a more formal system but initially it's
going to be very important that the
developers of contracts write a lot of
tests and that these tests can be be
viewed and and checked by Auditors of
contracts to make tests ever more useful
for developers they should be as dynamic
as possible
so it's a bit of a pain to write tests
first because often what the interface
for a particular function or method or
contract is differs um after you
finished the contract from when you
started the contract because you simply
don't have full knowledge until you've
written most of it so although uh
testing after writing the tests after
development is perhaps um there are
Arguments for writing it um before you
finish the full uh contract but there
are also very good Arguments for not
writing them before you've started the
contract so uh writing tests as you
develop the contract is probably going
to be a a sensible Way Forward and the
way to encourage developers to do that I
assert is to uh make the tests as
dynamic as possible so sometimes I'll be
coding a feature I'll want to debug that
feature to get a bit of a better idea
and test certain insertions that I'm
making well this should be a very
Dynamic a very quick way of adding extra
tests as you develop to make sure that
the assertions that you're you're making
as you develop are indeed
true as you type as you alter the
contract rather than just testing you
know maybe when you compile or when you
commit or when you push it tests
everything as you type if you make a if
you type a bunch of stuff you add a new
function then before you've even
compiled anything you're told hey hold
on this breaks that earlier test you get
a little
warning compiler integration is going to
be very important again as I said before
solidity was always devised to be a
library and not simply a
compiler and because it's a library
we're able to get structured information
from it from the solidity passer and the
solidity pass tree
analyzer so you can get this as and you
can have all of the references you need
which is to say you can you can say that
this um identifier here that corresponds
to this bite position going to this bite
position on line 24 is actually a
variable that is referenced uh
referencing the um the parameter uh of
name campaign ID to this function you
can get that information and when you
can get that information you can do all
sorts of uh cool things that are only
kind of possible in very certain
situations with existing Technologies um
such as uh refactor various types of
refactoring variable renaming and
generally altering the abstract syntax
tree altering the program in logical
well- defined ways that are uh
effectively guaranteed to be neutral
Transformations
um so uh because we we're integrating
with a compiler we can also as you type
check for things like code health so the
warnings that it generates maybe even
compile errors we can take as you type
that in variance so these are sort of
static assertions or um assertions made
over the entire lifetime or State uh or
all possible states of the contract are
true and we can have um within the code
itself a sort of I don't know massive
red box or a massive cross when uh an
alteration you make actually fails an
invariant we can derive code structure
and render it in a way that the user is
going to find useful perhaps as a um I
don't know if many of you use editors
that have a a sort of zoomed out view of
the program code or syntax highlighted
you're familiar with that so the idea is
well that that's that's okay that's kind
of good it sort of gives you a a nice
visual representation of the total
amount of
code but what we can also do is we can
add to that we can take the abstract
syntax tree what we can do is is render
a uh non-textual representation a sort
of diagrammatic representation or a
structural representation and place that
at the side and that's going to be a bit
more information
dense um and finally as I mentioned
earlier we can do things like canonical
code formatting which is sort of a a
halfway step to actual structural
editing and canonical code formatting
what I mean by that is basically when
you make an alteration to the code um it
automatically reformats the code in the
way that is actually canonical so you
don't have any of these problems with
style a you coding that's coding
standards as as the C++ developers know
I'm kind of tough on these and uh this
effectively uh removes that as as a
contention um now I don't know if any of
you uh it probably shows my age a little
uh are familiar with the Amos
programming environment there an early
um uh something early on the Amiga you
can make your computer games it's kind
of a form of basic um that actually
already had this so this this stuff that
I'm I'm mentioning is is very little of
it is uh at all um sort of new or
anything and that was in the what mid
'90s early '90s late ' 80s uh you know
and you type a line of code you press
enter and it would just format the code
canonically it's like yeah it's really
sensible why do we why do we go back to
the 70s all too often um Okay so we've
also got like things like debugger
integration because we know the abstract
syntax tree because we know all of this
stuff we have absolutely full knowledge
of what's going on in the code we can do
all sorts of cool stuff like as you
debug annotation for things like State
what what value are these variables
right now well we can actually show that
so there could be for inance you hold
down control shift and suddenly the code
expands into uh equals 5 for instead of
uwing Campa ID it becomes uwing campaign
equals 5 maybe the equals 5 is in
italics and some uh variable with font
so that we know it's not actually
literally equals 5 in the code but you
can start to imagine that we can
actually annotate this code with
upto-date contact sensitive information
directly from the debugger that is just
kind of if not if not impossible very
difficult to do with existing tools
um assertion truth again is similar
something similar to the invariant we
can actually put crosses where
assertions fail and this could be
integrated into the test environment in
order that when you're when you're
running tests you get an immediate
immediate visualization of where the
test is going
wrong you can go into State integration
transaction integration the blockchain
um integration so this is where we you
know we are developing in this this kind
of new environment this environment
where there's a a lot of other stuff
going on so we need to integrate this
stuff into the into the development
environment and really sort of wrap all
around it so we've got full at your
fingertips um control as well as
obviously transparent handling of
various grunt tasks wherever
possible so we can um one of the most
important things is to be able to test
and debug with very particular um states
of the blockchain it's no good saying
well we'll just test with the the
current state of the main main net
that's that's crazy all sorts of things
might be going on that you just can't
predict um you may not even have an
internet connection but similarly
they're doing it with a test net is is
no good either for the same reasons um
so we want to be able to start um
debugging control in a very controlled
fashion we want to be able to pick out
which block that we want to debug on we
want to be able to specify hey maybe I
want to debug on a chain that's empty we
want to be able to specify what states
we want to be deogam maybe it's never
was a maybe it's not a not um maybe it
was never in existence and we just want
to sort of create this state this new
genesis state if you like and debug on
that same with the transaction
integration maybe we want the the the
the the transaction that we're actually
going to debug to follow several other
transactions first so we can make sure
that the block has say five transactions
first and then debug our transaction
just to set up the state into exactly
what we need exact with full control
over it
um and again blockchain and swarm
integration so that there's a onestep
deploy right deployment could very
easily be an absolute pain in the ass
and very error prone we need to uh
really get on top of that and have
basically just a button that's you hit
it it runs a deploy script that's easily
creatable
and what was I
um yes it's easily creatable and can do
whatever you need so um what it might do
for instance is uh we already have
something like this in the C++ codebase
for anyone who's familiar with the
standard Services the things like name
registration the config contract um the
coin The Exchange um that's actually all
just the Javascript file that I run
whenever there's a new chain created and
it it it deploys all this stuff well we
need a really easy way of creating this
um and running
it and of course selecting whether we
want to run it on the test net or the
main net
um very very important integration is
that with with uh uh with source code uh
Version Control tools these are these
are you know absolute life blood life
blood of programmers and have been for
some time now um yet integration in
editors is often pretty minimal yay I
can commit because I made a change I
mean this is really basic stuff all it's
doing is basically do it running a
command G commit we need something a bit
better we need something that follows
our workflow a bit better and encourages
us to to to Really commit or use these
tools um optimally so one thing Google
brought in a while ago with their their
Google Docs um infrastructure was the
idea of having a uh a permanent undo
stack or really tracking all of the
changes so what they've what they've
done is they've uh they've taken the
notion of control Z of and do and
they've bundled it with the notion of
Version Control so now when you when you
say right revision history it will give
you um an undo history SC scanning all
the way back to the very beginning of
the
document why don't we do that we've got
G it's pretty uh it's pretty efficient
certainly efficient enough for our
needs no reason just nobody's done it
yet um currently working on so with Git
with the commits with branches you tend
to say right there's an issue I create a
new Branch I I'm going to I'm going to I
don't know it's a feature or it's a bug
fix um you'll commit to that Branch a
few times and you'll generally merge
into the branch that you came from well
maybe this is the branch that you came
from this is the branch that your your
you know your your bug fix Branch maybe
it's connected to an
issue let's just build it into the
workflow let's automate this stuff as
much as possible and put the control put
the put what the programmer needs to do
focus focus on what they want to tell
not what they have to do yeah we don't
want the programmer to work around tools
we want tools to work around the
programmer similarly the contract
repository integration so uh hearkening
back to what Andreas was saying a few
days ago with the with the documentation
system this should this should just pull
that information in and we've got the
information to to collate with that so
let's just put the ends together connect
it all up and really give the developer
a um that information at their
fingertips
automatically GitHub is a great service
right for open source developers I mean
has anybody here not used GitHub that is
a developer
no um it's a great
service but it's it's disjoint I have to
go to the web browser and use GitHub and
then I go to my emac or or cute Creator
or whatever VI whatever it is and I I
use I I edit the code why can't I do
both at the same time GitHub is very
clearly a programmer tool editors a very
clear programmer
tools they're dealing with the same
stuff they should be
integrated team activity activity is is
largely development as I'm developing I
I want to know what other developers are
doing and whether it's going to affect
what it is that I'm doing it needs to be
integrated if I'm working on an issue
and somebody else is reporting hey this
issue this bug I've got some more
information I've been I've been you know
testing it I've got some more
information I don't want to have to sort
of I don't know finish half hour of work
go onto the web browser click on
something click on something else get
into the issue find that they've posted
oh well it was that no I want it right
there in front of
me so when we have
um when we have the when we have real
GitHub integration what we'll be able to
do is Click right project fork in our
editor in our development
environment at the end okay and when I
do that it will go to iub it will Fork
that it will put it under my my reposit
my accoun in GitHub it will create a new
repository it will open it all up and
I'll be good to
go should do the same for distribution
when I want to uh when I want to
distribute it's already on GitHub and I
should just be able to click a link give
it to someone else and they can Fork if
they want to issue
integration GitHub issues are great
right uh people already use issues for
slightly more than they were designed
with their of waffle waffle. the Canan
board thing that that utilizes issues as
Bas as it's underlying database
effectively
um why don't why don't IDs do the
same I mean all right you might argue
the skub integration you need the
Internet for yeah but most of the time
developers have the internet and when
they don't they can there should be an
offline option um so when we're doing
task feature and project management
let's use issues when we're doing
collaboration let's use this this system
it's already built for us API
there so that's some of the ideas that
we have that we want to put in action
over the coming 12 18 who those
months um any
questions so are you only going to be
able to work on the solidity code or are
you going to give some you know L
editing capabilities as well at present
it's going to be designed mostly for
solidity but there's no reason why
ultimately we can't add an abstraction
uh platform to allow it to be used for
other code as well um what I would like
to see is uh a multilanguage support So
specifically JavaScript as well because
JavaScript is going to be a very
important part of this and from
JavaScript you're going to want to call
into contract so you're going to want
some form of as analysis for JavaScript
so that you can do all of that cool
documentation stuff and you know
parameter um parameter upfront head up
documentation um so yeah ultimately I'd
like to add just mult language support
in
there a dependency on contracts that's
already deployed and it's not part of
your application particular case yeah
how you manage this um the uh if I go
back a
you so this would this would come for
under the contract repository
integration so the idea is that there's
a contract repository it doesn't
necessarily store The Source Code of the
contract it maybe the the closed Source
but what it does store is the Json
represent you
remember a talk earlier there's a Json
representation which is kind of like the
header file of a contract right that it
would store there's no reason why a
developer wouldn't of a contract
wouldn't put that in it's free
information it's it just helps people
interact with their contract and it's
easily derivable um and that would go in
the repository alongside some
documentation whether it's contributed
by the author or or other other people
and um and it's that that it would that
it would look up via this URI system and
the URI system
ultimately will be integrated with the
um solidity language so you use a URI to
um to cast from an address from a
generic address into a contract and then
when you start call it that's then an
object of type this URI this particular
contract when you start you know I don't
know if the contract's called a a DOT
that will bring up the uh the methods
that you can call whether it's in
JavaScript or
solidity stepan is the time to slowly
improve NS Z with this type of feature
set or just have a power development uh
about own track mix for minute um the
latter Al zero is at present um rather a
bed of nails it does most things that
you can ever need to do but it's it does
it in ways that are very much not uh
designed around the developer the idea
is to have this additional ID um and
basically sort of push alth zero into
Power us user or people who are just
sort of interested in mucking around and
viewing the blockchain and really push
the ID as the the primary way of
developing
deps Victor yes so three quick questions
first is so
so block right so it's not existing
right that is correct
yes I
mean does it exist in some yes there is
uh we're we're just about got to
Milestone one I believe is that correct
John yeah okay second uh you mentioned
that we don't want to deal with F I got
a bit scar
scar like you obviously people
understand what f is what director is is
even if you have proper GitHub
integration I mean even with GitHub you
need to have files and and people
understand how to transport maybe their
project with the zip anyway it's like BL
from so
for example with the contracts it seem
to like if you only had the
names yeah so um I suppose if you think
of it it's not that files won't be used
underneath and it's not that ultimately
the developer will have access won't
have access to their files if they if
they want access it's simply that um it
shouldn't be necessary to understand the
concept of a file because actually it's
not it's not it's not actually necessary
it shouldn't be a first class citizen it
should effectively be an implementation
detail that you can drw down to if you
want but that you don't have to so with
the contracts to take an example um it
might be that the contracts are one
stored one in each file and the file's
name is that contract name do soul I
mean that that would be a very sensible
way of doing it um but you know just to
mix things up a bit it may be that you
store them in the same file um so all
contracts may be stored in a single file
apprehensive of these magic functions of
things um well it might have a see to
sort of end up creating a sort of pseudo
proprietary format which you don't want
so there would be I mean you know it's
open source if if it does something
really terrible that developers don't
like they'll change it um so it's not
going to make any anything proprietary
but I suppose the point is that um files
as a thing don't need to exist um for
this and with the notion of Zips well
again it may be that developers want to
have a zip in which case they're free to
make is it from the directory I mean
it's going to be a directory cuz as you
said GitHub Works in this way but it
doesn't mean that um that it has to be
shoved into the developer space now what
I specifically want to avoid so that if
if you're after a real use case for this
it's um I rename a contract and yet the
file is still the old name of the
contract so if I if I got a contract fo
I renamed a bar but they I've still got
food. soul now as a as a program I
shouldn't be forced to look after my
files as well is looking after my Cod
exactly but automatic renaming is just
as scary
so um I would argue that it's it's
considerably less yeah we and the third
question can we get rid of the semicolon
at the end of the night you have to well
we we we could have a separate panel
discussion about
that uh Le yeah uh I just wanted to make
a question regarding integration of some
of these features possibly with other
editors you mentioned that it's all in
the library right now
in um
so that would integrate with ID directly
I guess we would just call the functions
of the library but couldn't we also have
at least some like the ASD printing or
um other features made uh into the file
by S C does some special argument so
that other editors can also integrate
with some of these features yes and I
believe it already does is that
correct the format is not really Parable
but okay but could me could be made so
yeah um yeah I don't yeah why not why
not uh the the precise priority of that
task would have to
be discussed but uh in principle yeah
just mentioning because you know we want
developers to adapt it then we shouldn't
solve no matter how would it is a
specific editor on their face sure uh
that won't be the case so they'll always
have the command line uh compiler if
nothing
else Alex um so two questions the first
is uh I SW is is swarm integrated at all
potentially yes absolutely and uh uh is
it integrated in more than one way and
um uh what what will happen to the Kens
uh I mean it doesn't look like that
progress Mar is moving it may feel the
worst um as for swarm yes it will be
possible to set up within the deployment
script or within the test and debugging
environment So within the tests and
debug definitions a set of uh key value
pairs for swarm for the resources that
you might want there oh um what about uh
say for
chatting about GitHub issues or storing
the project
itself um well that's right indeed
exactly that so click new project it
makes a new project in GitHub checks it
out and you're good to go yeah yeah oh
so uh I guess I guess we could store
everything in the get repository somehow
um but then that could also I mean you
could Mount ipfs locally or we could may
need that's just you might not need the
file system uh that's a possibility
too uh so I I'm Keen to go with things
that are already working for now
but uh Daniel uh is it part of the
vision for it to become eventually
selfhosted I mean to get rid of GitHub
and just host it in
SW um that's something that could
certainly be considered once swarm is
again you
know orfs which is ver yeah yeah for
instance uh span what were your reasons
to say okay create a complete new ID
instead of just attaching it to Clips or
some other ID with
plugins
um
so mainly because I wanted to avoid
um forcing other software into the
system and making more dependencies
making more things that go wrong more
moving Parts I kind of wanted to keep it
towards a single uh code base um that we
had full control over that made some
sense to me regarding um the need to
integrate into the blockchain so I know
eclipse is pure plug-in and technically
you should actually be able to do any of
this with it um the other reason of
course is that eclipse is Java based and
Java's utterly horrible
sorry it's very
heavy
buy
um there's so many things that to do
with that second the idea that it's a
clip slide you can extend it easily and
you can and one main thing because we've
got a co- teaching project that seems to
be coming up a lot is like collaborative
or pair programming um uh with video
tutorials side by side you know you can
and especially in this sort of area you
might want kind of the legal person or
the business person and the contract
person you're debating you're writing
together um uh it just seems that to
extend the the the the the type of users
and to get it should maybe be early in
I'm sure you're thinking about or things
like that to do to do that I mean you
mentioned like Google Docs I mean that's
classic so what are your plans with
regard to collaboratively working um in
educational other s with the IDE um so
the uh the screenshot whatever it was
yeah um is uh a first effort um but yeah
uh actually Dynamic pair programming so
having uh seeing the other person's
cursor Google lock style um chatting
maybe voice over IP at the same time um
with what what as you see the other
developer altering things yeah I mean
absolutely that's what it's all
about I want
to eventually time uh time will tell
good things come to those who wait
though uh okay any other questions no
cool thank you