Select text to annotate, Click play in YouTube to begin
00:00:00
you know good afternoon welcome to the park forum my name is Sharon Tyler and I'm standing in for Kathy Ching who's coordinating
00:00:14
this series of Forums on behalf of exopt next week's form will feature Charles Russell from the Webster Research Center he will speak on electronic color documents and the 1992 siggrav
00:00:29
proceedings this week we're pleased to present Dr Adele Goldberg from Park Place Dr Goldberg earned the PHD in information science from the University
00:00:42
of Chicago and has held research and teaching positions at Stanford University in the pontifica Universidad de catholica of
00:00:53
Rio De Janeiro Brazil during her 14 years at Park she served as manager of the systems concept lab leading the r d team that designed small talk
00:01:06
from 1984 to 86 Adele served as president of the ACM she's authored numerous books articles and papers in 1987 Dr Goldberg received the ACM
00:01:19
system software award and she's also received PC Magazine's 1990 Lifetime Achievement Award for her significant contribution to the personal computer industry
00:01:32
please join me in welcoming Adele Goldberg [Applause] I was originally going to title this
00:01:43
talk is there life after Xerox but I understand Chuck geschke did that already when he came back from Adobe after a couple years being away what I was planning to do today
00:01:56
is three things is to tell you what park place is today and tell you from a technical point of view what we've done over the last few years to take a research result that we took out of park
00:02:09
into the commercial sector and then as the third item launched really into a more technical details of a new product that we just started shipping a couple months ago called visual works and do a demonstration of that David leaves from
00:02:24
Parkway systems is here with me David is an old zero eight as well he and a number of his colleagues from the Dallas Development Center were the first actually first five first four or five members of Park Place systems we had
00:02:36
transferred them up here in the late 80s as we were negotiating with Xerox to form part Play Systems fireplace systems in terms of his vision is clearly an extension of the work we were doing here at Park it's a software
00:02:50
company and the idea is quite simple which is to build software that allows programmers to create interesting applications that remove the barrier between people and computers is sort of
00:03:03
the emphasis that people are important rather than machines machines may be interesting but they're there to help people our Focus has been primarily on programmers at different levels
00:03:15
and we've been very interested in supporting the full development life cycle the um the technology base for what we're doing is object-oriented technology we spend a lot of time in the early years
00:03:27
evangelizing object technology and trying to convince people that just because with objects didn't mean it was bad now we spend most of our time trying to convince people just because it says it's objects doesn't mean it's good and you really have to take a look at
00:03:41
what the issues are in introducing the technology into an organization make sure that you have the right kinds of tools and organizational structure and especially that you're prepared to deal with the learning problems
00:03:54
um the analysis and design methodology problems for finding those objects and mapping them into the actual implementations for a lot of you I know you're familiar with the technology it's an old habit probably generated out of
00:04:06
the small talk early days that you want to build something you just sit down and you start building it I hope it doesn't surprise you that's part of the commercialization we've had to put a lot of effort into backing off and trying to
00:04:18
help people who don't just live and breathe objects to figure out what the right structures what the right models are what the right architectures are for their systems before they launch into programming so we worry about the problems of
00:04:31
learning analyzing implementing and testing big emphasis of course on reusing and creating Frameworks that people can specialize Frameworks in in our product line have more to do with
00:04:44
the horizontal support for user interface creation and information modeling um we wanted to make sure that the productivity expectations of objects were available by assisting in the
00:04:56
process of porting across platforms and as I'll show you the part the parkway Small Talk emphasis has been on 100 portability and then finally really helping people understand that it's not
00:05:08
enough to just reuse in order to get initial fast development but you have to be able to know what the ReUse is know who the reusers are and be prepared for the long-term maintenance
00:05:20
so a little history we officially left Xerox in March 18th of 1988 now for the historians in the crowd March 17 1988 is the day that Apple Sued Microsoft and
00:05:34
Hewlett Packard and the result of that was that Park Place got its picture in the Wall Street where I did my in the Wall Street Journal because the claim was of course that that was a silly lawsuit given that
00:05:45
it was all based on small talk in the first place that may have been the case for the lawsuit just settled as you know recently um and and had been a slight Nemesis of our place for the time because of my own
00:05:57
involvement in being the only Xerox Small Talk team member who never worked at Apple so um it was it was a strange position to have found myself in we shipped our first
00:06:13
Small Talk product in July of 88. we also got very involved in the C plus Community the reason for that should have been obvious we're real strong Believers in architecture and the support that objects bring to that
00:06:26
architecture have a good knowledge of the kinds of tools that Aid in understanding object-based systems and a good understanding of useful libraries and felt that for C plus plus to be
00:06:39
successful and for people to understand the benefits of object technology those tools those environments were going to be important there as well and that we would have something to contribute we raised I think about 11 million
00:06:54
dollars so far and we're done raising money now forever she says except in the public market we're a profitable company we're well over a hundred people for those of you who follow the market
00:07:05
powersoft which is going public now is a little bit behind us in quarterly revenues we're so we're at about a 24 million dollar run rate right now not bad for a group of researchers that
00:07:18
didn't quite know what they were doing when they stepped out in that real world time we completed our first profitable year then last year and then this year we took the money we had in the bank and we acquired two companies or released
00:07:31
Technologies from two companies Sovereign computer company which was a spark clone had a software development group software business unit that had done some excellent work in designing uh
00:07:43
visual components library for C plus plus and a product we call object builder for constructing user interfaces based on that Library smart editor and we acquired them in the in the early fall we also acquired which I'll explain
00:07:57
a little bit later technology that raises the tools level in the small talk world for interfacing object worlds to relational databases this is a technology called infoware which was a
00:08:11
group we spun off and then we just bought back it's kind of fun to do so as I said we're a little over 105 people we have engineering Center in Boulder Colorado that's where the C plus plus team
00:08:24
is partially the rest here in Sunnyvale we have a engineering center in Portland Oregon that's a dozen people all working on Small Talk project we have a subsidiary in Munich and then we have
00:08:37
Distributors around the world as well as our own direct sales offices and see if I can get this right New York and Washington Dallas Seattle here in Sunnyvale and in um I think that's it I
00:08:49
got it right the um so we've kind of gotten ourselves spread around the world pretty fast we had started out in the Pacific Rim with a partnership with Fuji Xerox which continues today although not
00:09:02
uh not exclusively anymore so we have a couple of distributors in Japan our target market as I said is primarily programmers so we have three product lines we have a product line that's focused on the C plus plus and C
00:09:18
programmer we have um product line focused on the small talk programmer and then a bunch of Engineering Services from day one we knew that this was going to be an educational process and put together a
00:09:30
good training team and Professional Services team that does a lot of mentoring and support of our customers so with the direct sales force knocking on the door of very large corporations we back that up with people who can go
00:09:43
out and give them direct training and mentoring as they start bringing object technology the kinds of programs however we deal with varies depending on the language this is a map that that I drew which
00:09:57
sort of says here's what's going on out there if you look at programmers today it's not hey there's those guys over there and beg them to make changes there's a a whole different layering of who the programmers are and the
00:10:08
corporations the corporations then working on a network with lots of information sources may go from a programming focus of systems programmers although in in the commercial sectors
00:10:20
like the investment banks on Wall Street for example or the insurance companies they don't tend to call themselves necessarily systems programmers they'll call themselves Competitive Edge programmers they're the ones who
00:10:32
absolutely have to have access to every little detail of everything because they're trying to squeeze the blood out of any performance or or any modeling capability they can and then they move forward to the people who you start
00:10:45
moving in the circle towards people who are more tied to the business but of course the way things are working now it all comes back where they all have to know the business when we first started in business I used to um give a lot of talks with the
00:10:57
audience for all programmers and I would say to them okay how many of you are programmers and most of them raise their hand and I'd say well keep your hands up if you're any good now what percentage of this audience would keep its hand up
00:11:10
what percentage of the audience do you think kept its hand up when I used to ask this no it's interesting Lotus they kept their hands up all of them and I and and I said oh just a minute here
00:11:23
this is before the the uh they've been so late with one two three and I said aren't you the guys who are a little bit late and they said oh no we're the Magellan team they're not allowed to come but most most of the time when I'd ask the question I'd get about four three
00:11:38
four percent and sometimes nobody would keep their hand up and a lot of it except they look at one person in the room and that was their the key person they relied on and then we'd end up I think hiring them
00:11:49
so I had to stop asking the question what was going on there of course isn't in those days when which is four or five years ago and you'd say are you good the measurement of good had to do with can you create the result that's desired so
00:12:04
it's running fast enough using the right amount of speed and delivering it on time and since very few people could take credit for being on time they were keeping their hands down as you'd expect but increasingly there was becoming this
00:12:17
this problem where they didn't know quite what it was they were supposed to deliver and the guys who were keeping their hands up when I'd say well what makes you good more and more they were saying we know the business so at the transition out there as we head into the
00:12:30
90s is not an isolated systems programming team of people who read the computer science literature but people who truly understand the business and so there's kind of a partnership that goes on where the old data Administration
00:12:42
people are more information Administration worrying about the information models or object models of the company worrying more of these problems of what is the shared repository and they negotiated a lot with these guys who kind of try it out
00:12:55
kind of worry and try it out so you have to start worrying about tools that transcend these levels of access to the system and pull around to the power users and end users but inserted in that
00:13:07
is another new class of uh not a new class of people these people have been there all the time the chief financial officers the accounting managers the human resource managers the systems managers we're always in these companies
00:13:20
but more and more as they started using spreadsheets and doing Simple two-dimensional you know linear constraint oriented systems they started realizing that they didn't have to go ask for help anymore or at least they
00:13:33
believed they didn't they can just go program the computer as well so as we're moving into the 90s we're seeing a big emphasis of these Competitive Edge programmers creating Frameworks that represent the business process being
00:13:46
delivered down to the information managers who are modeling their business programming through more constraints declarative oriented languages and expecting to have clear access all the
00:13:58
way down between very static databases on the Mainframe static databases and the relational world even static object databases but not not as heavily oriented as we're still on the db2 and
00:14:10
on the hierarchical and network databases on the Mainframe and more and more trying to have a client server model where they're after some kind of computation service so we start having to worry about what
00:14:23
kinds of tools and environments you give to these kinds of people and and what we've been doing is focusing um our C plus plus product family more on the systems programmers and business
00:14:35
programmers who are really really doing the user interface design and as a result we use the word object Works to refer to the programming environment for that systems programmer for professional programmer
00:14:49
object builder in the oi Library which we acquired from sobern this fall then provides that kind of graphical construction but it still expects you to have fairly deep understanding of C plus
00:15:02
plus in order to set up the callbacks for any kind of button push or any kind of widget Tree on the screen we have a process debugger for good tracing of the variables and the Dynamics of your C
00:15:15
plus program and then part of the strategy is along with object works there are libraries and smart editors that we call object kits and in this case it's the we Market some other people's stuff
00:15:28
I'm going to spend most of my time focusing on small talk though because a lot of people looked at our products and started seeing us announcing C plus plus and they said ah they got wise they gave up on small talk
00:15:40
um 50 of our product Revenue which was over a million dollars in December um or that million dollars was all small talk product and then of course on top of that is doubling our revenue between C plus plus and our services so we've
00:15:54
made a business out of small talk um we've managed to mainstream small talk along with our partners and other vendors who sell Small Talk um and we do it with a number of products object works for small talk then is focused on that system
00:16:07
Competitive Edge programmer we ship out full sources and we sell sources for the implementation of the system allowing that Competitive Edge programmer to make changes at any level of the system object Works does not assume that it's
00:16:20
going to be on a client Graphics it allows them to build information models on the servers and on Wall Street we have a large number of investment Banks who specifically use small talk to do the modeling of the portfolios out on a
00:16:33
server and then multiple Trader workstations running the client base we have a number of object kits I'll say some more about and then visual Works which we're going to demo today and then a lot of drivers to hook up to
00:16:45
relational and non-relational databases such as the ones listed here I want to go through this pretty quickly because I want to spend most of our time on on the actual visual Works content let me speak to the portability problem
00:16:58
because this gives a hint of the kind of work we had to do the the idea of portability is not that you take your C code and recompile it and hope it compiles and hopes the compilers have the same bugs in them the
00:17:12
idea portability is that you take a fully running system that is compliant with the expectations of that host system pick it up put it on the other platform and it takes care of all the problems
00:17:24
associated with living on that new platform and just works clearly the idea is is productivity here is is both speed as well as lower cost if I'm maintaining this one application but it happens to
00:17:37
run across all of these workstations that are kind of the combinations of these processors the Motorola based processors Intel based processors there's a bugger here for sure and all
00:17:50
the risk phase spark and myths and Rios and the PA systems are the ones we've done in fact the the only ones that we really haven't done yet are the um are the 64-bit ones which are coming up
00:18:02
the alpha chip and whatnot so we spent a lot of time worrying about the change in processors we worry about the operating systems combined with the windowing systems have an object engine that I'll describe in a little more detail and
00:18:15
then a bunch of modeling objects and then above that line is our whole programming environment that you use to develop your application your application then deploys at this level right above the base across all of the supported workstations and we guarantee
00:18:28
100 portability unless you decide to use something which we also support that that host provides that nobody else does example if you're on a Unix system you lose sockets you're certainly not going to be running sockets off your Mac or
00:18:42
off your PC until winsock actually becomes real but as the vendors start providing more and more services we make all that available the visual works that we're going to
00:18:55
show you adds another layer above this the the idea was of course very simple it says if I'm doing sophisticated interactive Graphics I'm going to have a very sophisticated package that
00:19:07
understands the visual widget tree and understands all the layout learning how to program that is hard and um is nothing to do with whether you're a good programmer or a novice programmer it has to do with the fact that the concepts
00:19:20
behind sophisticated multi-layered layout is just simply hard so what you want to be able to do is say never mind you could see it on the screen just paint it just lay it out and we'll take care of the rest now so that's one set
00:19:32
of it the second set of it says yeah but how all those widgetree hook up together and maintain their dependency together and how they hook up to the application logic that gets me out to the databases or out to my information models which
00:19:46
may be servers on the net that's all complicated hookup as well help me automate that so we provide a application framework which gives the first default layer of that that then can be refined to get out there that's
00:19:58
what we're going to show you today so we extend the portability that I showed you with two more layers and that the two layers then is to provide an isolation layer for the database that says I'm and this is our
00:20:12
customer requirement I'm going to write SQL and embed it in my small talk and then squirt that out through whatever drivers are available some drivers act as middleware Eda SQL is a product from
00:20:24
information Builders Incorporated in New York and it acts as middleware so that if you send it any SQL message it will try and figure out what its correspondence out is to the actual database but of course it's an isolation
00:20:37
layer we're providing not Independence because if you send an SQL message that Oracle doesn't understand but Side based thought does and you send it to Oracle there'll be a problem so we just provide the API for for that layer and then
00:20:50
we're coming above that with the independence layer and then we provide two more things what we call a policy interface for the look presentation so that you can sit at this one one machine and rehearse what it will look like on
00:21:02
all the other machines one of the other productivity problems our customers have have is that they they don't quite control What machines their applications will be deployed on some of them have thousands of of users of an application
00:21:14
and those thousands of users are worldwide and some of them will be on PCS some on Macs some on sun some on death some some on HP and so forth and every one of them has some different
00:21:26
peculiarity that they would have had to check out by having a laboratory full of every machine and then configuring to it so we provide essentially a re-implementation of the key aspects of all the machines so that they can
00:21:39
rehearse across it the um yeah just one one thing on the object kits for small talk um the two things that become important is that small talk is clearly no longer
00:21:55
its own world we sit in the host window system calling on host facilities uh working with the host operating systems and and executing to the machine code of whatever process there were on and that
00:22:07
means that we also have to interoperate well with other languages and so one of the things that we've done is created a object kit that says lets you sit there and say Here's my C procedure interface
00:22:19
create the small talk object stubs for me so that I can call to the C programs and call back of course what it's really doing is calling to that c interface and other languages that compile and can be
00:22:32
stored in those kinds of the right header files can also play in that in that kind of wrapping technology um the the the next five slides that I've put
00:22:46
together was to say look everyone used to ask me what's the difference between a research result and a product and one strong feeling we had is of course as a research result is the thing that you can always throw it away and start over
00:22:59
again and that was kind of the the whole Small Talk groups mentality is we really didn't want anybody using any of this stuff because then we couldn't throw it away so now that you're commercial you don't get to throw things away every release has a backward compatibility
00:23:12
issue but we had to start stepping through and I believe if it isn't 100 it's about 98 of the code we ship today is brand new since we started if that weren't the case you should be pretty
00:23:24
worried about our customers um I was pretty worried back in 1985 when I first started harangu and Xerox to do something because xerox's some of their groups were shipping very interesting applications the analyst
00:23:38
workstation is still one of the more sophisticated applications that I've seen built with with full object-oriented technology but they were shipping it on complete research results object engines built out of research and
00:23:51
they were scaring me because they were shipping it to government agencies who were using it for their daily work and somehow it just didn't quite feel right now they're shipping it on a robust engine and it doesn't break and it all makes a little more sense to me that
00:24:04
object engine that we rewrote had we had a couple of missions first one was that we would be fully compiled Small Talk At least our small talk is fully compiled on all of the workstations however you don't compile
00:24:16
it basically it's what we call a lazy machine code generator you uh you have a intermediate representation that representation sits on top of this layer here when you need to use a part of the
00:24:30
system it will compile it down to the machine code and then cache that never does it again you never notice it you never notice any burp or any weighting if it then has a cache of 8386 code and
00:24:41
you move it to other 8386 machines we stick with that but if you pick it up and put it on another machine and it's a spark it notices the difference flushes the cache and starts recompiling again because we recompile and not the people
00:24:56
moving it from machine to machine they don't have a configuration release expense on them nor do they have people who have to know all that stuff um and that of course gives us a couple things much faster execution speed
00:25:07
better space efficiency and then the binary portability that we're looking for um without having to have an interpreter another thing we had to do was was design an entire new memory manager this
00:25:19
memory manager is unusual in a number of ways it's what you might think of as a hybrid memory manager we basically segregate our objects according to age young objects what I call midlife
00:25:31
objects and old objects are ones that require permanence or mortality and then we apply different very different algorithms very different approaches to the management of those segregated
00:25:44
objects depending on what they are so we'll use a mixture of generation Scavenging incremental interruptible garbage collections so you can actually have a policy to say how often you want
00:25:57
it to start garbage collecting and for how long it should happen but it always bows to user events so it will always stop in the old days here at Park there was the famous little icon which was a
00:26:09
garbage can saying just a minute I'm the computer I'm in charge here I have to go clean up the mess you've made and that doesn't show up anymore and that's good and then of course an old-fashioned Mark sweep is still in there as well
00:26:22
the big reason why we redid the whole object engine and rewrote it all was because we needed to have a portable architecture because we were fairly confident that despite the fact in 1987 I was told there'd be only two operating
00:26:35
systems and two processors we'd ever have to worry about um I was pretty sure that wasn't going to happen I lived a park too long with people who like to invent those things and we were making it easier to do that so of course we can port to different
00:26:48
machines very fast we run today on 11 different platforms when we ship visual works this fall and we had seven platforms out at the time we delivered visual works on every
00:27:00
platform immediately and we're one of the very few software companies ever to do that so even if our customers didn't believe or want portability we sure did and it's really made a difference in the size of our engineering teams and the cost of our business
00:27:13
a couple a lot of other things we did we wanted to start creating layers of Independence if you're going to be on a multiple operating systems that means multiple file systems there was the design of a new class a library of
00:27:26
uniform i o that you program to and then you have complete Independence of the file system um we had of course to um to admit that Xerox didn't get in charge of the look and feel of the world and that were
00:27:39
going to be lots of different Host Windows systems and we would have to comply with more conventional Imaging approaches so we redid our entire Imaging model throughout all the all the bitmap stuff that was in there redid the
00:27:51
entire class Library accordingly and that gave us Graphics Code Independence across all the machines we also had to put a layer of classes in there that defined how you talk about window managers but as you move from the Mac
00:28:04
using the Mac Window Manager onto the PCS and windows or onto the Sun an open look or most of the other Unix systems with Motif it immediately converts to whatever the window manager of choice on the host is
00:28:17
we did a whole lot of series that we call policy interfaces so that you're always programming to policy this is very much in line with what Bob balzer at isi I've been screaming about for as long as I've known him which is probably
00:28:31
15 years which is you don't program and generate code you program specification you describe what you want and you when you need it you go put it into the form for execution and more and more we've
00:28:43
been taking that route so policy interfaces are ways of saying here's the kinds of color palettes I want here's the description of the fonts I want here's the kinds of visual widgets I
00:28:54
want an action button or a checkbox or whatever and here's here's my view of what I need in the memory manager and based on that policy when it's time to execute the system figures out what the good match is to the underlying host
00:29:07
system we didn't do a lot of changing to the small talk language itself that's kind of coming up and over the next couple years since there's now proposal before ANSI for ANSI standards that should stop
00:29:22
you know stall any progress for a while um our our biggest change that we're planning to do the language regardless um and and propose to the standards of course is to start having a clear
00:29:35
segmentation of the namespace in the system so we can have a base ability for dynamic loading and unloading and that work is in progress now we've added a sophisticated exception Handler in there
00:29:48
a lot of people would say to us so small talks perfect prototyping and I thought it was perfectly awful for prototyping because you couldn't signal that you were incomplete a prototype is something
00:30:00
that's incomplete and the worst thing you could do to somebody Who You're testing an idea out is to give them something that's going to crash all over or be real slow because then they're going to tell you I don't know your idea
00:30:12
is okay but it was running so slow or when I tried to do something it crashed so prototypes have to degrade gracefully and they have to run just as fast as any production system in fact prototyping systems tend to have to be in my eyes
00:30:25
more robust than some of the pro product systems you have less time to check things out so we put the exception Handler in we also we did all the graphics and user interface libraries as I said before I'm on the board of the
00:30:38
OMG we've been participating with them to understand the distributed shared object world problems a number of companies have been doing bindings of small talk to the object request Brokers
00:30:50
and actually in a couple of weeks a major vendor is going to be announcing a beautiful product which is Lotus Notes like all based on the visual works that we're going to show you we've done a lot of work in both both
00:31:04
product lines on visual navigation and better ways of understanding source code the object works for CNC plus plus product is written in small talk and provides a nice visual Navigator that's
00:31:17
coordinated with the source code debugging and online help I grabbed just a couple pictures of it just to give you a hint of that which was basically it's a a user model
00:31:31
that says pick a focus of attention and then attach to that Focus the perspective of how you want to look at it in its neighborhood so I may put pick as a focus of attention
00:31:43
a particular member function or a particular class or a particular file and then I may say gee the perspective is who calls on this or what does it call on and then I'll get a graph to
00:31:55
look at it and then I could attach to some other part a perspective for reading the source code and have a connected browser that shows me the source code and I can simply move this perspective
00:32:07
this perspective around in order to change the focus down here so I get a lot of interesting visual direct manipulation type pointing to look at the various parts of of a system
00:32:20
it's a drag and drop system so that there's a whole menu full of different perspectives that you can have for editing asking questions about usage asking questions about who's the client and who's the server of a particular
00:32:33
element and then be able to have a focus of attention like the list here and drag the different perspectives down so we were doing experiments and then out to product for the C plus community and we're going to
00:32:47
bring all this back to the small talk Community the debugger works with the same style and then the help system which is online has two parts to it most of the most programmers I know whether they're small talk or CC plus plus
00:33:00
Cobalt or Fortran or whatever don't like to document I think that probably Rings true here as well and when you ask them why they don't like to document they say it's a silly waste of redundancy the system it's in there already look at the
00:33:12
code it's all documented sound familiar um and what they're really saying is if you could just have some kind of filter some browser on the structure and let me explore it dynamically I'll have better documentation of what's going on but the
00:33:27
one piece of documentation I programmer and willing to write is what role these particular objects or these particular functions Were Meant to play so we we use the same kind of navigation on the online help system and the Unix system
00:33:40
we then convert Unix man files into these correct formats for being able to do the browsing so a lot of that work was happening and all that graphical stuff will come back to the small talk World
00:33:52
um we also had to worry about the bridges to and from other systems the small talk obviously wasn't going to live in its own world nobody nothing lives in its own world um in a networked environment so as I
00:34:04
said we built the C programming object kit for the call and callback interface we also built the we call the fusion database isolation for the embedded SQL and then the first year Park Place when
00:34:16
we started in on the database problem we started a project that ended up being called infoware and really has this object lens this notion of creating a persistent object world where you talk
00:34:28
about objects and you send messages to containers of objects for updating and inserting and deleting and it automatically generates the SQL out to the relational database automatically lets you extract the forms and create
00:34:41
the images on the screen and automatically lets you navigate over for the relational database and to do that you have to not retrieve everything but have a notion of proxies and to do
00:34:53
that you you have to absolutely know that for any retrieval if you've retreated before it's the identical object and that means that you have to have knowledge of the primary and foreign keys in the relational database
00:35:05
and so this technology that we started I started getting worried that it was a little bit too more too much research we spun the little group out they got separate funding they were researchers they did get it done we've bought it all
00:35:19
back and so we're integrating it now with visual Works to bring it out as a product I think that's a lovely way to do things and it was kind of fun after one year to be on the other side of that spin out table and then the last slide about what we
00:35:32
had to do um given that our Target were large corporations then we knew we were going to have large corporation culture problems or as we say in business
00:35:44
culture opportunities um and so the the issue here was to understand not just for object technology but for any new technology what do you have to do to be ready to bring it in the door so that people
00:35:57
understand what they have to learn and you can help them learn but also where the real cost is a lot of people equate objects and reuse they think that from the day they get started everything will
00:36:10
will go faster they can just reuse all these libraries combine them together it's really magic it's the most remarkable example I've seen the last decade of a strong belief in Magic certainly I
00:36:24
certainly think Philippe Khan has contributed to to that belief but not to uh now I guess this year he hasn't um one of our goals is to is to go in and I
00:36:37
really literally go into the Chief Information officer these companies and I say look it's going to be hard here's what you're going to have to do and it's going to cost you if you're really going to do reuse and it's going to make a difference to you it's strategic reuse
00:36:49
which means that you're not going to buy it from the outside I'm probably one of the few people out there who doesn't believe it very strongly in a large public market for objects alone and I qualify that carefully but basically
00:37:02
that there are strategic they are products they have to be prepared as products so we we've done some major project case studies and and have been endlessly as some of you know working on a book that to explain what we think
00:37:15
works and doesn't work and should have that out sometime this year and as a result of doing all that you really start getting into process model and what works and what doesn't work I've had people accuse me of sounding like some DOD contractor which was pretty
00:37:27
scary because around here they used to you know accuse me of living in a fairy world Maybe maybe they're the same so we got very heavily into understanding what methodology is and started looking to see what was the
00:37:41
problem with all the books there's lots of books on object-oriented methodologies coming out now and uh why they weren't working and they weren't working because they all make one assumption they assume you already know what the objects are and your job is to
00:37:54
figure out how to structure them in an interesting way and of course that's not the problem in the commercial sector they got to find the objects in the first place and if you go look and see how they used to find functions in the
00:38:05
first place the task is quite similar there's a whole interviewing scripting approach to napping things into what has to get done the difference is we don't throw away function anymore we keep that
00:38:17
function or that behavior they used to throw it away because all they wanted was the data model and then you can apply all kinds of new function to the same data model so we've been working on methodology called object Behavior
00:38:29
Analysis and design and the first paper on that was published in the communications of the ACM in sept December and we're now doing tools for for the Oba and we do this all jointly
00:38:40
with sematec and Texas Instruments um and finally of course we've done a lot of effort on visual construction the visual Works we're going to show you is actually a product that comes out of having done it four or five times before
00:38:53
so we've thrown away a lot of prototypes we see a lot of things coming to Market and we go oh yeah that was our first prototype we remember that um and there was a reason why we threw it away it's actually very easy to paint
00:39:04
a screen and generate some code that executes that but the um the goal we had is to and sort of the cute Title Here is maintain the objective of the technology for reuse
00:39:16
and and a lot of what we've been trying to do in in the small talk world is make sure that when you have very complex structures you can reuse from any part of those complex structures and plug them into any kind of complex structures
00:39:30
and the kinds of tools you have allow you to mix and match as you please we've seen a lot of people be surprised when you have a bunch of objects that we decide to make a new superclass and
00:39:41
they're all going to be made a new suit made subclasses of this common superclass but there are lots of members of the class that already existed and they all live and they all keep living and we just essentially remap all that
00:39:54
stuff instantaneously and then we discover well even a lot of other small talk systems file all those instances out restructure and then file them all out and again and sometimes it's three hours later so we've we've sort of put a
00:40:09
lot of time into worrying about being able to restructure carefully and quickly and as part of that shortening the development time thank you and obviously reuse is about quality and most people tell you gee reuse is about
00:40:22
getting it done faster when in fact what objects are really about and what reuse is about is improving the cost of the long-term maintenance of your systems here in research you don't worry about
00:40:35
maintenance you don't want to worry about maintenance that meant you were successful too successful because somebody took you seriously you shouldn't be doing that in research you should be doing things that when you do it nobody's interested in is there any
00:40:47
managers here mad at me um and I used to have this argument all the time if you're not doing something that is risky and it's okay to fail then in my book it isn't research but in in a product company where you're supposed to
00:41:00
be making Revenue you're not supposed to be doing that in a commercial sector you're not supposed to be doing that so what you're worrying about is whatever you build you know is going to be long lasting and you know it's going to change if anything the commercial sector has
00:41:12
finally learned is whatever they build is going to be wrong a couple years later not because they were wrong but because the world around them change and the needs change so now you have this interesting problem I've created a world
00:41:23
of new things by reusing a bunch of old things when it comes time to make a change there's two kinds of changes one change is just maybe restructuring the new things I built that's okay but the other
00:41:36
change is that we'll constantly maintain the reusable assets we will improve the quality of them and what everybody out there believes is that the quality of everything you built will be infinitely
00:41:48
better over time because it's going to be benefiting from the Improvement and the quality of the reusable assets well there's one flaw in this as I improve my reusable assets new reusers will certainly benefit but what about the
00:42:00
guys who are already reusing how do we know who they are how do we propagate that change we did case studies on 32 very large projects and 90 percent of the ReUse going on was cloning they were
00:42:12
just copying from these libraries and then changing them Helter Skelter and and basically ignoring where they came from well that means the long-time quality is not going not going to persist so there's a fairly major
00:42:24
maintenance problem out there which which you have to to worry about if you're worried about the life cycle now most of the ReUse that happens in an object World happens either because we're going to reuse the external characteristics which in a graphical
00:42:37
environment means what the screen looks like or we're going to reuse functionality and some aspects of the external characteristics or we're going to use what I call genetics that is everything about you however you grow
00:42:49
and changes your hair gets grayer my hair gets grayer sort of that genetic inheritance and so you get a closer and closer Tighter and Tighter coupling of how change should propagate and the
00:43:01
challenge to the designers for new systems based on effective reuse is to plan for how change should propagate over time now if we're going to use visual
00:43:15
construction and we're going to be able to benefit from reuse then we have to think about just what does it mean to reuse those three aspects of the system we're going to be able to express by painting and express through some kind
00:43:28
of interactive dialogues or wiring exactly how we're going to build our application logic and how things will be dependent but I want to make sure that I can choose how tight the coupling is so that I can predict the change
00:43:41
propagation that happens so I'm going to skip some slides because we're going to show them online and I'm just going to tell you quickly what's in visual works and what you're going to see in the demo the port for visual reuse then comes
00:43:56
from there being a painter which is what everybody does you have this notion of a canvas you bring it down the screen you make sure that you have a lot of tools to handle the layout and the positioning and the decorating that needs to happen
00:44:08
then there's a definer because there's different layers remember on that network of different kinds of users and some of them aren't going to want to have to see any code and some of them want to see code that's scripting and some of them want to see all the details
00:44:21
of the coding so you want to be able to have this canvas you paint which is your external characteristics will be linked into your database and your data model through an application logic or model and that application
00:44:35
logic can be partially generated and the way we do that is to think about there being an application model which represents the general notion of how all the dependencies work between all the parts
00:44:49
of the visual interface and David's going to show you some of this and then be able to subclass and specialize that um the product manager on on visual Works who who came out of informix was
00:45:01
very familiar with the informix database Tool uh um book and so he went through the book and he said I want to do everything in here all the 4gl activities never writing any code at all and he built a
00:45:13
subclass of our application model that just understood that default behavior and every time you build something you just said make me an informix model and everything then would be generated now we don't generate code
00:45:26
what we do is generate user interface specification which becomes part of the model so for the painting we generate the specification for the application logic we generate the code and then we have a
00:45:39
builder that when it's ready generates the actual code and for those of you who are familiar with the small talk world we have this factoring of models views and controllers that is to say information models presentation interaction and we're basically
00:45:51
generating what is fairly complex code and complex trans graphical transformation and layout code David you want to so what David's going to be doing then is he's going to show you how as an
00:46:07
interface designer he uses the painter and the definer to generate the specifications which gets you to start building a user application that user application passes the models and the specification down to a builder which
00:46:21
passes through the look policies because the specification says I want an action button here but depending on your presentation policies and my host am I Mac am I my own invention you get the
00:46:34
actual thing that the end user ends up happening has seen so I'm going to switch this off right okay and then we turn that on yeah okay miles yeah okay uh first I I just like to show
00:46:59
a few of the applications that uh the product manager built so you can see sort of the types of things people build this is a this finder that I'm
00:47:13
interacting with is sort of a way to find all the things that have been built with visual work oh goodness that was a demo effect was working earlier okay so this is a thing he built for uh
00:47:39
tracking leads for uh sales people so we can go through and look at different leads and make notes about them
00:47:51
and let's see things about different sales people that sort of thing it looks like the kind of uh thing people build with hypercard calendar sort of application
00:48:32
okay so uh let's let's uh build some stuff with it you open up a canvas to paint on and get a palette of the widgets that you
00:48:47
want to paint and you can paint with action buttons and radio buttons and it's got the normal selection and grouping and kind of things that you'd
00:49:02
see in normal drawing programs and you have alignment and distribute functions oh did them the wrong way let's do that again it's hard to work
00:49:21
and talk is it it is that's a line on the vertical on the vertical vertical right the normal way I do it is uh actually there's keyboard shortcuts for everything so I would just normally do
00:49:39
it off of the keyboard it's a lot faster so uh you can bring out different kinds of widgets and place them and interact with
00:49:55
their properties so we have a good Xerox style sort of a property sheet interface to these things so I can I can select the widgets and see what
00:50:08
properties that I have to fill in so I can give the this group box a label another one of the tools uh let's see canvas control
00:50:34
would allow me to turn on a grid set the grid for whether I'm gritting it in X and Y put a fence up around it so I don't have to be careful when I'm
00:50:47
dragging things around I can just slam up against the edges let's get something uh with scroll bars and from this I can preview different looks and feels
00:51:09
so we can look at uh sort of the os2 CUA look or open look anybody like motif
00:51:22
yeah I do oh good and can I show this one yeah it's Macintosh but don't stay there okay go back to Windows go back to
00:51:35
Windows okay it's a Windows machine I guess that's the right thing to do okay so actually let's let's build something
00:51:51
and see how it all hooks together so let's uh just have a simple uh number input field and the slider foreign
00:52:12
for this widget to hook up to and say it's a number [Music] and I want the slider to talk to the same aspect set of range for it and step it by five
00:52:43
and at this point I need to give it a place to live so it's going to prompt me for the name of a class which would be uh typically one of our application models oh
00:53:02
it says I've never seen that do you want me to go ahead and make a new class for you and it gives me an opportunity to name a different class or make it a modal dialogue but it's a plain application models which
00:53:15
wanted foreign that I really want to use this is sort of a control panel that lets me do pretty much all the useful things like aligning and distributing
00:53:39
and spacing components and I can also Define things that need defining so since I've been saying all right I'm going to hook up to a certain aspect
00:53:52
which we called aspect uh says it knows it needs that so I say okay go ahead and write the application code for me so I'll have
00:54:04
something there of the correct type that will answer to aspect and at this point I'm ready to run the thing and of course it doesn't work
00:54:26
I don't know I have to go see David's giving a demo in front of an audience for the first time so be nice but look at the property okay I I didn't you didn't say except
00:54:42
I didn't tell it that one was aspect I didn't accept it now you can still now you have to you have to Define at the defiant left to right say Define oh no I I I it I didn't I
00:55:01
didn't accept the type either oh oh okay it's gonna redo what he did and now you can all right there it is there we go there last so it should do the normal
00:55:25
slider and number value trick and you can add a a button easily give it a name and close request is one of those things
00:55:54
that already knows how to do so I don't have to write any code now uh internally we make a lot of use of uh sort of active values we call
00:56:09
Value models and we have a theory that the widgets want to talk a simple uniform protocol to things that just know value in value colon and application models tend to want to
00:56:24
have a lot of state so we sort of objectified the state as value holders and if the application is interested in finding out that the value change that
00:56:36
can register in interest in in that so we we can write a little application code say what you're typing okay I'm going to create an initialize method to hook up
00:57:05
the registration of the interest um so there's basically a declarative language in here for how you declare the dependencies and link up things some of them are automated and some of them you
00:57:50
write so part of that language is to say when things change what to do so you say what changed and then you say what message will be received and then you just do it so what he's doing is saying
00:58:02
on whenever the aspect changes come to this method and do something and what it's going to do is print in in a little transcript window so now he's going to what's behind all visual works is still
00:58:15
object works and there's a little transcript window that he's going to print in so um just open it up and every time he moves it around you see the numbers printing in the transcript at the same time so it's
00:58:27
pretty I wanted a carriage return in there can you give a demo you know so of course true to small talk he's making changes to the code while it while the application is running so you saw him
00:58:46
one do the switch Yeah so there's actually three things one of them was just quick and dirty and there's a notion here of value value models which is if you're going to hook together two arbitrary things then they're just not
00:59:00
always going to know about each other so what's being generated here are communication channels and standard communication channels send messages give me your value and take this value but there's all kinds of adapters in
00:59:12
here much like you would adapt into the wall for various aspects for agreeing on changes in protocol changes in number of numerical ranges and and changes based
00:59:24
on computation the second technical thing to show you is how this visual reuse propagation works so um what I'm going to do is clean this up take out what he has
00:59:35
and um I can leave most of this sitting here and I'm going to build four applications very quickly the first application and and I basically don't use the pop-up menu so I think I'll be okay I'm going to open up the property
00:59:48
tool and let it sit here and give a property to this window I'm going to call it the original I see you can hardly see as part of the problem and then just apply that so it so I can remember which one is which and then I'm
01:00:03
going to drop on here just the button and on this um this button then I'm going to set its property and its property is going to be that I'm going to ask for to calculate
01:00:15
something calculate for the label and the action will be due calculator I'm just making this up um we can name any of the components now one of the things is we can't show you
01:00:29
all of the capabilities of visual works but visual works of course is written in visual works so all the things you're seeing were the window canvas changes the sub canvases where things become visible and invisible where there's um
01:00:42
things being enabled like these buttons down here and disabled all that is programmable so almost anything we can do um that you can see in anything we can do visually you can also have a programming interface too so I'm
01:00:55
basically going to just have that one action button here and I'm going to install that and the class I'm going to give this class the name original
01:01:07
now I'm going to learn to stealth original and um and I'm going to make it a subclass of the application model so it defaults to all that capability and I'm going to store the specification
01:01:20
in a canvas call Window spec which is the default and I'm happy with that and now what I want to do is ask do I have to Define anything and it says no you don't need to do that but I for the application as a whole I needed to find
01:01:32
something it's not expensive we're still in your it still thinks that David does it still think it's the old guy [Music] um I did the same thing you did because I
01:01:49
can't talk and drive at the same time oh you're right I didn't do it I was busy talking to you calculate do calculator and then say accept right I should have known because I couldn't
01:02:07
see it right all right so we'll we'll close that out and now I will install it again because I've changed the user interface I've changed this image now I'm going to ask is there anything to Define and it says yeah there's something
01:02:20
called do calculator so I say okay do it for me so it's defined it of course it's defined it to do nothing so that if I open it up it's going to sit there doing nothing now what I wanted to do is actually to um to open up some
01:02:34
application that was there before so this is the first level reuse and there's a whole bunch of um I can filter example classes sitting around and one of them is this calculator example I think there's also
01:02:45
a mortgage calculator MO are no you don't have one here you have a loan calculator so I'll use this guy so I'm going to have this guy when I say start him up what I see is what you'd expect a typical little calculator that
01:02:59
nine and if we're real lucky 9 times 6 will equal 54. usually Small Talk Works if it can do arithmetic um so we're going to use this calculator example so I'm now going to go back to
01:03:13
um to here and ask to browse and it will show me the class it's defined and its actions in the calculator instead of doing nothing I'm going to ask it to bring up that calculator example and part of that protocol is simply to say
01:03:26
open except that and close this window and come back now to the running application which now opens the calculator so as you'd expect so that's going to be
01:03:39
our first one and that that's going to provide us with something that we're going to reuse so let me put this aside up here so we can remember what the original is and go get another canvas
01:03:50
it's such a teeny screen it's amazing okay so now what we're going to do is we're each time we do it we're going to take a canvas and we're going to put in a sub canvas so here's this sub canvas and now I'm going to come and get my
01:04:03
property sheet and I um I like to do it out of the properties here and the property for the sump canvas is going to be that I want to use original and I want Originals window spec so I
01:04:18
said there were three things you reuse one is the external characteristics so we're going to start out using just the external characteristics and um let me open this window up a little bit so I get some
01:04:30
layout help and um I think the other thing I want to do is put on that sub canvas just for for show a horizontal scroll bar just so we can see some differences and things going on
01:04:44
um or maybe I'll make it a little smaller and then that will cause us to be able to scroll through it all right and then then I want to set the properties for the window and I'm going to call this one first as in the first
01:04:57
reuser okay we'll apply that and and then close this down and then we're going to install it and
01:05:11
this one is going to be called first same window spec that's fine application models fine and and we're done so I can see if I need to Define anything
01:05:23
and it says yeah you have to Define do calculator because you didn't inherit anything all you asked for was the visual interface so I say okay Define it but I'm not going to have it do anything so I'm just going to open it up because
01:05:35
my point here is just to see it and there is the um the working reuse but of course if I hit calculate it doesn't do anything because I've defined it to do to be blank okay but that's enough to show my point when I go and change
01:05:47
original the issue is what happens to first so that's the first one now let's get another canvas do the same thing again make a sub canvas I've noticed something that's interesting if I put this guy in the
01:06:02
upper left corner I'll have better layout so I'm going to make that change to the original and install it and just say okay so now um I'm going to this one and I'm
01:06:15
going to uh I'm going to put a canvas in here and then I'm going to go get my properties sheet again yeah I always like this one because it reminds me when I'm talking I have trouble doing this and now I'm going to
01:06:34
go for original again and I'm going to say it's the window spec but now I'm going to say that there's a client and I'm going to call the client um org or Ridge that's going to be good enough
01:06:48
and basically by saying that I want so there he is but by saying that there's a client name I'm saying I want what's in here to be an instance of the class original whose name will be or Ridge and
01:07:00
that way I'm delegating responsibility so let me give a name to the label to the window as well and that way we can keep track of it and we'll be real clever and we'll call it second
01:07:12
and we'll apply that so that one has a label and I'll close it and so now we'll install that and again this time we'll call it second we're almost done window spec is again I'll
01:07:24
just use the defaults defaults are fine okay okay so for those of you who are object-oriented folks you have to start thinking when I change the original what's going to happen to all these guys because we're going to test you now do I
01:07:37
need to Define anything the answer is or Ridge so I say okay do that for me it's struck constructing everything I need so I can just say open now there's second and I can ask for the
01:07:49
calculator and it worked just fine right let's make um one change to Second let's put a menu bar at the top all right so let's go back and let's um get the property tool up
01:08:02
and let's say that I want a menu bar at the top and I'm just going to apply it and now we'll close that down now I need a special tool tool that lets me build menus so I have a menu editor
01:08:15
and it's a little bit of a text editor we've encouraged Dave to think he can do better than this so what we're going to do is say here's some actions the action is going to be calculate um
01:08:29
print maybe we'll have something called show we'll show hello we'll show by I'm just making things up right we want to have the same one do calculate chore
01:08:42
these are the actions they'll happen so um David that's not right it's just calculate let me do it don't confuse me right I'm going to build this so here's
01:08:56
what the menu is going to look like it's either going to say calculator print it's going to show show hello goodbye or I could have a menu button that Cascades things as well so I get to rehearse what that looks like I say looks cool do it
01:09:08
put it in second I have to give it a name we'll call it the menu bar okay and then um I can call it anything and there it is and I can come back over here and rehearse it and make sure I like what it
01:09:21
looks like that looks fine to me so I go fine let's just put this away and [Music] um and now I'm going to install that and I'm going to call that seconds
01:09:36
window spec and so we're done with that one so now if I say do I have to Define anything more um it says I say no no I've already done that so let's let's get out of there and now if I go browse and go look what's
01:09:50
here I'll see that I have um an implementation for what it takes to do the instance um but I have no actions and if I go and I open this up calculate works but nothing here works
01:10:06
for example if I try to say hello nothing will happen now I'm not given it any actions associated with the menu bar so let me go back let me just go close all these things up this is a very small screen and the smaller it is the better
01:10:19
off we have to keep it as clean as possible so I'm going to go back to that menu editor and I'm going to go load the menu the menus from second
01:10:34
which is menu bar it's one I want let me see that again now actually the format is to put the actions in like do calculator um show something I'm just making things
01:10:46
up say hello have to learn to type and say goodbye say bye so I'll build it again so what I'm doing is saying for for anything that's there there's a message that will be sent to have to happen and I'll apply that
01:11:02
and I'll leave it in menu bar because I could have done something else and um and I'm done and close it up now there's a bunch of messages that if I teach second to understand
01:11:16
which I'll add add actions and so I'm going to teach you how to say hello which is just going to put into the transcript I'm going to say show um hello from second so this is going to
01:11:33
be a good test for us to figure out whether we know where the show message is going to come from as I start making changes so now let me open up second and calculate of course is still
01:11:44
delegated and works fine if I said the rest of them won't work but if I say hello oh let me show you what's going on down there bring it up it says hello from second like David I forgot to put Carriage returns in but if
01:11:58
I keep doing it it will just keep spreading say hello hello hello from okay so now that works okay so now let's do one more and then we'll change the original
01:12:10
I said that you want to reuse the external characteristics you want to reuse the functionality delegate to existing things but I also said you want to be able to inherit genetically so this guy is going to have a sub canvas
01:12:26
in this sub canvas is going to be the same thing we had before property tools and um it's going to come from original
01:12:39
it's going to come from the window spec but it's not going to be an instance so that's going to be fine I'm going to apply that and then I'm going to go the window and give it the clever name of third and I'm going to apply that
01:12:54
and then I'm going to add one more button which is going to be the hello button so we're going to have this hello button and that action is going to be um hello
01:13:06
the action is going to be say hello so we have the same one and we'll apply that okay and um and so now we're going to install that as third and now I'm going to do something
01:13:23
different instead of saying I want to be a subclass of application model I'm going to say that I'm going to be a subclass of original so now I'm inheriting the genetics I'll say okay and I asked I asked now 4 3 is there
01:13:39
anything I have to Define and it says I have to Define do calculator and say hello now say hello makes sense since that's the new action but I thought we inherited a do calculator everyone understand why it
01:13:53
shows up as something to Define how many of you think you know but I know some small talkers here okay you can override an inherited message so it's giving me the opportunity to do that but I don't want that to happen so I'll turn it off and
01:14:05
we'll just go for say hello and then what I'm going to do for the um just this one button I'm going to ask to browse to its method and I'm going to say that what's going to happen is transcript
01:14:18
show hello from third okay carriage return right I heard somebody thinking whether I was going to do it or not
01:14:29
all right so we got that one done and I should be able to open it now calculate's gonna work sure that was inherited hello is going to work where's our transcript let me get it in top so you
01:14:43
can see I'm going to clear it oops wrong button until everything so it's clear and come here and hit the low button everything's too big
01:14:54
there there's hello from third right okay we got them all working now now I'm going to go back and change the original so now you all now now comes the test um I'm going to make a change here I'm just
01:15:08
going to what I'm going to do is I'm going to add a button and the button I'm going to add is going to um be the hello button that's one thing I'm going to do the
01:15:19
other thing I'm going to do is is show you one more tool so let me I'll use this the actual the label is going to be hello the action is going to be say hello and we'll apply that then I'm going to
01:15:31
get a pretty tools for you see there's a bunch of positioning tools I can make any widget relative to any other widget relative to the edges or fixed in space or I can get the coloring tool and color things and these are what we call read
01:15:44
apply tools so it's actually reading what's here and seeing its color and then I can choose to apply it so I'm going to make it a Motley green does it show up Lee grania and then apply that to the hello and then I'm going to turn
01:15:57
off the read go to calculate keep that green and apply it and that way they both get to be the same color I can say no I don't want to do that make it yellow all right we'll change it so we get some just some coloring so you see the tool that's there
01:16:10
okay and I'll install that change to original in the same Canvas OR we won't get the inheritance all right so now of course something has to be defined here
01:16:23
um I would have I have the button selected I want the whole thing selected it wants to Define do calculator I'm happy with we just have to Define say hello
01:16:33
now I'm going to browse to it now when I browse to something it will show me in the hierarchy where else things are and that will help me because then I can just copy it and I won't forget I have these buttons
01:16:49
um I won't forget to do that what's happening with the buttons in me is that I've been using a Mac and I've been completely tainted by Larry Kessler's idea of one button and so my fingers are having problems second
01:17:06
oh excuse me this is original and we'll we'll be cheating if I don't get it right huh thank you guys all right so we fixed that now let's see if it works if I open up the original
01:17:20
there he is hello let's make it pretty so I can see it on the screen I'm going to shut down this guy we don't need him anymore and we don't need him anymore so that'll be fine and um see we don't need him anymore so get
01:17:33
some room here all right we're going to clear this so for the big test cancel all right hello from original works fine all right now let's go look and see what the other guys do here's our finder I'm going to
01:17:45
filter the finer to look at user classes or make it easier for me to find um what I've done and I want first there's first so I'm going to start them up okay so here he is the color change now
01:17:59
the buttons in there and of course what's going to happen can't possibly work right you're going to get an error because all we inherited with first was the external face all right we could have done that with a cut
01:18:10
and paste so we could have just done it so we in here if I cut and pasted I cloned it I wouldn't have seen the color change in the button change of course um this is the one that has the nice scroll bar and and that we can scroll around in
01:18:22
it so that's first we'll put him over here now let's go get second s e um these are our list widgets and they allow you to do some searching so here's
01:18:34
second now second was delegating right so um if second's delegating whatever he knows how to do it does and it's coming from original right however here's hello and it's coming from second so everybody
01:18:48
knows the right thing to do all right so that's that was a decision about how the change should propagate now let's go get um third okay now start that one here's third
01:19:04
um and we have both of them again now what's going to happen when I push the green hello what's going to happen foreign Danny from original and third of course because it's
01:19:24
overwritten he knows that he knows say hello just because we implemented it here I was full people because I did the subclass before I did the super class all right so I did it the other way around right sorry I've done this all the time okay
01:19:37
um the issue here is to do some planning on the propagation of change and then you get to test your class and see if Danny was just teasing all of you um there's one more thing that's interesting that we've done which is not part of the product yet but given a lot
01:19:49
of language designers and UI designers here I thought you'd find interesting so David's going to show you one of our goals here is that we we're really moving into the 4gl market and the 4gl
01:20:01
marketplace surprisingly we'll start with these little systems and then they'll start the language be defined like this very simple declarative languages and then they kind of get bigger and bigger and bigger so it's interesting to watch those manuals grow
01:20:13
but um what you want to be able to do is program declaratively say do this do this do that and that's what we do graphically we do it visually we do it programmatically but we want to be able to
01:20:25
um wire together the relationships between all kinds of parts of an information model declaratively and of course to do that you have to do it with constraint language so our value models allowed us to build a very simple
01:20:38
constraint language as an aspect of that so we're going to take five minutes to do that and then we'll be done okay this is the classic Fahrenheit to Centigrade example where
01:20:51
the only interesting numbers are 32 0 and minus 40. I think that's all the Fahrenheit disintegrated examples good
01:21:08
for now the code for this when when you get into uh programming uh active values that communicate by way of
01:21:23
dependency it's easy to get into a situation where you get into dependency Loops or you have to write two different versions of the code depending on what it is that's changing and make sure that
01:21:37
you don't start looping so you have to test the other guy's value before you assign into it to stop it so and playing around with constraints what you really want to play around with
01:21:53
Fahrenheit disintegrate you just want to write a little bit of algebra which is sort of the definition of the relationship between Fahrenheit and centigrade and notice the object C is a
01:22:06
number holder and this is a I think this is sort of a low-tech kind of constraint it works with simple algebra it doesn't uh it doesn't do simultaneous equations
01:22:22
but since uh messages to an object uh can can be dealt with appropriately messages arithmetic messages to constraint
01:22:35
objects uh create other constraint objects and messages to numbers that don't take numbers as arguments fail the Primitive and do double
01:22:47
dispatching saying all right uh I'm an integer and you said you wanted to multiply you better know what to do so the constraint object response to that
01:22:58
is to build a right-handed constraint as opposed to a left-handed one which will propagate it one way or another so basically this is the entire uh Fahrenheit disintegrate
01:23:11
application is just that definition and a typical 4gl programmer can write that whereas what what you'd have to write otherwise were all the conversion routines going back and forth and
01:23:23
structuring all the messages and there's just no way they're going to keep track of all of that oh I'm sorry a fourth generation languages for geo yeah playing around with examples are focus
01:23:42
and progress and natural yeah so it's the angle conversions and the only object that gets created here in
01:23:55
this case is an angle that's a number holder and then when the Machinery that hooks up the specification object to the
01:24:07
application it it asks it for a binding to be resolved uh Radiance just sends radians to this number object which doesn't compute radians but it creates something that
01:24:21
will when asked for its value and signs you know just works on radians and let's see there's one last one not that one hello yeah got to remember what I
01:24:42
call constraint move anybody want to borrow money so I can borrow that and say eek I can't pay that go back the other way and
01:25:04
the code basically uh just says these are these are the uh number objects that I want it's a little bit bigger make it a little bit bigger yeah these
01:25:21
little displays okay so the uh constraint that's being created is this this formula that came out of a book now I added some syntactic sugar uh to this
01:25:34
pretty quickly so I could make uh these things these statements that look like arithmetic but it's really constructing constraints uh stand out because I think it would be unfortunate to never be able to trust
01:25:49
simple arithmetic you know looking at arithmetic uh not knowing whether it was actually doing arithmetic or making some kind of constraint thing so in the long run I think we'll actually
01:26:00
come up with a constraint browser that lets you write constraint code sort of where we're going right so this is sort of we're going to start adding a declarative layer to small talks so that
01:26:14
people who can copy formulas out of books and the kind of applications we've been showing you are really what most people build when they're doing a lot of these really simple access the database put things on the screen type stuff and
01:26:26
we're trying to make them do that quickly so that's what we wanted to show you today and sorry it ran so late it's 5 30 already but if you have an urgent question please ask it now that that would be one state
01:26:38
ments sure if you want to turn off the tape it's easier to answer the questions thank you [Applause]
End of transcript