FOSDEM 2009: Étoilé
This is a modal window.
Das Video konnte nicht geladen werden, da entweder ein Server- oder Netzwerkfehler auftrat oder das Format nicht unterstützt wird.
Formale Metadaten
| Titel |
| |
| Serientitel | ||
| Anzahl der Teile | 70 | |
| Autor | ||
| Lizenz | CC-Namensnennung 2.0 Belgien: Sie dürfen das Werk bzw. den Inhalt zu jedem legalen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen. | |
| Identifikatoren | 10.5446/39500 (DOI) | |
| Herausgeber | ||
| Erscheinungsjahr | ||
| Sprache |
Inhaltliche Metadaten
| Fachgebiet | ||
| Genre | ||
| Abstract |
|
FOSDEM 200967 / 70
3
4
6
16
17
18
19
20
21
22
23
24
25
26
27
29
30
31
32
33
35
40
41
44
46
47
48
50
51
54
55
57
58
59
60
62
65
67
68
69
70
00:00
QuadratzahlResultanteGesetz <Physik>Web SiteSichtenkonzeptQuaderTwitter <Softwareplattform>Prozess <Informatik>Zellularer AutomatEndliche ModelltheorieComputerspielWort <Informatik>BildschirmmaskeMailing-ListeRechter WinkelFlächeninhaltPhysikalische TheorieZusammenhängender GraphBitSchreib-Lese-KopfMultiplikationFormale SpracheSchnittmengeMessage-PassingProgrammbibliothekDifferenteRechenschieberFamilie <Mathematik>p-BlockAlgebraisch abgeschlossener KörperBefehl <Informatik>Objekt <Kategorie>Bildgebendes VerfahrenParametersystemGamecontrollerMereologieQuick-SortCompilerProgrammierungGeradeVersionsverwaltungDatenflussTypentheorieVererbungshierarchieBoolesche AlgebraImplementierungArithmetischer AusdruckDemoszene <Programmierung>Poisson-KlammerFontEinsMAPLoopTermJSONComputeranimationVorlesung/Konferenz
06:03
LoopRechenschieberImplementierungStreuungCodeEinfache GenauigkeitEin-AusgabeTypentheorieQuelle <Physik>Formale SpracheCloud ComputingSchreiben <Datenverarbeitung>Interface <Schaltung>MereologieObjekt <Kategorie>Workstation <Musikinstrument>Arithmetischer AusdruckMultiplikationsoperatorRechenbuchProgrammierungMessage-PassingMaßerweiterungVersionsverwaltungSichtenkonzeptPhysikalische TheorieGrundraumTopologieZahlenbereichWort <Informatik>DruckverlaufWeb SiteRechter WinkelOrientierung <Mathematik>ResultanteCASE <Informatik>FlächeninhaltSchnittmengeGruppenoperationParametersystemGeradeStabDialektComputeranimationVorlesung/Konferenz
11:54
AggregatzustandMultiplikationsoperatorProgrammierungSichtenkonzeptProzess <Informatik>VersionsverwaltungSchnittmengeObjekt <Kategorie>CodeGlobale OptimierungComputeranimationVorlesung/Konferenz
13:33
ProgrammbibliothekDivergente ReiheApp <Programm>EreignishorizontRechter WinkelGrundraumSoftwareSpieltheorieDatenstrukturKartesische KoordinatenObjekt <Kategorie>Endliche ModelltheorieMultiplikationsoperatorFaserbündelFormale SpracheCodeSkriptspracheSynchronisierungLaufzeitfehlerTotal <Mathematik>InformationInterpretiererBitRechenschieberFunktionalNabel <Mathematik>Vorlesung/Konferenz
21:00
MultiplikationsoperatorSpieltheorieStandardabweichungInhalt <Mathematik>Gesetz <Physik>SchnittmengeEreignishorizontPunktLesen <Datenverarbeitung>Divergente ReiheComputerspielMailboxRechter WinkelDatenstrukturFlächeninhaltKategorie <Mathematik>MusterspracheEnergiedichteQuick-SortObjekt <Kategorie>Wort <Informatik>Zellularer AutomatGrundraumSichtenkonzeptKontextbezogenes SystemFunktionalp-BlockKonditionszahlBefehl <Informatik>Ganze ZahlAusnahmebehandlungLaufzeitfehlerMessage-PassingZeiger <Informatik>MereologiePhysikalisches SystemVariableVorlesung/Konferenz
28:19
FunktionalMereologieRahmenproblemRechenwerkAusnahmebehandlungQuick-SortQuellcodeEndliche ModelltheorieKategorie <Mathematik>SoftwareHalbleiterspeicherElektronische PublikationZeiger <Informatik>Physikalisches SystemRechenschieberKlasse <Mathematik>CodeKonfiguration <Informatik>MetadatenLastAutomatische IndexierungPlug inTypentheorieKonditionszahlVersionsverwaltungFreewareSchnittmengeGüte der AnpassungRechter WinkelResultanteFormale SprachePhysikalische TheorieWellenpaketMultiplikationsoperatorFlächeninhaltAssoziativgesetzVorlesung/Konferenz
35:37
Virtuelle MaschineOrtsoperatorGrundraumVariableLaufzeitfehlerAbstrakte SyntaxKartesische KoordinatenKlasse <Mathematik>InstantiierungFront-End <Software>GradientKategorie <Mathematik>Prozess <Informatik>SkriptspracheMessage-PassingSchreiben <Datenverarbeitung>BrowserVorlesung/Konferenz
41:34
Güte der AnpassungElektronische PublikationResultanteMereologieBasis <Mathematik>Anwendungsspezifischer ProzessorFamilie <Mathematik>DialektProgrammierungVersionsverwaltungFormale SpracheDynamisches SystemVorlesung/KonferenzBesprechung/Interview
44:50
IndexberechnungInformationComputeranimation
Transkript: Englisch(automatisch erzeugt)
00:12
You can see me talking, but I can't hear anything then. Wait a minute, I'll try to read that. You can hear better. We hear, but not at the level of voice in the room.
00:27
Okay, well, I'll put my face right into the microphone. Hopefully now you can see a vague outline of what I'm going to talk about.
00:45
I'm going to start just by giving you a quick introduction to the small talk, which maybe some of you can see through, some of you will find interesting. And then I'll get on to what this talk is actually about, which is the pragmatics of small talk implementation that we have out of image 1.
01:02
So, if I can have the next slide. The small talk family dates back to around 1967, I guess, to the first initial thoughts on the subject. The final that I understand that was really worked out in the 1980s,
01:24
the language that, I guess, all produced that was developed as a preview with the first sense of language that was applied in the creation of the projective scene. Well, there are lots of other large examples of that that result
01:45
was a version of small talk that kept the same sort of syntax with the written classes, and it became very simple as a language. There was really nothing much that was mixed in the behavior of the language.
02:02
Everything else had to be added as part of the library. And CELF has one very popular descendant, which is JavaScript. JavaScript, there, it's mostly a language from CELF, but it adds, which you can come up with, and it's got the syntax on top of that. A few really important things that we've tried implementing JavaScript.
02:26
Some of the things, such as the patient, made you scratch their head on to what they were smoking. We'll move on to the next slide. So, in small talk, there are basically two main bits of syntax.
02:42
There's assignments, okay, so you have a variable on the left, and then someone's praying on the right. My guess is we're all going to be with a side-check when the parent's working with languages, and that's any ML program that's involved in things like
03:03
sending an object of C, which is not sort of a fun fact. So, the only difference is there are no square brackets, because the square brackets and objects of C are there to distinguish between C-like syntax and small talk syntax,
03:23
while in small talk, every word is in small talk-like syntax. So, you have three types of message. You read messages, and you adjust the message name between the arguments. Messages with one parameter, messages with multiple parameters,
03:41
which have this selector in between each of the components. And I guess no one's confused or surprised by this syntax, so if we can move on to the next slide. The flow control?
04:05
Yeah, it's just that we were on the flow control slide. Yeah, if statements while that was more than use,
04:22
all that helps now. And in small talk, there are no control statements on that message setting. All of this is implemented in terms of message setting.
04:40
So, if you want to have something that looks like an if statement, then you just have a Boolean object through statement, through message, and it's not given to that in a block or a closure. So, there's an example here on the slide between setting and false message,
05:00
and in bits and square brackets, there are block expressions. So, these are just another, these are all sort of straight intervals that you get, you'll get to see. They're just an object when the compiler runs,
05:21
and this object is a block of your parts, and it responds to a value message,
05:57
and then setting an if-through message to the result of the loop body.
06:03
So, this looks kind of like setting a value message
06:59
to the argument,
07:07
to do any kind of, is exactly as expressive.
07:49
You see, I guess, it's a language that most people in this room are familiar with. Yeah, that's what we're learning.
08:06
The fast enough spring of C in small talk. It's what you squish C and small talk together into a single C program as to learn, because it's basically half a dozen syntactic extensions
08:20
in which the program was to learn, and it's basically just a C-C type of scatter and then small talk structures,
08:43
which you're asked to adjust as the objective C was created
09:02
was the small talk calculator to fasten the workstations when the small talk was created. But it's still an advantage if you've got something that's processed faster,
09:25
it is possible to write code in objective C and it's possible that it's faster than the person's code. It's also possible to write really slow code and start a code on objective C using an interface with a Fibonacci set,
09:49
implementation in small talk, which uses a sensible loop based on objective C, which uses the naive branching, recursively calculating each sub-tree version.
10:03
And by the time you get to around the 20th look, now you should know that the E and the start and the T are all part of the thing that we've seen.
10:36
If that's done, then you get the C
11:18
and the three lines, small talk,
11:26
have this selector with the inputs on the slide and down, stop talking about small talk.
11:56
The objective is the ABI version
12:02
and it's absolutely run at that code. It's very simple. Co-generating is used for the message setting.
12:37
It has a few advantages. LLVM has a massive optimization
12:41
of the process, as is just in time.
14:07
You might want to write an interpretable runtime like in this, which I'll talk about why this talk is called
14:49
pragmatic small talk.
15:06
There's also a command line tool, ETLC, which is a dynamic language which is to run shell scripts
15:31
in three bundles, so you can put it in a double-tap bundle. It does a little bit of hacking
16:26
assuming that what you see and what I see have been kept in sync. This slide should be showing you exactly how big this is. So, the total amount of code
16:42
produced
18:48
functions in any language that has team information really easily at runtime
21:00
you can
21:01
actually start to find out exactly what. So, in small talk, everything parts objects are real.
21:38
This is basically an integer
22:02
function that compiles the generator calls to those functions in LLVM in light of them.
22:56
The unboxed activity for any message
23:28
is long time to happen.
25:23
The object itself, we allocate instead of an object, which someone might
25:44
want to retain, allocated to the stack. So, what happens if you pass a block and the receiver says, okay, I'm going to store that into this variable and stack the function that's
26:11
now going to take your object. So, that's kind of a broken message to the block object.
26:29
The last slide, the block itself is a statement, so all it does is to have a pointer to the context. The context is where all of the variables are stored. So, pass
26:47
the context, and the stack is changed. So, the block object is stored somewhere and when this node returns, the block context is promoted
27:01
onto the heap, and the node keeps working. So, the block is variable to be accessed on the stack. They're local, they're very large, so when you move them off the stack, you're set to retain the system. So, still, the block returns.
27:31
Like this, you have some garden floors where you have a condition This would be just like in Objective-C,
27:44
you'd say, if some condition returned true, then that's fine in Objective-C, because all of those statements are all set in context. But, it solves all of this. Return true statement and when these return true statement should return true.
28:08
The way we can do that is to have a new exception and a personality function, which is part of the GraphQL runtime. So, with the new zero-cost exception and the APIs that are appearing in most
28:21
units and access systems now, and they originally came in one place as well. We let you associate a personality function with every stack frame. This is just stored in the debugging metadata that's in there. This is called
28:43
by the unwise-on exception pointer. Unwise this stack for this frame, and if this exception should be handled by this frame, then that's all this new function
29:03
does. We just define a new type of exception, and it's only understood by a small-time code. Objective-C exceptions are used in small-time style exception handling, where we
29:21
send to the user. It's not exception to message, so it takes two arguments, the version and the exception, and logs the receiver,
29:41
then it loads the function So the downside of this model is that it's really slow, but the upside is that it's slowly slow when you actually use it, and most of those tend to use this random thing for the same sort of thing. You're using settings
30:01
or using the guard. This now wraps Objective-C
31:03
and it's all used in a single condition. We can use it for scripts, and
31:23
after cleaning, we recommend seeing each other on existing files
32:08
and those new methods to replace the existing memory. That's useful for Objective-C programs, but because this is the same thing behind Objective-C,
32:22
it's the same thing that builds Objective-C, so we can write categories in a small talk on Objective-C options. I've said a couple of slides ago small talk on Objective-C objects, but really, there's not a bunch of things in the school that have some
32:41
new methods. Any one of these
33:11
kit, and it's shipped as part of its running, and the new versions of that enable process. They also now
33:22
link in. So I guess we're all here
33:49
with the books. In some way, we believe that free software is a good thing, and free software foundation defines for us, access to the source code
34:20
and easy to create plugins that
34:30
allow you to replace existing pieces of the new
35:11
being open and pass them around,
35:24
which lets you look at classes and categories on the classes, and if you use the small talk environment, it's weak, so the index
35:43
browser you saw in the screening is driven by run time introspection, so this will give you grades on the classes more than a few weeks ago
36:25
with abstract syntax. I'm using this now, so if you define it, if you add methods, if you add methods to the existing classes, it just turns the class into a category. If you're an instance
36:42
variables to an existing class, then we still want to be able to do that, so what it does is add is it takes all references to those instance variables and it turns them into KVC rules, first of all via
37:08
and it sets it up as an instance variables to existing objects, it's obviously right some kind of method for supporting
37:30
it, it's where pre-application will have in the application menu, and it will develop behind pretty much
37:53
all. There are a few things we're planning
38:03
in the future, the script I mentioned the front-end I said was one last week
39:36
which will lower
39:40
new statements, so if you can guarantee that an intro message will never be sent to anyone who isn't an open key, the process written
40:52
in the school tool passes for now, which actually works, which is a matchup that's written, it allows for the writing
41:05
of the IDE, and Eric's written the first two applications I think it's more important to be working with those who manage your application What I was thinking is maybe we
41:54
prepare a replacement tool for tomorrow and maybe merge this one
42:01
a short version of this one with the 8.1 status tool I just got a question What happens when the dynamic T-ops and the small talk, if you compile it is it still there, or will it get frozen somehow?
42:30
I want to know if the small talk if you compile it if it's if it loses the dynamic T-on
42:40
Yeah, so if you compile the small talk, what is the impact of the dynamic aspects of the language
43:21
OK
44:00
Now if you have small talk questions I can answer them locally
44:22
That's a problem and then maybe I will I will prepare a version of this tool for tomorrow and try to be able to answer more questions about it already
44:40
OK with that
Empfehlungen
Serie mit 70 Medien