Live Demo of Ada's Distribution Features
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 490 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/47038 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FOSDEM 202018 / 490
4
7
9
10
14
15
16
25
26
29
31
33
34
35
37
40
41
42
43
45
46
47
50
51
52
53
54
58
60
64
65
66
67
70
71
72
74
75
76
77
78
82
83
84
86
89
90
93
94
95
96
98
100
101
105
106
109
110
116
118
123
124
130
135
137
141
142
144
146
151
154
157
159
164
166
167
169
172
174
178
182
184
185
186
187
189
190
191
192
193
194
195
200
202
203
204
205
206
207
208
211
212
214
218
222
225
228
230
232
233
235
236
240
242
244
249
250
251
253
254
258
261
262
266
267
268
271
273
274
275
278
280
281
282
283
284
285
286
288
289
290
291
293
295
296
297
298
301
302
303
305
306
307
310
311
315
317
318
319
328
333
350
353
354
356
359
360
361
370
372
373
374
375
379
380
381
383
385
386
387
388
391
393
394
395
397
398
399
401
409
410
411
414
420
421
422
423
424
425
427
429
430
434
438
439
444
449
450
454
457
458
459
460
461
464
465
466
468
469
470
471
472
480
484
486
487
489
490
00:00
Computer programComputer programmingComputer animation
00:38
Representation (politics)Operations researchComputer programmingSystem programmingImplementationFreewareProgrammer (hardware)Read-only memoryComputer programIndependence (probability theory)Computer networkInterface (computing)Partition (number theory)Plane (geometry)WhiteboardCoprocessorLocal area networkComputerPhysical systemDistribution (mathematics)Regular graphComputer programPartition (number theory)Representation (politics)Position operatorNumberSet (mathematics)Stress (mechanics)Table (information)Context awarenessLevel (video gaming)Thread (computing)Process (computing)Goodness of fitPointer (computer programming)Morley's categoricity theoremMachine visionSemiconductor memoryDegree (graph theory)AdditionAddress spaceImplementationTask (computing)Model theoryRemote procedure callPiForestSlide rulePrice indexMultiplication signObject (grammar)Natural numberCompilation albumProcedural programmingCategory of beingType theoryFlow separationCodeChainPlastikkarteNeuroinformatikDifferent (Kate Ryan album)CompilerVirtual machineWhiteboardPattern languageComputer hardwareLocal area networkExecution unitPhysical systemFormal languageComputer fileMappingBefehlsprozessorOcean currentCoprocessorSingle-precision floating-point formatReal numberSoftwareJava appletDistribution (mathematics)ConcentricShared memoryIP addressClassical physicsLocal ring1 (number)AreaSystem callComputer animation
08:12
Representation (politics)Distribution (mathematics)Regular graphIndependence (probability theory)Type theoryOperations researchSystem callSemantics (computer science)Pointer (computer programming)Exception handlingClient (computing)Distribution (mathematics)Remote procedure callServer (computing)Object (grammar)CompilerData transmissionFunction (mathematics)Mechanism designNormal (geometry)Category of beingError messageCodierung <Programmierung>PasswordEncryptionPhysical systemCartesian coordinate systemSocial classPointer (computer programming)Object (grammar)Partition (number theory)CodeServer (computing)ConsistencyDisk read-and-write headRepresentation (politics)Type theoryTerm (mathematics)Virtual machineConfiguration spaceComputer programStreaming mediaInterface (computing)CompilerPasswordGoodness of fitSemantics (computer science)System callException handlingRemote procedure callDistribution (mathematics)SoftwareNeuroinformatikSharewareData typeMathematicsMultiplication signDifferent (Kate Ryan album)Level (video gaming)QuicksortTransformation (genetics)Dependent and independent variablesSpeech synthesisTwitterFamilyUtility softwareDatabaseVideo gameHypermediaQueue (abstract data type)Table (information)Game theoryShared memoryInheritance (object-oriented programming)Software protection dongleCausalityDemosceneComputer animation
15:34
Distribution (mathematics)Expected valueLetterpress printingMultiplication signComputer programVideo game consoleClient (computing)TorusDifferent (Kate Ryan album)Right angleTerm (mathematics)MathematicsMessage passingMoment (mathematics)Category of beingComa BerenicesNumberCASE <Informatik>System callInterface (computing)Function (mathematics)Remote procedure callMorley's categoricity theoremServer (computing)BitCountingComputer animationLecture/Conference
17:57
Video game consolePoint (geometry)NumberClient (computing)Message passingProgrammschleifeTorus2 (number)Term (mathematics)Partition (number theory)Letterpress printingMoment (mathematics)Computer animation
18:33
Hand fanServer (computing)Client (computing)WindowInterface (computing)MiddlewarePartition (number theory)Physical systemMessage passingSharewareLevel (video gaming)Remote procedure callMultiplication signSystem callCountingDirectory serviceBitLetterpress printingCompilerStructural loadConfiguration spaceVirtual machineComputer fileMathematicsCompilerVideo game consoleGastropod shellInternetworkingDistribution (mathematics)Execution unitData storage deviceResultantFreewareComputer clusterBoiling pointArithmetic meanProcedural programmingScripting languageSingle-precision floating-point formatTerm (mathematics)DemosceneKey (cryptography)HypermediaPublic domainComputer animation
26:12
CompilerPhysical systemMessage passingConfiguration spaceVirtual machineComputer programServer (computing)Partition (number theory)MereologyLine (geometry)Letterpress printingStructural loadComputer fileTorusHeegaard splittingDistribution (mathematics)Scalable Coherent InterfaceArithmetic meanChainFigurate numberSoftwareComputer clusterComputer animation
27:56
Directory servicePhysical systemComputer fileNumberCompilerEnterprise architectureCoordinate systemComputer animation
29:00
WritingDistribution (mathematics)Musical ensembleReading (process)AbstractionInstance (computer science)Tape driveLaceData bufferNeuroinformatikServer (computing)Type theoryArithmetic meanBit rateSoftwareCategory of beingState of matterSound effectInstance (computer science)Computer-assisted translationPointer (computer programming)Tape driveRemote procedure callSystem callInterface (computing)Object (grammar)ImplementationDegree (graph theory)Table (information)Computer clusterNetwork topologyClient (computing)Distribution (mathematics)Computer programProjective planeDevice driverPoint (geometry)Level (video gaming)CrosswindExtreme programmingProcedural programmingWordAreaSharewareWritingBitConfiguration spaceRegular graphMorley's categoricity theorem.NET FrameworkComputer animation
33:49
Goodness of fitBitModal logicMultiplication signHypermediaAirfoilComputer animationLecture/Conference
34:48
NeuroinformatikPartition (number theory)HypermediaWindowIntegrated development environmentAreaLine (geometry)AirfoilTorusSoftwareBitMiddlewareFirewall (computing)SharewareBootingOffice suiteString (computer science)Near-ringVirtuelles privates NetzwerkComputer animation
36:34
IP addressPartition (number theory)Core dumpObject (grammar)MetreGoodness of fitMultiplication signHypermediaRule of inferenceCoefficient of determinationThermal expansionSoftwareKey (cryptography)PreconditionerCompilerImplementationTransportation theory (mathematics)TelecommunicationWordDistribution (mathematics)Computer simulationDifferent (Kate Ryan album)Communications protocolView (database)FreewareSystem callException handlingPhysical systemComputer networkMiddlewareInterface (computing)Server (computing)Right angleTranslation (relic)
40:32
Formal languageShared memoryObject (grammar)Computer clusterCartesian coordinate systemComputer animation
41:19
Heegaard splittingFlow separationComputer programType theorySingle-precision floating-point formatPartition (number theory)Cartesian coordinate systemRepresentation (politics)Different (Kate Ryan album)Object (grammar)Core dump
42:11
Point cloudFacebookOpen source
Transcript: English(auto-generated)
00:05
Okay, so our next speaker is, once again, myself, Jean-Pierre Rosin, about distributed
00:54
programming. So, this was announced as a live demo, which is always frightening because you never know
01:02
if it will work. So I'll try to go relatively fast on the slides, then we'll make the demo, and if we have some spare time, I'll show you another example, or maybe we can just come back to some of what I said.
01:20
So, this is defined in the reference manual in an annex, in the distributed systems annex. So it means that it's not required from every compiler to implement that. In practice, only Gmat did implement that, and I'm a bit sorry about that because it's
01:40
a real nice feature of Ada, and it would be nice if we had other compilers to implement it. So, to understand what it means, it's about having one program distributed over several machines. You know, distributed systems that work well with several, in general, executions
02:06
concurrently may have different levels of coupling. You have tasking, when it's inside a single program with shared memory. Then you have the distributed systems annex, where it is a single program which is split
02:25
over several computers, okay? And then you may have different programs communicating over the network. So here, it's a single program, so we'll see it keeps all strong typing and all the
02:43
checks that you can have, but still running on several machines. And the goal of the annex is to make the programmer concentrate on the problem and be freed from all the nasty details of networking, communication, differences in representation,
03:03
and all those programs that plague distributed programs. So an Ada program is made of several partitions. So, it's a very abstract definition, but to be honest, it's several executables, okay?
03:21
You have several executables. You run them together, and together they build the whole program. You have active partitions that can run any program, also passive partitions that can contain code and data, but no task, nothing that's active.
03:44
You can even have several main programs. The language requires only at least one main program in one of the partitions, but you may have several main programs, including one in each partition.
04:01
So this maps to different patterns. For example, if you imagine hardware boards plugged in a backplane, so an active partition will be a processor board with a CPU and whatever, but a passive partition will be a
04:22
memory board. You can have RAM for variables, RAM where you have the code of your subprograms, but nothing that can run directly on the board. On a local area network, while it's a classical stuff with computers, you may wonder how
04:40
you could make passive partitions. Actually, Ignat manages to be able to have passive partitions. Each variable is modeled as a file over NFS. Not very efficient, but it works, and it provides you with persistence by the same token, so it can be quite interesting if you don't abuse it.
05:05
And even at the level of an operating system, while you could view the active partition as the process level, tasking is about the threads level, and that would be about the process level, and for example, a set of subprograms that is shared between several
05:25
executables, that would map to a DLL. So I'm not saying that the current Ignat implementation does all that, but I want just to stress that the model is not linked to a particular model.
05:42
It has always been intended to be implementable in several contexts. What I mean is if you take, for example, Java's remote method invocation, you designate a remote object through its IP address.
06:01
So it's purely internet, there's nothing else you can do with it. Here it has been carefully made independent of any particular network. So of course, not all data can circulate on a network.
06:23
A task, a pointer would be hard to, if you exchange them, that would not be possible or it would be meaningless. So you need to have some restrictions. So the idea is you have a number of aspects that define how a package will behave regarding
06:45
distribution. I won't go into too many details, but just to mention, you have a regular package that has no categorization. These are called categorization aspects.
07:01
Without categorization, the packages are duplicated, so they are independent. If you have a variable in a package in a partition, that variable is not related to the same variable, while with the same name, in another partition. Your shared-passive packages are used to manage the data that's directly shared, so
07:27
it's a common memory between the different partitions. Remote types allow the definition of types that can be exchanged between the partitions.
07:41
And remote call packages are the most interesting ones, the ones that can make RPCs, RCP, remote procedure calls, where you can, from a node, from a partition, call something that physically resides in another partition.
08:04
And for each kind of categorization, of course, there are a number of restrictions about what you can do. Those restrictions are very complicated. You don't need to understand how it works. You put the categorization, you compile, and the compiler will tell you what's allowed
08:22
and what's not allowed. In Ada, we trust the compiler, you know? And since all the consistency of the program is guaranteed at program level, it means that all the data representations are guaranteed to be consistent over all the partitions.
08:48
So you get a remote call. When you call a subprogram that's something in another partition, directly by calling what is called a remote subprogram, so a subprogram with the aspect remote call interface,
09:07
so classical RPC, of course, you have to know the name of the package. If you call a subprogram, you have to know the name of the package. So in terms of distribution, it means you know the server.
09:22
You have a certain special kind of pointer that allows you to designate a subprogram in another package. So it's a typical callback where you can call back a subprogram through a pointer in
09:41
another partition. But then you have to get the pointer from somewhere, so you have to have some kind of name server that will provide you with the pointer to the subprogram being called.
10:01
And you can also have remote objects, the famous remote access to class Y types. So basically you can have a pointer to an object in the sense of a tag type, and you can invoke methods of objects that are located in a remote node.
10:27
So you can have distributed objects and directly call the methods of the object. Once again, since you need to first get the pointer to the object, then you need some
10:40
name server. And the whole semantics of Ada is preserved. So if a remote call raises an exception, you'll get the exception. All typing are checks to be consistent, and so on. So distribution is completely transparent, at least for the client, for the caller.
11:09
When you transmit data over the network, the interface is designed in such a way that it uses the streams mechanism. In Ada we have streams inspired, without any shame, from C++ streams, and you have standard
11:29
streams provided by the compiler, and you can redefine the streams. So the marshaling operation, transforming your high-level data type into a stream of
11:42
bytes, is performed automatically by the compiler using the stream that you can redefine. So for example, if you have a type name, for example, password, you can redefine a marshaling function so that this type is always scripted, and that your own
12:04
redefinition will be used by the compiler, and therefore you are guaranteed that never to have a clear password over the network. So it means that strong typing is totally preserved.
12:22
You don't send bytes. You send, you exchange, through the normal mechanism, high-level data. So how would you write, in general, a distributed application? First of all, very important, you don't care about distribution.
12:44
It's very tempting when you know that you have something that will work on several computers to think first, oh, what am I going to put on that computer and that? If you do that, any change will require a total redesign of your application, and it
13:02
will be extremely costly. Now, the best way to design a distributed application is first to design your program on your own machine. It works, and you debug it, and you design it as a regular application.
13:21
Then you categorize. You look at what you've done. You said, well, these are some casual utilities, I don't need anything special. Here I have a centralized database, so it must be shared if it's ever distributed.
13:42
Here are the types that are used to exchange data with that database, and so on. So you just drop those little aspects on your code. You recompile, and you bow your head because, in general, there will be some restriction
14:01
that's not obeyed, so you need to change things here or there to make sure that it corresponds to your intent. That's quite often, for example, you take off some type definition from a package to make a special remote types package or some changes like that.
14:22
Then you decide on the distribution. You decide that you will make three partitions, and, well, the only shared package are the remote call interface packages and, of course, the shared passive. So these are to be attached to some explicit partitions.
14:46
This is done thanks to a configuration file, and I'll give you an example shortly. Okay? You recompile, the compiler will care about everything, and you will get as many
15:03
executables as you have defined partitions, and then it's up to you to start your partitions where you want, maybe on the same computer, maybe on a different computer. Okay? So that looks like a miracle.
15:20
Are there some people who ever wrote distributed applications here? Yeah. Okay, good. So you appreciate the demo. Okay. I'll turn now to this.
15:43
Okay, it's a very simple program, and here I just have all the printing is done through that console package. So console, can you read it or it's a bit too small?
16:02
Okay, sorry. Okay, that's better. So it's just a package, and we print by, for the moment, it's a regular package, no categorization.
16:22
Okay? Then I have a server. This is a remote call interface package. You see, there is a primary remote call interface.
16:43
And what it does, it registered clients. So when a client comes, it calls register. It keeps account of the number of registered clients. And when that count reaches the expected number, in that case three, then I have a function
17:04
must terminate that tells that now everybody has arrived. So I can show you quickly the body if you want. Come on. Okay, I'll do it this way.
17:24
So you see, I just have a global counter. But it's to show you that that counter must be shared between the different partitions, of course. And then the client, a very simple also, we'll see, ah, just not, okay.
18:05
So the client just registers, it prints a message by printing message, well, it keeps the time, and why not must terminate, why not everybody there, it loops saying it waits for a certain number of seconds, delays one second, and when terminate, must terminate
18:26
becomes true, it just prints that it's terminated, okay? So for the moment, the interesting point is the console that prints the message.
18:41
Now it's a regular package. It will be duplicated in each partition. So I prepared everything so we don't waste time, but believe me, I didn't cheat, so if you want me to recompile in front of you, I'll be happy to do it, okay? But we are not here to watch compilation time.
19:04
So if I start partition one, it should start shortening. Oh, I forgot to mention the server itself, the server package prints when a new client
19:20
arrives. So you have seen that. Can you see that? Excuse me? Oh, yes, sure. That's better. Okay, a bit small, but I think you can see, so it prints in its own window, and
19:48
I start the second partition, which is printing. You see the server print on the left, and here it prints on its own window, okay? If I start a third client, then everybody terminates, the count has been reached, and
20:08
everybody terminates, okay? Now let's have some fun. I change to another directory where I prepare the second step of the demo.
20:39
Okay, so now, oh, I forgot to show you something important, sorry, the configuration.
21:03
So this is the file that defines the distribution, the configuration. Here you see I just declared three partitions, and I have only one remote call interface package, the server, so I said that the partition one contains the server.
21:23
Client is my main procedure, and well, in that system there is a kind of main main procedure, you know? So this one is in partition one, and there is a secondary main in partition two and partition three.
21:41
That pragma starter here, because I need to start all this in three different windows, I start them by hand. But you can have the compiler generate automatically a starter that will run every partition in, you can tell on which machine and so on.
22:04
And the funny thing is that starter can be written either in Ada and automatically compiled or generated as a shell script. So if you want to see what happens, and that's generated automatically.
22:22
Okay, so we move to step two. What did I change here? Very few. I just added in my console pragma remote call interface.
22:44
I didn't change anything else, but now, in a sense, I have a printer server. Instead of each partition printing in its own domain, I have a shared printer server.
23:01
And at the level of the configuration, you see I just added console, since now it's a remote call interface package, it has to be assigned to a certain partition.
23:24
So I assign it to partition one, and the rest is the same. And then you recompile, and I start partition one.
23:41
There is a kind of middleware in behind. If I have some time, maybe I told you. For now, it seems like before, but if now I start partition two, all messages for partition two are printed in the same window, because that's the first window is where
24:03
the printer server resides. Okay, and of course, if I start my third partition, we'll see a new client, and then everybody terminates.
24:21
Okay, now imagine that I made some insufficient design about the load of my server, and that first server is really too heavily loaded. Okay, that happens quite often on distributed systems.
24:41
It's hard to foresee what the actual load will be. So I decide I'll put a fourth machine that will just hold the message server, the console. Fine, step three here.
25:26
I didn't change anything in the eta. I just changed the configuration file.
25:40
I define a fourth partition here where I put the console. Okay, that's all I did. I didn't change the software at all. Recompile.
26:01
Okay, it's here. So let's start partition one. Nothing happens. Of course, it's printing in partition two, in partition four. Okay, let's start it now. And you see all the messages are now moving to that dedicated partition for printing.
26:26
Okay, of course, if I now start partition three up, everybody terminates nicely. So this is just a small program to demonstrate it.
26:45
But think about it. I first started with no centralized server. Each part of the program used its own local server. Then I decided to have one centralized server to do everything.
27:04
I added one pragma, changed the configuration file, and recompiled. That's all I had to do. And then I decided to change the way the load is split on my different server. I had a new machine with a new server.
27:23
I changed one line in my configuration file. I didn't change my eta software, and I had my new configuration. Okay, so generally people who never had to cope with distributed systems find that very nice.
27:44
Those who had to cope with distributed systems are absolutely stunned by this, because all the hard work — yes, I have some spare minutes, I can show you something — is done by the compiler.
28:00
When you compile something with the distribution, you see here a little directory that appears with the name DSA. That means distributed systems architecture. And if you look at that, you'll see the partitions, and you'll see all the files.
28:26
You'll see a number of eta files here that are all automatically generated by the systems and compiled by the system that ensure the whole of the data transmission, the coordination, finding the name server,
28:43
and all those things that you need when you are doing a distributed system, all generated automatically. Okay, fine.
29:04
So, well, since we have some more — oh, we started. So now I'll show you another example how to make distributed objects.
29:25
So it's not a live demo because it would be a bit long today. Imagine you have a tips — well, nowadays, of course, you don't use tips anymore. But it could be any server. Do you?
29:40
Well, for archiving, well, when you see the amount of data you can put on a microSD card, it's very impressive. Anyway, so imagine I have one computer here, here, here, that manages tapes, okay? So first I define an abstract data type, tape,
30:04
with pure means it's another categorization package. That means that there is no side effect. And, well, the basic operation, rewind, read, and write. Okay.
30:22
If I want to access a distributed object, I mention that I need a name server. On a different partition, I have that name server here. So it's a remote call interface, so you know where it is.
30:42
And it defines a pointer to that tapes.instance tick class. So it's a class-wide type, a type that encloses all dissonance. And since it's a regular name server,
31:00
you register a pointer to a tape under a certain name. You can find from a name the pointer, the corresponding pointer, and you can unregister it if you want. Now you have an implementation of that object.
31:23
So a tape driver. And so you define your own tape if you want the driver, the concrete implementation of a tape drive, and so you redefine the procedure, rewind, read, and write.
31:42
By the way, the overriding keyword here makes sure that you are actually redefining a method and not due to some typo or anything else, defining something new. You declare two tape objects here,
32:02
and you register those tapes under a certain name to the name server. So you send to the remote name server a pointer that, through the network, designates your two tape drives.
32:25
And then the client, which is a normal program without any categorization, can declare two objects of that pointer. It will ask the name server to give the pointer
32:43
that through the network designates those tape drives, and use that as usual. Now, maybe you didn't notice that. But there is nothing in that example that refers to distribution
33:02
except some pragmas here or there. You just write it as a normal software, and then you write your configuration to tell which computer you want your tapes, on which computer you want the name server. And normally, you build your program by calling
33:30
netmake or gprbuild on your project file. All you have to do is call pognetdist on the configuration file,
33:43
and it will recompile everything, and that's all you need. Okay, oh, I've been even a bit earlier. We have five minutes for questions.
34:00
Wow, so impressed. Yes, please. Go ahead. Okay, well, there is, of course,
34:21
oh yes, so the question was about the communication, and the necessity of a firewall, and problems with firewalls, and so on. Of course, you need some middleware, and I was afraid of being a bit short in time, so I didn't put the slide,
34:42
but there is middleware that's provided. I won't cheat, I'll show you. Here, in that window, you have the middleware running, okay? And when the middleware starts, it gives you a magical string that's somewhere here.
35:08
Okay, polyorb, koba, name service, blah, blah, blah, blah, and you have to set some environment variable to that magical string so that you have to boot from something, from somewhere, of course.
35:22
Now, of course, that middleware must be accessible from your partitions. So, of course, if you have firewalls in the middle, actually, I intended to make the demo a bit more impressive
35:43
by having one of the partitions running on my computer at Isilé Mulino near Paris, okay? And through, of course, a VPN. But it happens that the Wi-Fi here, there is a firewall that does not let the VPNs.
36:07
Okay, so I had to make it local, okay? Normally, it would have been even better because, well, trust me, I'm sorry you've come to my office in Isilé Mulino. I can show you that it's exactly the same thing
36:22
if one of the partitions is running Linux inside of Windows, okay? It works exactly the same. But, of course, you don't get rid of all the problems inherent with networks. Other questions?
36:52
Okay, if it's not available when you start, you have an exception and the partition doesn't start.
37:01
If you lose it, well, actually, the middle, maybe the data core people could answer that better, but the middleware allows you to exchange the IP addresses of the various partitions. I'm not sure that it plays a role once it's completely started.
37:25
No, okay. Well, it's a very specialized domain, so you have two or three guys at IDACOR that know the answer and the others trust them. There is an exception that's intended for communication problems in the network interface.
37:50
Yes, I can mention that now. All communications have to go through a dedicated package called system.RCI, and the implementation of that package
38:08
is in charge of the transportation layer. And the standard makes it very explicit that you are allowed to provide your own implementation in that package.
38:21
It means that if your compiler supports that annex, and you have some proprietary networks, safety critical, whatever, then you just have to rewrite the body of that package to handle all the communication. But the compiler does not know about the transportation layer,
38:44
so you can use various networking solutions with that. Okay, something else, yeah?
39:06
No, no, it's special to the polyorb implementation. Oh yes, I was talking about that and I wondered somewhere else, but here the middleware I use is called polyorb.
39:21
It's something that's provided by IDACOR also, and it's called a schizophrenic middleware, because it has several personalities in the same person at the same time. So it is a middleware for the distributed system annex,
39:41
but at the same time, it's a COBA server and an MME or something like that server, some other protocol, and it allows the simultaneous views of the same object. So you can declare a distributed object in Ada as a tag type,
40:03
and from your C++ application, it will be viewed as a COBA class. Okay, so you can exchange data with different protocols and the middleware, that's the translation between the different views,
40:22
the different personalities of the middleware. Anything else? Okay, I think I'm right in time. Yeah, okay, with pleasure.
40:56
Now, in COBA, you declare the types,
41:02
and it's intended for different applications that communicate through shared objects, and you hope that the idea is the same on the various applications. Idea is the COBA language for defining the shared objects,
41:23
but there is no cross checks, for example, that the various applications use the same definition of your COBA object. In Ada, it's all compiled together with all the type controls that we are used to with Ada.
41:41
So there is a guarantee that the data representation and the objects will be the same in all your partitions, but it's a single program split over several partitions. With COBA, it's more a way of having different programs that communicate through objects. So there is a difference.
42:03
Okay, thank you for your attention.