Select text to annotate, Click play in YouTube to begin
00:00:00
soft engineering radio episode 140 new speak with Gilad bracha this is software engineering radio the podcast for professional developers on the web at se - radio dotnet as the radio brings you
00:00:14
relevant and detailed discussions and interviews on software engineering topics every two weeks thanks to our audience and the partners listed on our website for supporting the podcast so welcome listeners to another episode of
00:00:26
software engineering radio we are sitting here in the gardens at Microsoft Research we're here at the DSL Def Con and our guest today is give out Brava
00:00:37
and welcome thank you so please introduce yourself our audience so they know who you are okay so I've been doing object-oriented language work for more
00:00:50
years than it is fashionable to say but I'm probably best known for the 10 years I spent at Sun Microsystems where I was the keeper of the Java language specification and eventually the Java
00:01:03
Virtual Machine specification and before that I was involved with a lot of small talk work we did I was in a startup that did I think called strong talk which was
00:01:16
a very fast Smalltalk implementation that eventually evolved into Javas hotspot virtual machine and and I've done in academic circles I'm somewhat known because I also do research and
00:01:30
publish and things like that and the past two years I've been working on this new language called new speak which hopefully we'll get to talk about yeah well that's the topic of today's show and I guess new speak sounds to me
00:01:43
almost like small talk I mean the name is a little bit I mean speak talk small new yeah yeah there is something there definitely so so can you give us a new speaking a sentence okay so new speak in a sentence
00:01:56
is a language for the cloud I guess that's that's the best slogan I can come up with the the law the real goal of Newspeak is to create a really nice environment where you can program
00:02:11
for the web without worrying about the web without dealing with all these mechanics of of you know different languages CSS HTML Dom database back in
00:02:24
whatever in general to create a language for not just to run in a web browser but language for a networked world a network of where language where you very easily
00:02:36
can manage clients that have to on the one hand be connected to the greater world and on the other hand should be able to work offline and interact natively with your system and that's
00:02:48
that's a vision we're working toward it wasn't a sentence was it but I'll keep going I can add more and more concise yeah yeah exactly a run-on sentence yeah and from another perspective its small
00:03:01
talk with some of its pragmatic weaknesses made right so modularity security interoperability all those things are not strong points in in small
00:03:14
talk environments and we're we're trying to change that while at the same time maintaining what's really wonderful about it the reflectivity and flexibility that that you get that makes small talk programmers so fanatical
00:03:27
about the like yeah so so you mentioned small talk so small talk is clearly an influence yeah I guess also on the syntax to some extent uh yes the syntax is is very small talk like it's not exactly the same but definitely small
00:03:40
talk is probably still the largest influence other influences would be self and beta I don't know how many people are familiar with baby I've read the book whatever that means yeah definitely
00:03:53
that's those those are the three major influences so what are the influences from each of those languages like the top two or something okay so I guess small talk really still dictates the
00:04:05
it's still a class-based language it still dictates the the overall feel of the system self the big influence from self is this idea of what I call message based programming that is everything's a
00:04:17
message send or if you're if you're not familiar with those languages and their terminology don't think asynchronous messages as in concurrency but more virtual method calls every name and you speak is essentially a virtual method
00:04:29
call and that is an idea that comes from self the other the beta influence is the idea of nested classes and the fact that they can be virtual and overridden and
00:04:42
whole class hierarchies can be mixed in and things like that that is an evolution from the beta world mm-hmm if you say it's a system it's the overall system is like small talk is it all also also image based the objects in
00:04:56
the IDE kind of instead of text that certainly is a current situation because we're implemented on top of squeeks motto on now this you have to separate people often have a difficulty separating a language from its
00:05:09
implementation right so people speak of interpreted languages which technically is a meaningless phrase but if most of the implementations they know are interpreted they they tend to associate that yeah so images in particular are a
00:05:23
double-edged sword and we do not expect to require implementations to do that we currently are image based in there there are advantages to that one of small talks big problems was getting you know
00:05:35
separating applications from the ID right this is something that we're doing differently because because we have real modularity we can essentially very easily factor out an application and
00:05:49
save it essentially in a file and that sort of thing right so if you if you talk about systems or well cloud-based stuff based stuff and we talked about influences then if I were a cynic I
00:06:01
would say there might also be like negative influences languages you wouldn't want to influence your one I'm thinking about JavaScript in particular is it comparable to JavaScript in any
00:06:13
way does it try to solve some some of the same problems or is that a meaningless comparison well of course you can always compare two languages javascript is a dynamically typed language effectively you also get this
00:06:28
idea JavaScript was influenced by self yeah oh and and again you have objects and they have slots that it's very flexible and essentially every you reference in an object is is it's
00:06:41
like a virtual method call right it can be bound it they do the lookup versus a prototype so there's a whole bunch of broad similarities but javascript is is is a fairly poorly thought-out language
00:06:53
considering its influences were scheming small talk it's it's rather sad what came out but it got lucky it is in a crucial place it's simply fell into the right place in the universe and it's very important and we we are relatively
00:07:07
lucky because a lot worse could have happened in JavaScript is JavaScript is a wonderful assembly language it's my viewpoint it's it's my view is that people should not be programming the web
00:07:18
directly in JavaScript they should in whatever they want yeah and they should file it down and the browser the browser is evolving into the operating system and as it evolves it becomes more and
00:07:31
more adequate as a target and fast implementations are coming online and so forth so I don't I don't like program directly in JavaScript partly it's the
00:07:42
language partly it's the tooling which we'll also yeah but I I really don't I really want don't want to see a world where people are forced to always program in the one true language right for a company that tried to shove that
00:07:54
down the world's throat you don't have to mention names yes I think that it's it's a it's a nice one one very good
00:08:06
propagation vector is through web browsers and and we hope to get to a point where we compile to JavaScript and that works well enough but that's still something that's that's down the line so of course if we talk about a new
00:08:19
language one question I have to ask is why a new language couldn't you solve the same problem with frameworks based on existing languages what's the problem well so for some value solve the problem
00:08:30
right it's all turing-complete but you this the small dog experience is that this kind of reflectivity in in the language is very useful and that that idea has actually propagated in in
00:08:44
slightly warped form through through scripting languages right they people who the communities that use that have realized that the dynamism is really powerful and there are many features that originate in small talks that are
00:08:56
in these languages Ruby is actually very similar to Smalltalk conceptually though the syntax and implementation are or another matter yeah and so doing that in in a really clean and principled way
00:09:09
actually gives you a lot of leverage Oh in particular modularity is not a solved problem in programming languages okay we don't get the same kind of modularity then when you think of a hardware module
00:09:21
brock's okay pick up and and simply that that doesn't happen in programming languages and I think we have made real progress we've pushed the state-of-the-art this is this is actually academic or scientific but now we've done and so combining these things
00:09:34
gives you gives you real leverage yeah so so while I was preparing this interview I I obviously looked at little bit about material and you have things like classes modules namespaces mix-ins
00:09:47
all these different things in some shape or form can you distinguish the roles of these you already also said that module just a minute ago modularity isn't a solved problem I guess that's about
00:10:00
specifying the semantics of black boxes in some sense so what did you do in that space okay so so I must say though the way just introduced it it's very misleading because you mentioned all we have all these different things the point is we don't have no different okay
00:10:14
let me explain yeah essentially we have classes but because of two fundamental design decisions we can actually use classes and in all these roles right and
00:10:28
so a lot of people think that you know once you have nested classes it makes sense you can structure things you could values classes as your packages as fuel but in practice it in most languages doesn't seem to work out and people argue all we really need something
00:10:41
different and so you add a construct a package or an assembly or something like that we use classes top level classes as module definitions because if that works because we don't have a global namespace
00:10:53
which is fairly unusual there is no global namespace in the language at all and so a top-level class is a self-contained namespace and doesn't refer to anything external
00:11:04
to it and so can serve as a real as a real module definition the nice thing about using a class as a module is you can have multiple instances so then you can do things like side-by-side deployment which people struggle with in
00:11:18
in other frameworks and go to great lengths but it comes out naturally right there is a similarity between them and if you do them right do you actually can force them into that role so we the
00:11:30
absence of the global namespace means that classes can conserve as module definitions and their instances are modules because there's no global namespace the only connection and instance such a module has to the
00:11:43
outside world has to come through parameters that are passed to it when it's instantiated and that is a perfect fit with what's known as the object capability model right another I would start to me a little bit like dependency
00:11:56
injection also that you pass into it whatever it should be able to work with well in in a sense but of course the nice thing is we don't need a dependency injection framework of getting past your
00:12:08
available environment right so so the the other key idea of except for a global namespace is this notion that everything is is late bound everything is a method call and this eliminates all
00:12:20
kinds of constructs that were the main motivation for say for dependency injection right constructors the fact that you hardwire names of classes into your code and then you go and and develop these rather heavyweight frameworks to try and get around that
00:12:32
this can't happen because every reference to a class is really a method call in our system from virtual classes yes yeah yes so beta was the first language to introduce virtual classes
00:12:43
that's now we we get those for free because we can't do otherwise every name everything is virtual in our language everything is is this effectively a virtual method call that can be
00:12:55
overridden somewhere else and as a result of that we don't need dependency injection and as a result of that these modules also act as mix-ins because when you just you can let me let me back off
00:13:09
a minute nested classes when they refer to a superclass that superclass name isn't something fixed right that too is a method call which means that your classes really are mix-ins because a mixin is really a class with an
00:13:21
abstract superclass right and that doesn't mean that the superclass is declared to be an abstract class I mean is it really the superclass is something that can change it itself you can think of it as a parameter or something right yeah and so when you when we compile a
00:13:35
class we don't really know who its superclass will really end up being mm-hm and so we have to compile everything as a mixin and and so the top level classes act as mix-ins as well because they're the super class should be object or
00:13:47
something implicit in the system and so we've got mix-ins modules classes and I think you had a fourth thing but I feel modules I guess but you're right instances of a module definition so so
00:13:59
we managed the nice thing is we cover a lot of ground and get a lot of expressive power from very very simple rules based on these two ideas no global namespace and everything is laid bound
00:14:10
huh we just saw talk here about I don't know what the name was basically about designed by contract forms for dotnet language we have something like that like pre post conditions in your language we don't at this point and the
00:14:24
nice thing about this sort of language is it's very easy to accommodate these kinds of extensions without without really having to reform the language or change the more features you have in a
00:14:37
language the more features you end up having to add to it so you know essentially these contracts are you know in my perspective one of the things we haven't that's in the spec but isn't implemented yet
00:14:48
is a very general form of metadata yeah and that metadata could you know is left to someone to interpret so it could in fact include post conditions so if we did an implementation on dotnet I could
00:15:02
you know have the tooling to take such metadata and compile it into calls to Manuel's framework that you were describing we have a very nice framework and and implement that that way right so
00:15:14
but we do not we haven't done any specialized syntax or any snow and we haven't actually done any any any support for that right right now it's fairly conventional in that respect because we were thinking about
00:15:26
modularity I mean modularity requires that you can specify what some module does in some sense so you know when you can use it in how that's where the contracts come in that's certainly true that is one thing
00:15:39
that's nice to have and and certainly we can do that but that is actually easier to to fit in to do languages then the fundamentals of modularity right when
00:15:51
you have a piece of hardware the hardware doesn't specify anything about what it does there's a there's a document somewhere saying that it wants five volts on this plugin and something else and if you've poked
00:16:03
up 200 volts in my we might burn up but it is still a module by virtue of the fact that it doesn't depend yeah on it only depends on on the things that are plugged into it it doesn't have implicit dependencies on its environment sounds like you're making an analogy between
00:16:16
hardware and dynamic typing which is something I've never heard before but I don't see if you you know if you put the 220 volts on the thing you see it explodes yeah so it's something what's wrong well the real world of course isn't statically typed right you do you
00:16:29
do not have proofs for everything everywhere you go there's that but the main point is analogy that that's the kind of modularity that you really want is the ability to pick up a piece and
00:16:41
take it and connect it and know that it doesn't drag along things with it yeah so imports classical classical imports are a huge problem because an importing
00:16:53
say the modular style of thing is it doesn't disconnect you from dependencies it simply makes them explicit yeah you move it's like your laptop and you move it and it's connected to power cable which goes all the way to the power station and you take the power station
00:17:06
with you because you you specified exactly what it is you you have not made it parametric with respect to testing right and that's what we're trying to get away from so since we're talking about typing static or dynamic so
00:17:19
obviously we're dynamically typed so two out of the three big influences are dynamically that is awesome it should have been obvious but beyond that oh I
00:17:32
have a long-standing religious war going on this thing I've spent a lot of my time working on with types unlike most proponents of dynamic languages I I've spent a lot of work building type systems okay
00:17:45
static type systems and and I know what they are yeah and I know what they are good for they're mainly good for documentation documentation for both man and machine
00:17:56
so it's interesting there the idea that they make your programs more reliable is a myth and so and they're they also have the advantage that it is easier to optimize but that's not essential that's
00:18:09
been proven time again that most of the hot spot technology that makes java fast is is was developed for self and small talk and it doesn't necessarily rely on the typing some things do because the typing is there and people tend to use
00:18:21
that right but the real value is there humans who read this can see you know can quickly get an idea what this thing does and machines can can do that so you can do a better name completion better
00:18:33
refactoring etc etcetera right so with machines you don't necessarily mean the compiler but rather the tooling following it yes okay and so I'm all for having what I call pluggable or optional
00:18:46
type systems uh-huh and so the difference is the conventional approach is the type system is part of the language if you don't pass the type checker your program isn't legal it won't run right compiler will spit it back in your face and so the idea with
00:19:01
an optional type system is okay you write these types you can run a type checker it can tell you what it thinks and it does not affect your semantics it doesn't change what the program does and it certainly doesn't prevent you from running the program just as if it had no
00:19:14
types at all okay but then question why would you run a program whose type checker even if it's optional tells you your types are wrong because what type checkers do is they attempt to prove
00:19:25
that you can your program conforms to the type system all right and the type system you know guarantees you that if you conform to it certain kind of bad things won't happen that doesn't mean
00:19:38
that if you don't conform to it think bad things will happen right they can't prove they do not prove that your program is bad they prove that your program isn't good according to their definition of good and their definition of good is usually - is always too
00:19:50
restrictive inherently because the only way to really know if it's good is to do is the runtime semantics but if I try to add too a string you will never make sense right if you add two to a string it may never make sense
00:20:03
oh you're assuming that you know what ad means in a language like this of course you could have overridden things virtual yeah I'm saying yeah but but let but do you in depending how you write this presumably plus on on two makes sense
00:20:16
and so forth and so yes that will that may never make sense but that isn't really the problem I mean this is the kind of toy example that there are Tisha's give you but that really isn't
00:20:27
the problem the problems are much more subtle than that and there are lots of things that do make sense it's sort of like the the British or anglo-saxon legal system versus I believe the
00:20:40
Napoleonic one right are you are you innocent until proven guilty are you guilty until proven innocent right we generally don't don't assume that you know someone should be arrested because he can't prove that he didn't do
00:20:52
anything right a type system is essentially Napoleonic law it arrests you because you can't show that your victim you're worthy yeah so it certainly makes sense to to be able to
00:21:05
that that's one issue is the flexibility the there are other issues which which really boil down to documentation yeah there's go Kay so so one of the amusing
00:21:20
arguments that people bring up often nowadays what they've learned to appreciate I DS something that comes from the small talk world essentially in the early Lisp world and so forth and now they tell you ah but the more I DS
00:21:33
can do such a wonderful job refactoring and without type four information you probably can't do as well and they sort of neglect the idea that where did refactoring come from it came from small talk and the Java world they didn't
00:21:46
invent this because one of the things these type systems do is it makes it hard to invent things it makes it hard to do meta programming it makes it hard to do things that the language designer didn't anticipate as typical use cases
00:21:58
right because then you're type checker says no I can't prove that that's okay and and you it's very hard to be creative the wonderful thing about about dynamic typing is it lets you express anything
00:22:11
that that it is computable and and type systems don't type systems are typically decidable and they restrict you to a subset the common the type of people who favorite static type system say ah yes
00:22:25
but it's fine this is good enough all the interesting programs you want to write our will work as type then that's not that's ridiculous that's the once you have a type system you don't even know it interesting programs are there sure yeah it's a usual problem yeah that
00:22:38
the language you use con restricts the way you think yes our influences to everything yeah so let me try to explain to you what pluggable I have understood what pluggable type systems are and you tell me if that's right okay so let me make an analogy you say it basically
00:22:52
that in a language like Java which has a static type system there is certain information you put into the program as a form of metadata with basically a special syntax which is types and then you have a compiler that does some
00:23:03
checks on that metadata but there might be other interesting metadata for example the stuff there or well no let me say there are other interesting checks that for example today static analysis tool can perform for which
00:23:16
there is no specially treated metadata with special syntax but you might use for example Java annotations to put into the program additional metadata that then specialized static analysis tools
00:23:28
used and what you're saying is a language should basically have no you know singled out preferred type system or metadata system but rather you should be able to add different kinds of metadata that then are evaluated or
00:23:40
checked by different kinds of tools depending on what you want to do exactly also you you've got it now to elaborate upon one point in order for this to work
00:23:51
it's very important that none of the type systems change what your program does right because once once the typical case we have because then they'll interact and then you can't keep adding
00:24:03
new ones and so you can't you know check for race conditions or information fleex or you know whatever whatever flavor of the month you want or non-null or their there's all kinds of analyses and once
00:24:17
you say ah but once I can show that that that it is supposed to be now I'll put in a cast or a check then your program doesn't have the same and it'll interact with another system and it just won't scale
00:24:29
it's like it's like metadata is like has no side effects and presence yes exactly so and that's also why you said before that in Newspeak you have a general metadata system that's for exactly that
00:24:43
reason yes well have is a strong term or one that we we have a spec for it okay or something and we we will get there so yes that that is the exactly the
00:24:54
motivation well one of the motivations is viewing types of metadata they're actually more now our type system for Newspeak is a non-trivial exercise right now actually we we allow you again a legacy of the work I did on strong talk
00:25:07
is we actually allow you to annotate your code with types we just don't do anything with them and in fact we I can't say that we know precisely what these types will mean because type checking new speak is harder than type
00:25:19
checking small talk which is what we did in the strong dog system ok all right so so then is there I mean another like tendency today and in compilers with static type systems like Scala is to use
00:25:32
type inference to make you know to still have static types with the you know theoretical or claim benefits but you don't have to write all the type or type information all the time and use type inference sort of compiler can calculate the types does that play into this stuff
00:25:45
here oh it certainly plays into this stuff so one of the one of the problems with type inference is that once you mandate a certain degree of type
00:25:58
inference in your language it constrains your type system as well because they're the types have to be such that you can plausibly infer them and so there there's an exact analogy just as a type
00:26:11
system you know reduces them the set of programs you can write to to some subset that that you can actually check once you decide on language level rules for type inference it constrains what kind
00:26:23
of type system you can have because it has to be to fit within that inference team and so mandatory type inference is also a bad idea my preference would be to say okay for the type checker the
00:26:35
types have to be explicit whatever the type system is but again it's a tooling issue okay I would like to have a method browser where I said oh please infer the types and it'll fill them in and if it if it
00:26:49
fails then you know that's too bad but it hasn't it doesn't prevent me from writing those types it doesn't constrain how my type system was designed and I in fact I can use different heuristics different schemes to to actually do the
00:27:01
inference in some sense a type inference is just one of possibly many calculations a tool does with metadata yes and and that again removes a set of
00:27:12
constraints by not coupling these things as tightly and interestingly enough the research the the scheme community has done matthias for lisen and his students have done a lot of work on on what they called soft typing and Corky Cartwright
00:27:26
basically people in the scheme community and I think after a good many years and theses they came to the conclusion that the one of the weaknesses of soft typing was the emphasis on type inference
00:27:38
because it constrained things so so the the it's a surface illusion that you say I don't I don't want to it's nay the problem isn't with with writing these annotations or reading them within within limits the problem is with what
00:27:51
you can express it's often useful to read these annotations and how whether they're clutter or readable or what is a tooling matter yeah oh you present it so and one last question what is metadata stuff is it like comparable to Java
00:28:04
annotations in the sense that you have some generic generalized syntax where you put these things or didn't you get to the center so in text big yet since you're still at specification phase well so they it is comparable but it is not
00:28:16
the same I mean certainly the idea of annotations definitely fits with this but in my view to really make this work well you should be able to have for a given set of annotations you should be
00:28:30
able to actually define the syntax and define essentially a tool that will know how to interpret the metadata so it'll be something that says however begin metadata essentially look like a comment comments are also a form of metadata right
00:28:42
treating them formally also is great for refactoring because then you know where they belong and in that comment at some point you say oh this is metadata of some kind which will Q which kind of interpreter you how you want to interpret the rest
00:28:54
and then you can use nice syntax for it and and also hopefully tool support yeah code completion I think because that's one thing I won't I'm not willing to get rid of I'm yeah that's definitely yeah
00:29:06
so so it isn't supposed to force you to write it in some little constrained notation so we're here basically for the DSL def con is there any support for DSL and you speak hashes new speak yeah news because the infuse new speak
00:29:19
and strong talk right yeah you alright new speak well support the new speak is a great language for doing the s l's support is it's not like there's some feature that was put in press a to do
00:29:31
this but small talk originally was was fairly good at for domain-specific languages because the key word notation is actually very general very readable people aren't used to reading it as a
00:29:45
general-purpose programming language but it actually if you look at at notations people use to define metadata you know it's it's fairly fairly similar if you look at things like languages that are
00:29:57
purpose designed for describing gooeys like zamel and java it's where it's very similar in a way when you look at those examples so we use that in our in our GUI system we we writes new speak code
00:30:09
that looks a lot like you know rows and columns of gooey things right and it works well in that sense it works better than small talk because we allow the receiver of a method call at the target
00:30:21
of a method invocation if you to be implicit in in in a lot of cases which small talk doesn't so that again reduces clutter and the fact that it's dynamically typed means that yeah well you have more flexibility there you
00:30:35
could know about program yeah yes the meta programming features in general the fact that you can trap methods messages that aren't understood and give them some meaning that so this works very very well the fact that you can use
00:30:47
syntactically operators in a very natural form defined methods whose names are operator names so all that oops all that really works and and well the
00:31:02
reason I'm speaking at these Alcon is I'll be giving several example yeah when I'm looking forward to seeing that so a couple of last things one is that just came to my mind I did an
00:31:15
interview well since we were here about a year ago with Under Hasbrouck and we talked about c-sharp obviously and about his thoughts about languages in general and one thing we talked about was the
00:31:27
idea that language extension is always also IDE extension so it's also like what intentional is doing right or MPs JetBrains so have you if you're thinking about
00:31:38
being able to define pluggable type systems optional type systems then would you foresee a way how these custom definable type systems can also influence the behavior of the IDE so you
00:31:52
can for example do code completion based on some of that metadata sure so so anders is very right that if you're serious about your language then then every every feature in it should have ID
00:32:04
support and so if you extend it it means you have to assign your ID now in our case of a pluggable type system or a new type system isn't strictly a language extension but it is its new metadata and
00:32:15
and the tools definitely to make this work you want tools to to support that now because it's it's very easy to do meta programming and certainly the local the core the core reflective libraries
00:32:28
should let you get at that metadata then you you would have be able to expand your tooling because our preferred preferred ID is the one written in Newspeak right that's the point that now it's very easy to extend it and modify
00:32:42
it on the fly since you basically you do ide meta programming it yes yes yes and so that would be one example of that so getting back to where we started about
00:32:54
this language being optimized for cloud computing and the web there is one thing I came across which is object or services yes what's that okay so that that was the original motivation for the whole thing
00:33:06
the idea here is that typically in in client applications I started with this when I started using Gmail now I guess five years ago and I was very enthused when I said Oh
00:33:21
finally Google is doing mail finally I have a mailer I like because I've never found a mailer I really was satisfied with yeah and I used it for half an hour and decided no I don't have a mailer I like and and and more than that I realized well that it hit me then rather
00:33:35
belatedly perhaps that what the real problem was that I wanted something that behaved like a true native local rich application in traditional sense and yet had this coupling to the network and had
00:33:49
the advantages of being coupled to the network for example the nice thing about a web app is that no one asks you what version it is no one no one tells you I'm using version 2.0 and I'll never
00:34:01
give it up and you have to support it till the end of time and so forth right nobody the the question doesn't even enter people's minds well because you as the provider of the web app have to make sure that everything is compatible with
00:34:14
the data if you deal with rich rich client programs nobody would ask either that that's true to some extent though say UI features might change and so but yeah but yeah the nice so so definitely
00:34:28
you have to make sure that it works with the data and the traditionally because you're keeping the data on your server that you you manage the data yeah now on the other hand that means that this thing doesn't really work that well say
00:34:40
if I don't have a good network connection yep and if I if I need to go somewhere and it doesn't have that that immediacy and interactivity sometimes depending on on unless you have a really
00:34:52
good high bandwidth connection it's really hard to do so the idea was that you would write applications that could run disconnected on your machine and keep essentially a cache of the data right on your machine but at the same
00:35:05
time you do want that data to always be up-to-date and always in the format for the latest application and so forth and it's a little when I start to think that this is similar to what you do with with things like calendars and things where
00:35:19
you synchronize but right so you synchronize your data between several places and given how my mind is warped around the small bug way of thinking it's all basically a persistent set of objects
00:35:31
mm-hmm and if you could synchronize a general set of objects this way essentially the heap representation of your persistent data right then you would have these objects both on on a server providing a service and that's
00:35:44
where objects as a service comes from ah right and you and you could sync or download it to machine your machine essentially by synchronization make sure that the local changes you've made when you are offline you know take hold there is a design
00:35:58
pattern I think called half object half protocol or something which basically says that you design replicated objects in a way that they basically feel like if they were local on both sides of the replication channel and then the
00:36:10
replication basically happens automatically in case of the pattern yet the program it you of course and what you're saying basically is that you have language support for that essentially well we aim to have language support and we have we have basic features in the
00:36:23
language that are there are we don't even have the specification for it we have we have ideas and we have basic features which we believe make it a lot easier to do this because this is a hard problem yes and to do that one of the
00:36:36
idea is that because everything's laid bound right that simplifies matters there's a code doesn't depend on representation yes and and things like that that's that's very useful it means that if you need to change or update
00:36:49
things you you are always going through some intermediary that'll let you do that so that's that's the in a nutshell the idea of objects is software services and and you could actually build
00:37:00
services this way so you would deliver say a word processor as an application you you'd run it nice and locally and it would you'd have your documents as objects that you would have locally and if you're landing in Kamchatka somewhere
00:37:14
you can still write your your documents and you don't have to worry oh there's no web connection and my Google Docs aren't available yeah at the same time whenever I if I needed to collaboration I could have it in a shared space that
00:37:26
other protocol reach over the network when I change it would sync up and so forth so it's a kind of a way to get the best of both worlds and having a language which is really good at meta
00:37:38
programming in which objects are only handled through late bindings so you have this level of indirection all these things are things that basically are key to how we expect that infrastructure to work and we've done
00:37:50
some experiments but it's it's too early to really say that we support anything so what is the state of Newspeak today what can you or should people use it for work what can they get it from well they can get it at Newspeak program
00:38:03
what is the name of the webpage Newspeak language okay and you know Google will find it there turns out there are actually apparently two or three languages called Newspeak and a tool called Newspeak which is slightly
00:38:16
annoying but what can you do and but they but you if Google will find it though since it since its web 2.0 which you could have left away a couple of vowels and you know the name you speak
00:38:30
is is was was carefully thought and and occasionally you hit someone who's offended by it because of our well and so forth some people get it and most a lot of people get it and occasionally
00:38:42
you find someone who gets it and it's all upset but this is mainly a good way of testing whether people have a sense of humor or not so the idea actually is not a scheme to to oppress the world but
00:38:55
rather the thing about new speaking in normals novel was that every edition of the Newspeak dictionary was smaller because they were cutting down on the vocabulary with the idea of limiting how people could express themselves but
00:39:09
basically the idea that you would be able to cut the vocabulary that is you could actually take things out of software minimize the language little bit like in the Lisp tradition small language with powerful features that let
00:39:21
you do everything well we're certainly in that tradition but the thing I learned that Java was and I'm sure Anders would agree right any any widely used languages that you or any widely used software the curse of these things
00:39:33
is the curse of compatibility nothing can ever be taken out yeah yes and the nice thing about this vision which is a fairly futuristic vision of when you get to the point where your data is backed up on a server is that the world is
00:39:47
connected now and you should be able to find who's using what and you can you get just as you reform their data to me to fit the latest version of the program you know if they have
00:39:59
if they're using an idiom that you know you've decided is no good and can be rewritten or something you put out a script that that'll rewrite it and you know where to find all these programs so this is a bit extreme and that's sort of the blue sky research side of this but
00:40:12
the idea was yes wouldn't it be wonderful if I could take things out if we could minimize a shrinkable language rather than a global one yeah I got better okay so so
00:40:27
it's at this time it's basically in a development stage there isn't probably much that normal people should use it for it's definitely for the early adopter right so people who get enthused about languages and playing and stuff
00:40:40
certainly can do it cuz because we built you know product quality stuff with it at kailyn's okay but you had you still have there's a few things you still have to know what you're doing one of the great problems in the small talk world
00:40:53
has been deployment because again this issue of the ID and basically you deploy the ID with your application and not everyone wants to do that because of the modularity we can separate things out of
00:41:05
the ID and we're we're gonna get there fairly soon but right now it isn't quite a push-button process to say okay now packaged my application you still have to know a bit more than that to get something that's that's like to get a
00:41:19
dot XE out of right but we're we're on that track so that's mainly the thing that would limit people now because other than that I certainly on Windows you can do professional-looking stuff okay so right now I I don't want to
00:41:32
foist it on anyone who's who wants a turnkey solution but people who are interested in these issues who are enthusiasts and early adopters can certainly you can build stuff with it I
00:41:44
think that that'll run and yeah so I guess people who decided that Scala is now mainstream enough so that it's boring they can now go to new speak it's it's fresh enough so that it has its edges it's yes I think that's definitely
00:41:58
I wouldn't call Scala boring but yeah but yes that certainly is sounds like a fair characterization of how radical you should be okay and again we're we've been at this for about two years
00:42:12
been more or less eight years or more and it takes time to evolve to the that point sadly and I hope we will get there faster than that but before everybody has internet everywhere and
00:42:25
synchronization and offline working isn't necessary anymore I'm not worried about that yeah I agree okay anything else you want to say before we wrap this up just thank you for taking the time and you know you
00:42:36
certainly seem to at least have communicated this to one person because you seem to have gotten it and hopefully that way your papers are good enough so we're reading for 15 minutes I can ask
00:42:47
these questions so I hope I hope people you have a broad audience and my website is overrun by people floating Newsweek listen thank you thank you thanks for listening to software engineering radio
00:43:01
software engineering radio is an educational program brought to you by hillside Europe if you want more information about the podcast and all the other episodes visit our website at SE - radio dotnet if you want to support
00:43:13
us you can donate to the SA radio team by our website or you can advertise for sa radio for example by clicking on the Digg reddit delicious links and the slash dot button to contact the team
00:43:24
please send email to team at se - radio net or if it is specific to an episode please use the comments facility on the website so other people can react to your comments this episode of se radio
00:43:37
as well as all other episodes are licensed under the Creative Commons two-point-five license please see the website for details thanks to Charlie Crow and the pot safe music network for the music used in this show the song is
00:43:49
called Vegas hard rock shuffle
End of transcript