AV-Portal 3.23.3 (4dfb8a34932102951b25870966c61d06d6b97156)

Perl in the Physics Lab

Video in TIB AV-Portal: Perl in the Physics Lab

Formal Metadata

Perl in the Physics Lab
Title of Series
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.
Release Date

Content Metadata

Subject Area
Experimental physics Group action Process (computing) Multiplication sign Universe (mathematics) Bus (computing) Physics Physicalism Bit Quicksort Measurement
Three-dimensional space Multiplication 1 (number) Single-precision floating-point format Medical imaging Type theory Lattice (group) Different (Kate Ryan album) Vector space Gastropod shell Data structure Data structure Form (programming)
Scaling (geometry) Length Weight Auto mechanic Element (mathematics) Neuroinformatik Element (mathematics) Number Hypothesis Goodness of fit Mechanism design Logic Personal digital assistant Single-precision floating-point format Telecommunication Logic gate
Ocean current Digital electronics Multiplication sign Source code Dreizehn Limit (category theory) Food energy Frequency Liquid Quantum Computer icon Wavenumber Pairwise comparison Noise (electronics) Logarithm Ocean current Scaling (geometry) Image resolution Sound effect Bit Food energy Auto mechanic Vector potential Frequency Physicist
Point (geometry) Laptop Metre Complex (psychology) Curve Game controller Kälteerzeugung Maxima and minima Mereology Thermodynamic equilibrium Power (physics) Mixture model Type theory Liquid Telecommunication Mixture model Dilution (equation) Liquid Dilution (equation) Physical system
Web page Metre Functional (mathematics) Divisor Analogy Hidden Markov model Mereology Rule of inference Computer programming Neuroinformatik Analogy Energy level Liquid Stability theory Thumbnail Social class Source code Metre Digitizing Web page Control flow Measurement Latent heat Function (mathematics) Social class
Web page Spectrum (functional analysis) Functional (mathematics) Multiplication sign Reflection (mathematics) Mereology Arm Computer programming Data transmission Power (physics) Frequency Phase transition Vector space Energy level Physical system Game controller Arm Web page Complex (psychology) Parameter (computer programming) Computer network Control flow Data transmission Category of being Arithmetic mean Function (mathematics) Phase transition Bridging (networking) Social class Dilution (equation) Physical system Reading (process) Pulse (signal processing)
Standard deviation Serial port Source code 1 (number) Open set Parallel port Mereology Formal language Emulator IEC-Bus Different (Kate Ryan album) Query language Set (mathematics) Bus (computing) Physical system Social class Scalable Coherent Interface State transition system Arm Serial communication Control flow Measurement Type theory Radical (chemistry) Emulator Telecommunication IEC-Bus Metre Topology Game controller Sweep line algorithm Number Product (business) Frequency Root Internetworking Operating system Gastropod shell Software testing ASCII Default (computer science) Serial port Standard deviation Dependent and independent variables Dot product Interface (computing) Computer program Generic programming Diameter Word Software Network topology Password Video game Communications protocol
Web page Serial port Code Maxima and minima Device driver Function (mathematics) Field (computer science) Computer programming Template (C++) Measurement Programmer (hardware) Prototype IEC-Bus Military operation Operator (mathematics) Computer hardware Cuboid National Instruments Corporation Physical system Default (computer science) Scripting language Default (computer science) Email Expert system Code Bit Device driver Control flow Measurement Template (C++) Graphical user interface Type theory Process (computing) Data flow diagram Computer hardware Function (mathematics) Graphics software IEC-Bus Interface (computing) output Video game National Instruments Corporation Quicksort Diagram Window Resultant Extension (kinesiology)
Keyboard shortcut Serial port Set (mathematics) Mereology Formal language IEC-Bus Different (Kate Ryan album) Kernel (computing) Bus (computing) Cuboid Endliche Modelltheorie Library (computing) Physical system Scripting language Keyboard shortcut PCI Express Bit Measurement Entire function Connected space Category of being Macro (computer science) Telecommunication IEC-Bus Interface (computing) Modul <Datentyp> Quicksort Data structure Point (geometry) Dependent and independent variables Device driver Hidden Markov model Computer hardware Operating system Energy level Software testing Data structure Compilation album Module (mathematics) Game controller Serial port Distribution (mathematics) Interface (computing) Plastikkarte Device driver Kernel (computing) Computer hardware Object (grammar) Communications protocol Library (computing)
Complex (psychology) Scripting language Code Multiplication sign Function (mathematics) Parameter (computer programming) Computer programming Formal language Measurement Connected space IEC-Bus Object (grammar) Network socket Logic Set (mathematics) Bus (computing) Abstraction Social class Scripting language Trail Bit Control flow Measurement Connected space Category of being Type theory Arithmetic mean Telecommunication Phase transition Interface (computing) output Remote procedure call Whiteboard Functional (mathematics) Data structure Trail Functional (mathematics) Inheritance (object-oriented programming) Vapor barrier Boilerplate (text) Disintegration Shift operator Revision control Frequency Latent heat Object-oriented programming Telecommunication Computer hardware Address space Module (mathematics) Default (computer science) Dependent and independent variables Computer program Code Generic programming Computer network Personal digital assistant Query language Network socket Object (grammar) Dilution (equation) Local ring
Sensitivity analysis Functional (mathematics) Dependent and independent variables Multiplication sign Source code Maxima and minima Limit (category theory) Bit rate Parameter (computer programming) Mereology Shift operator Computer programming Formal language Frequency Type theory Different (Kate Ryan album) Phase transition String (computer science) Computer hardware Energy level Logic gate Social class Module (mathematics) Source code Boss Corporation Complex analysis Dependent and independent variables Interface (computing) Range (statistics) Maxima and minima Device driver Parsing Connected space Frequency response Similarity (geometry) Type theory Latent heat Frequency Query language Personal digital assistant Function (mathematics) Software testing
Point (geometry) Noise (electronics) Game controller Digital electronics Real number Physicalism Parameter (computer programming) Real-time operating system Bit Function (mathematics) Parameter (computer programming) Measurement Plot (narrative) Population density Programmschleife Personal digital assistant Sweep line algorithm Arithmetic progression Programmschleife Spectrum (functional analysis) Electric current
Logical constant Point (geometry) Ocean current Trail Slide rule Group action Scripting language Sweep line algorithm Computer file Plotter Source code Hidden Markov model Set (mathematics) Parameter (computer programming) Mereology Shift operator Graph coloring Plot (narrative) Declarative programming Computer programming 2 (number) Depth of field Measurement Programmschleife Computer configuration Computer hardware Scripting language Noise (electronics) Logical constant Block (periodic table) Expression Voltmeter Measurement Type theory Cache (computing) Arithmetic mean Software Function (mathematics) Internet service provider Programmschleife
Functional (mathematics) Scripting language Computer file Code State of matter Plotter Multiplication sign Computer-generated imagery Generic programming Mereology Plot (narrative) Measurement Bus (computing) Configuration space Scripting language Moment (mathematics) Expression Code Generic programming Mereology Measurement Connected space Function (mathematics) File archiver Configuration space Sweep line algorithm Arithmetic progression
Scripting language Plotter Standard deviation Functional (mathematics) Code Source code Expression Computer network Mereology Encapsulation (object-oriented programming) Mereology Formal language Formal language Type theory Particle system Seitenbeschreibungssprache Type theory Different (Kate Ryan album) Vector space Moving average Endliche Modelltheorie Abstraction Booting Scalable Coherent Interface
Service (economics) Collaborationism
so welcome let me tell you something
about Paul and the physics lab so first maybe I should introduce myself a little bit I'm well I'm mostly here at fosston because I'm heavily involved in Gentoo Linux so most of the time you will find me down at the gen 2 bus where I'm involved in packaging all sorts of stuff including also Perl as a Perl package I'm a little bit horrified at all these ideas about carton and docker and so on I think specifying good dependencies should do the work but anyway in my main occupation in my day job I'm an experimental physicist working at the University leading a research group and we are using Perl to measure and that's what I'm going to tell you about today this is this package here lab measurement so what are we working on so
we are working on we are researching carbon nanotubes I don't know if you've seen these pictures here before there are many different forms of carbon there are many different forms of carbon you can have Dimond where you have such a three-dimensional lattice of carbon atoms you can have these fullerenes you can have graphite or graphene with this layer structures and you can have carbon nanotubes carbon nanotubes stay there you have basically one of these caffeine sheets wrapped up into a tube and it's really one big macro molecule you can
have many different types of these it's bit hard to see so you can have multi walled ones we have many such shells in each other you have single walled nanotubes where you have just one these are transmission electron microscope images and you can describe them with the different structures here you can see that essentially this carbon sheet is wrapped up and glued together in different ways why is this interesting well you can do a lot of different
things with them on one hand they are very light and they are mechanically very stable there are very tension of assistant and this is more or less the only material where people find that the numbers are right for building this hypothetical space elevator basically you need to have something that is strong enough so it can carry its own weight over such a long length the other side is that it's a very good electrical conductor so people have been thinking about using it for cheap beers for example and that it can be used for very fast transistor elements the problem is the handling and building the devices but also there people are making good steps forward so this is kind of the first nanotube computer that was built it's still far below anything x86 like but anyway I mean it looks like the logic is essentially working mmm what are we doing we are looking at the
mechanics and electronics of single such molecules and you can see here that you have two metal electrodes and you have one molecule that is lying across them in this electron microscope picture the scale bar here is half a micrometer 500 nanometers so we have a single macro molecule we have metallic contacts we have a gate electrode that is somewhere on a chip pack substrate and you can
draw this for example here like a small circuit you have two voltages that are applied one source voltage that is actually driving the current that flows through the tube one gate voltage that is just changing the electrostatic potential and you measure the current that flows that looks pretty simple the challenges are you want to measure at very small voltages you want to measure there's more currents you probably want to measure at high frequencies and you want to see tiny details and that's why
you go to low temperature low temperature well temperature is for us a little bit something like noise the higher the temperature is the more smeared out the effect that we want to observe are this is a logarithmic scale physicists love to compare temperature scales and energy scales so energy a temperature scale in Kelvin so this is always a thousand so we go from a thousand Kelvin which is about three times room temperature to one Kelvin here in between somewhere helium gets liquid and this is where our experiment actually is at 10 milli Kelvin which is 0.01 degrees above absolute zero that's something you can buy so this
equipment to cool down so far is well commercially available it's called the dilution refrigerator that's actually been a part of my IRC nickname comes from it uses an isotope mixture of helium 3 and helium 4 in liquid state as a coolant and goes down to in principle arbitrarily low temperature just that at some point you get the equilibrium between the thermal isolation from the outside and the cooling power and then you have a minimum but it's still quite a complex piece of equipment and you need the knowledge and the personnel to handle it mm-hmm yeah and with that we end up at some point in as soon as my laptop manages drawing
the picture in our Millah curve in lab where you can see all these equipment pieces assemble together so you have the actual cryostats they are sunk down in the floor here they actually go about 3 meters down and you have all the control electronics that impart controls the cooling and impart controls the actual experiment what type of equipment well let's look
at this at such a simple measurement I've shown you this picture here already we have we apply two voltages measure one current so what do we need we need two highly stable voltage sources this year from company called Yokogawa we need to amplify the current that comes out of the thing that's done by some analog piece of equipment so I haven't even made a picture because it's not interesting for us here and we need a digitizing multimeter that basically reads out the digitizes the values and delivers them to the computer that's what we have done here in general we can
divide more or less by a rule of thumb the equipment in two or three pieces there's the fairly simple part this is these voltage sources for example fairly simple as relative fairly simple my class my personal classification is the manual is smaller than 200 pages and the programming part of the manual is smaller than 50 pages typically they have one main function for example they apply a voltage or they measure the level of a liquid hmm examples would be some cheap stepper motor for 20 euros that you buy at Colorado or one of these voltage sources which costs about two and a half thousand yours or per meter or a liquid level meter yeah you can't actually read what's here this is kind of an except for manual where the command syntax for this thing here is just cracked leather two would be
complex complex means usually there's an armed Linux system somewhere in there that's controlling it the manual is somewhere smaller than a thousand pages the programming part is somewhere smaller than 215 pages and you have a main function with a lot of detail for example you have something like radiofrequency sauce that can do amplitude modulation pulse modulation frequency modulation anything like that or you have some temperature measurement equipment that measures five or six temperature channels and can regulate or you have a magnet power supplier for a big fat superconducting magnet all such a spectrum analyzer here well that's level two and then there's all also level three level three well
Manuel bigger than a thousand pages programming part larger than 250 pages price insane typical well one is this cooling equipment okay that does not really have a thousand pages manual but it should have and if you count every page with a mistake three times then you get pretty close to the thousand pages then something like a vector network analyzer from Orange Box here which is basically measuring transmission properties in a microwave regime so you send them my frequency signal in a frequency signal in you get a high frequency signal out and you see what a transmission amplitudes and phases you get well this is again a piece of the manual and what you can't read is that the programming part here is somewhere like 500 pages how do you program this stuff well
there's different ways to get access you can often connect them directly to some network it's not always a good idea to connect them to the Internet at least one piece of equipment that I saw ones that actually cost somewhere around 40,000 euros had an open tenet port where he immediately got a root shell on internal armed Linux system without any password mmm that was luckily fixed in the next fembra release so use a separate network for that mmm you can control some of the older equipment with serial cables some of them have USB port that acts as a USB serial interface then there's this GPIB general-purpose interface bus or I Triple E 488 that's something people outside the lab don't know it's basically a very fat cable about a centimeter in diameter with a fat plug here a parallel bus 8-bit depending on how old your equipment is it can be pretty slow or pretty fast up to 15 devices on 20 meters of cable topology any so that means you can make a bunch of spaghetti out of it but it's pretty useful because it handles part of the equipment addressing and part of the communication protocol and more modern variants are also built on top of that so you have the USB USB test and measurement which is basically just another type another class of USB device that more or less emulates the protocols from here over USB and you have weeks e 11 which is emulating the same protocols over TCP so they are in everything but the hard way are pretty much similar how
do the commands look like well luckily most of the equipment just words with ASCII which makes life pretty simple mm-hmm you can talk to them essentially with the terminal emulator and everything that conforms to this I Triple E 488 not too understand some minimal command set some a few generic commands for example this ITN will you basically just tell the instrument identify yourself and you get a response like this year so this would be like lakeshore temperature control interface the model number serial number and so on everything that goes beyond this well primitive idea of identify yourself or reset yourself or something like that can vary mmm so you have non-standard stuff which is basically either old or highly specialized equipment you have they're not quite standard stuff well some companies really try hard and get it wrong and you have language that's called STS CPI or skippy standard commands for programmatic instruments which defines other complex syntax it is fairly readable so we have something like system communicates serial about 2400 you can guess what it does it sets serial communication to 2,400 dots or measure voltage DC was okay or source frequency start 100 stop 200 means sweep a frequency from 100 Hertz to 200 Hertz that's actually doable so how do other people solve this how do other people control the equipment well there's many different solutions I'm not going into all of them I'm mainly going to show you one that's kind of the default solution
that's called a National Instruments LabVIEW it exists even for Linux which is astonishing in a way and that's what every hardware vendor provides drivers for now then the question about for Linux already becomes a bit more questionable programming in LabVIEW basically means you wire up the flow diagram of your code so it's really graphical programming and you can easily put together graphical interfaces where you have input fields and output fields and so on actually I think LabVIEW is a very nice program for simple stuff it's good to make some quick prototype and try something out the problem is when things get a little bit more involved then you end up with something like this here and the fact that this picture actually comes from the National Instruments website tells you that they have realized the problem and this is from a page called I think something like like laugh you laugh laugh you wrote mistakes or some rookie mistakes or something like that the problem is I've seen code like that coming from a company for some piece of equipment and we had to work with that and modify it so yeah it's not so much fun you can do subroutines and everything like that so there are ways to do it much better much better but why do it this way then when you can actually write a script so what do we
need we want to be operating system agnostic what we want to do needs to work with Windows and with Linux because at least I want to work with Linux and some of my colleagues don't it needs to be drained transport and Driver agnostic so the idea is if you have for example some piece of equipment like these voltage sources that can be plugged in by a GPIB or by ethernet or by a USB serial then it shouldn't matter which type of cable you use it should work just the same it should support background operation which means for example cron jobs so we want to be able to set something up so some whatever lyrics box monitors some piece of equipment reads out values every 10 minutes and sends an email if something goes wrong and we want to have support for foreground operation especially also we want to be able to run some long and complex measurement and watch the result life to see when something goes wrong and hit control-c of course we want to be able to control our equipment in as much detail as possible and on the other hand we also want to have it pretty easy to set up some sort of default measurement and especially since not everybody who is working in our lab is a programmer and a pearl expert we want to have it fairly easy to extend the instrument driver somehow and also to create a new measurement just from a template so of course what we wrote didn't happen overnight this program started over 10 years ago more or less has grown and evolved in the meantime a lot how it
looks like right now it's more or less like this year so we ended up with some sort of layer structure everything here in this gray box is the actual lab measurement distribution so we start up here with the actual hardware then we have hardware drivers or library bindings for example the serial port there that's just a Linux kernel or the operating system Linux GPIB would be a set of kernel modules that is also a separate distribution this is a commercial library then we have a bus layer a connection layer an instrument layer the so called express a I'm going to go through this in detail on the next slide and in the end down here your actual measurement script and everything in this box here is your problem so no compilations involves anymore let's look at this in detail so the
upper part so we have these hardware drivers as I mentioned this is outside the actual distribution part of it is the operating system for example the serial port Linux GPIB is distribution of Linux kernel modules that comes with library to do the communication and with bindings for many different languages PHP Python but also Perl some bindings we also to ourselves there's a snap these are packaged which binds to net international instruments these are library there's lab weeks 11 which basically implements that protocol on top of TCP USB T and C which use asleep USB to implement this test and measurement protocol there is also a Linux kernel driver for that protocol but it's a bit unflexible hmm yeah and the bus and the connection level they encapsulate the transport model as the command transport bus means we have one object for one yeah host adapter Mallis so for example for this GPIB you have one object that is corresponding to the adapter card that goes into your PC a PCI Express card for example that then connects to the cables and that has all the global properties that are not specific to the instruments connected to the bus that are specific to the entire system of connection the connection lever layer on the other hand that is one object per attached instrument so this is like a TCP connection that goes from point A to point B so you have a connection per instrument that is attached to the cable hmm the connection layer is actually only a very thin very thin interface so if you
look at the code in the legacy version most of the stuff is implemented on the bus layer I picked because nobody here is familiar with the specialist hardware I picked the socket connection for TCP connection as an example so here we have the bus and the bus defines all these well properties that correspond to everything that you can do with the TCP socket like remote port remote address local port local address and so on but also things like time outs the bus creates the connection objects and keeps track of them and the bus also handles the actual oh this is too long the bus also handles the actual communication so when when connection wants to do some some talking to somewhere then it hands over the texts to the bus the bus does the actual hardware access the connection layer itself is not a simple okay I showed here a little bit but the socket connection module is really not much longer than this it uses a generic socket it uses the bus and it uses the generic connection package but otherwise it just uses the inherited subs things get more interesting when you come to the instrument layer because the
instrument layer here is the first layer where you can actually do something as a user then we have a generic lab instrument class and then subclasses of that which correspond to specific types of equipment the specific types of equipment means in this case that the subclass implements the yeah the language the instrument speaks so you get your specific queries to the instrument and you pass the specific responders that they sent and you can implement a nice interface for for your end-users generating the instrument object is father is rather easy so there's this function here in the lab measurement package where you can generate such an instrument object by passing the class name and then passing further parameters and in this shorthand here we get for example an instrument of the type oh I Triton that is automatically generated with a connection of the type socket and that calls up the whole underlying stack so you get a bus of the type socket you get a connection of the type socket in this case it's generated with the default parameters like the default remote address and the default port and so on which is in this case already adapted for this specific type of instrument or here network analyzer with the module name of the instrument I set VA and the connection type Linux GPIB and here the address on the GPIB bus that this particular device that we want to address has and then it generates connect and a bus if the bus doesn't exist yet and we can we are ready to talk to it how does working with an instrument look like well this is actually a full fully functional script so we have we are calling here in the instrument module we need an address on the GPIB bus in this case where this instrument instrument is located so we get that from the command line mm-hmm we generate the object corresponding to the instrument this is in this case of Stanford Research lock-in amplifier which is connected with GPIB address as parameter at the first GPIB board in the pc and then we read out from there the output amplitude and the output frequency and we get the input amplitude and the input phase doesn't matter on our exactly what these barriers mean but anyway you get ready-made functions for getting the various device parameters and obviously you can do this in such a small program but you can also write a big and complex Perl script a big package that does much more complex things with the equipment what do these functions do internally oops now I write yeah well they are not
really complicated because we want to keep this level where people actually may want to modify things and enhance things we want to keep this level as simple as possible so if you look at this gate frequency function here it does nothing but call the query function of the lab instrument class and that sends this string here to the instrument asks for the frequency gets a response and that response as returned this query function it handles it's in the lab instrument class it passes this string to the connection with the proper parameters the connection parser to the boss with the proper parameters and that goes to the hardware same get amplitude also just one command string that is documented in the in the manual of the equipment in the hardware manual and similar also our fee here where we get two values at the same time and then return them as an array and as you can see this is kept deliberately simple so people who are not perl specialists can improve it and extend it by a simple copy and paste
of course there are more different cases and there are also cases where we can use more language features or more programming features for example there are many different types of voltage sources from different companies and they all have roughly the same functions so we can make a class that is called instrument source and that provides like a common interface and then we can automatically provide more complex functions for example we could say we have a very sensitive chip and that chip doesn't survive if the voltage suddenly changes above a certain step size so we enforce that voltage is only changing in a smooth way with a maximum speed and the maximum step size and all this is already then implemented in the source package and our actual Hardware addressing modules don't take don't have to take care of this anymore similar modules are in preparation for other equipment types for example superconducting magnet power supplies but then things can easily get rather complex and we don't yeah we do part of this stuff only when we really have the need for it and now for something more
complicated yeah now we want to do something like a real physics up measurement let's get back to the simple circuit that we had at the beginning we apply two voltages we measure one current huh we could also measure more things so let's generalize this a little bit so we have nested loops of two or more control parameters in this case the two voltages one voltage a second voltage and at each point that corresponds the two of these values we want to measure one or more parameters for example the current all the noise spectral density or something like that mm-hmm and we want to watch the progress of the whole thing so we get some output that you can't see here and we want you to plot the data in real time in a way
no like this here how do we do that
well for this we have this Express layer let's just talk to one of the measurement scripts rather quickly part of it you already know from the previous slides so we call in that measurement here we just define some constants that correspond to our hardware and to our equipment and so on this year you've already seen as well so here we generate the instruments we have two voltage sources of the type Yokogawa GS 200 we have one multimeter from HP or agilent keysight now yeah and then comes the new stuff then we define sweeps sweeps basically means we go from voltage a to voltage B in steps of this size with this and this speed mm-hmm so here for example we go stepwise from minus 1 volt to plus 1 volt with this step with here and there are some more parameters like we don't we jump from point to point so there is no actual smooth sweep involved between the points and before we start we wait three seconds hmm and this is similar declaration so we go from minus 0.5 volts to plus 0.5 volts with analysts with another step with and another speed and so on and then we define a data file so for example yeah tap separated columns with one voltage a second voltage and the current three columns and then we define a plot and for that plot we have in the x-axis the one voltage on the y axis the other voltage and the color bar is the current and after every Plock meaning after every trace of one of the voltages the plot in the block is the the picture is refreshed next step we need to provide measurement instructions what should be done at every point and then we define a sub that is called at every point what does it do well it calls it leaves out from one source the value it reads out from the second voltage source the value and it reads out a multimeter about this cashing stuff here well sometimes hardware access can be slow and especially these voltage sources they can set the voltage very fast but reading the voltage out is unfortunately a very slow action so what we do is we provide an option that the software keeps track of the last set value and when you want to read it back out you just read it from a cache in the PC you don't actually access the the hardware equipment anymore yeah and then each of these triples two voltages one current is locked into the file and in the end we wire this up we connect the data file with the sweeps and so you get these nested loops and then we stop it and it starts to run and then you get a plot like this well
precisely you get a plot like this when nothing is connected because this is just noise hmm but never mind the plotting itself is done by calling a new plot as an external program and piping the commands and reading the data files from it which works in a fast and robust way what do we get in the end you can't
see this here you get a copy of the measurement script for archival purposes you get the actual data file in the subdirectory you get a summary of the device configuration and you get the last state of the live plot as a file as I sent this code is at least in its very beginnings over ten years old so right now we are looking into modernizing it and that turns out
to be rewriting it with moves step we need to keep it working because we have it running all the time so we need to rewrite it as step wise as possible parts already included in the current release but we need to somehow keep compatibility as good as possible the bus and the connection functionality is mostly done so this is now one combined layer the generic instrument functionality is also mostly done the instrument porting and subtyping is partly done but also in some parts of the code there's already more in the new version than in the old one and the Express work is working progress at the moment of course once we have moves we
can use the most functionalities and you can for example use vowels for types of instruments what we did before with the source we can now do with for example moose rolls or we can use it for language standards so that we have one role that implements part of the Skippy standard for addressing the devices and then what we are also doing is we are doing the plotting bio and data handling via PDL now so this gets a bit better capsulated and with that I'm getting to the end I'm not the only person who's
involved this Daniel Daniel started it like 11 years ago florian introduced layer model christian boot Co Finch different guys are made this Express layer for the fast creation of scripts Charles Lane introduced a lot of code for oscilloscopes they use this at a particle accelerators Simon is the guy who is now doing all the work porting it removes and of course some more people were involved that all the details of course in the get knock
and with that I'm finished and thanks for your attention [Applause]