 So, the tutorial is going to be in English mostly, but I also speak French, so if you have questions you can ask and you don't feel comfortable asking them in English, you can just ask them in French. And I will try to reply in French as well. So, I'm Sebastian, let's see, I actually have a pointer, well, that's not a problem. My name is Sebastian Manto, so I'm the lead developer of Open Sesame, with us is Daniel Schij, who's also here visiting the lab working on Open Sesame. And Open Sesame is a tool, as you know, you should sign up to make experiments. So, what we will do today, I'll start by giving a short introduction, which is just this presentation. Then we're going to make a simple experiment, which is the tutorial that you have a problem with. It's very basic, so I think everyone will be able to follow it, just to kind of get the general idea of how Open Sesame works and the logic behind the program. We will take a little bit of a coffee break, not if we don't feel like it, but I probably will feel like it, it's 45 minutes. And then we finish the tutorial, I estimate it will take about an hour and a half. If we finish early, we can do some extra things. If we finish late, we just, we retire and just stop. And feel free to interrupt me at any time, right? If we have a bit of an interaction, it's better than if you just follow everything that I do. So a little bit about Open Sesame, so Open Sesame is, as I said, a graphical experiment builder. So it is a tool that psychologists and neuroscientists and experimental economists, basically all the researchers that do behavioral experiments, can use to create experiments in kind of a simple point and click way. So it's drag and drop, point and click. You can also use Python scripting in Open Sesame, and Python is a programming language, quite a powerful and popular programming language, but we're not going to do that today. It's pretty, because a bit beyond the scope of this tutorial. If we feel like we want to do some Python programming next week, then we can do a tutorial that has some Python programming, but we'll just see how you guys feel. Open Sesame is open source, so that means that it's free, right? You can just download it for free. You have downloaded it for free. And it also means that the source code of the program is available. So you can just download the source code and change it if you want to do that. There's cross-platform, so I see a mix of MacBooks and Windows, maybe Linux PCs here. I use Linux, but it's also available for Windows and Mac OS, and it should make no difference which platform you're using. So the idea is also that, like, say that you want to, you develop your experiment on your own MacBook, and the lab has a Windows PC, and you can just take it from your MacBook, put it on the Windows PC, always test, obviously, right, whether everything works as expected, but in principle, they should just work. And there is runtime support for Android, so runtime support means that you can put your experiment on your Android phone and run it, but you cannot build your experiment on your Android phone, right? There's no graphical user interface, only the part of the software that executes the experiment. But it's kind of cool and works pretty well, so you can just really, if you have an Android phone or tablet, you can just do experiments. And I've done quite a few. The focus is quite broad of OpenSesame, so I come from visual psychophysics, but the focus of OpenSesame is really all kinds of research within the behavioral sciences, and it's not even particularly good for visual psychophysics, I think it's really a broad software. So I started psychophysics, reaction time tasks, having complex stimuli, like random dot gradient, random dot stimuli, that kind of thing. You can do that with OpenSesame, but you can also use it for neuroimaging studies if you want, like you can send parallel port triggers or serial port triggers or whatever kind of triggers your trigger-happy device requires. Social psychologists, well, they don't only do questionnaires, but I think questionnaires are very important for social psychology, so there is a form of functionality in OpenSesame that allows you to embed questionnaires in your experiment. And for clinical applications, I think I'm not particularly, I'm not sure whether OpenSesames at the moment use much for clinical applications. I think it's used mostly for teaching and research, but in principle, I think it could be used very, very well for test batteries, especially when you put your, like say, you have your test battery, you put it on an Android tablet, and then, of course, you can use it very easily in a clinical setting. Yeah, so in terms of support, which is, of course, very important, right? If you can use the software, if you use the software that you have some decent support in case you get stuck, because, of course, you always get stuck. So there is a documentation site, osdoc.coxside.nl, that has a lot of documentation, and actually this tutorial that we're going to do today is on the documentation side. It is just one of the, it is the French language tutorial on the documentation side. There's a community around it, so we have a forum, a support forum, forum.coxside.nl, which offers support for OpenSesame, but also several other open source packages, like most, most famous probably being JASP, the open source kind of SPSS clone. I don't know if anyone here are familiar with JASP. It's pretty, pretty awesome, you should probably check it out. Through the forum. The forum has now, I think the count is now up to 1,800 something members, not all of which are real, part of those are spam accounts, but it's really quite a big forum with daily activity, and people are very responsive, and we have a few people that actually actively and semi-professionally maintain a forum to make sure that questions are answered and stuff, one of those being here in the room. So in terms of outlook, so perspective on the future, right? If you're going to invest time in learning piece of software, you want to know that it's still going to be around in, well, in the foreseeable future. So is that going to be the case for OpenSesame? I certainly hope so. I think we have an active development team, right? Certainly, actually in the last year or so, we got a few grants that made it easier to actively develop OpenSesame. So I think it's going really quite well. Well, we have some small funding, but still some, and some sponsors that help us really to keep the program project going, and we have, I think that's also very important, we have a pretty large user base. It's very difficult to estimate how large the user base is, because you can just download it for free and then you don't know, right, how much people use it and stuff, but at least if you look at the, if you take the visitors to the website as an indication, we have around 500,000 hits per year, corresponding to roughly 125,000 individual users, or insofar as we can tell individual users. Well, users, visitors, not all of which are users. Developers, well, meet the team, the core team consists of Daniel Schij, who now works, works actually full-time on OpenSesame. Lodje van der Linden, who works, who's PhD student here at the, at the university, at their position, and who actually made this tutorial that we're going to, going to do today. Edwin Delmeier, who does kind of the eye-tracking stuff and works at the University of Oxford, PhD student. Edward, who works at the Vue University Amsterdam, and who does, does make the, he does support, he answers questions on the form, and so does Joshua, who's another PhD student here at the university, as I say. So those, and, and, and, so those are the, that's the core, those are the core people, I think it's pretty loosely defined. There are some, I mean, people come and go, but those are people, I think, that are actively involved in, you know, Sesame. And then there are many occasional contributors who do things like contribute to translation. You will see, if you have a French computer, you will see that it's partly translated in French. Not as well as it should be, but it will be in future. And it will report bugs, help us answer questions on the form, et cetera. Now, in terms of teaching, Opus Sesame is becoming more and more a teaching tool. It's also, I think it's primarily intended to be a research tool, but it's also used a lot in teaching. And I think what's very important is that Opus Sesame has no licensing issues. Like, for example, at the Vue University Amsterdam, where, where I did my PhD, they used to teach their programming courses using, using E-prime, which is pretty expensive to begin with, but also the students don't have an E-prime license, so they have to go to the university and go to the computer rooms, which are always overcrowded, et cetera. And now when they, they, they use Opus Sesame, at least they, they, they're still, they're still using Opus Sesame? Yeah, yeah, yeah, yeah, good. And, and those licensing issues are gone, obviously. And there's no steep learning curve, right? There are plenty of good toolboxes for, for, for making experiments, which you're not going to teach bachelor students to work with psychophysics toolbox or something, or you can, but it's quite tricky to, to do. So Opus Sesame's kind of like easy. So it's used for teaching at universities, really, across the, across the world. And for bachelor master projects. Actually a lot of, I see on the forum now a lot of students, which I think are doing their El Tua strategy thing here in, at the university. Because they're, here, they have like names that kind of suggest, that's what they're doing. And it's, well, that's what I said. It's used as part of these courses on programming and research. So about using Opus Sesame. An Opus Sesame experiment is, is basically just a structure of what I call items. And an item is just, and like each of these, these icons that you see here in this overview area is an item that does, that handles one particular functionality. And you basically just click together these items to build your experiment. Like for example, you have the fixation and the, the, and the stimulus items that do represent the visual stimulus, the keyboard response item records a keyboard response. So you really see the, basically the logic of your experiment in this, this overview, right? This kind of tree-like structure. There's 10 core items that have the most basic functionality, really things like you basically need every experiment, like presenting visual stimuli and recording keyboard responses. And then there are many plugins that offer additional functionality. Like the can, which can basically be anything. Like there's a set of plugins. The PiGays plugins who, who allow you to work with eye trackers. I use that myself a lot. That's developed primarily by Edwin, Edwin Dahmeier. There is a plugins for video playback that Daniel mostly maintains. There are plugins for forms, the questionnaire functionality basically, which are very important, et cetera. There are a whole bunch of, whole bunch of plugins that do various things. So that way, obsessive is really extensible, right? People can create their own plugins. They sometimes do, to a certain extent. Like, for example, someone created a very nice set of plugins for mouse tracking. You know the mouse tracking paradigm, which you basically record mouse cursor trajectories as a measure of cognitive things. Or in someone else wrote a set of plugins for interactive experiments, which are really awesome. Those are these behavioral economics experiments, like prisoner dilemma games, where people really interact with each other on a, on a, on a computer, on different computers that are connected, right? And those are pretty, pretty complicated, pretty advanced plugins that you can use in obsessive. And plugins provide graphical control. So it's not difficult for, from a user perspective, there's no real difference between using one of the core items and using the plugins. You still get a bunch of buttons that you can use. And new plugins can be written easily, if you're a programmer. Let's go in a little bit, go a little bit into the distinction between user interface, which is what you see and usually work with, and the script that kind of defines your experiment in open sesame and lies below the user interface. And the way it works is kind of as follows. If you do something in the user interface, it generates a script. So let's say that your drawing is smiling. Then what open sesame does is it generates a whole bunch of, it generates a script that basically corresponds to that smile, like draw a circle while it's a bit too dark maybe for you to see, but each of these lines is a draw command that creates this, that creates that smile. That happens automatically. This is a custom language just to avoid any confusion. What you're seeing here is not Python. Open Sesame does not generate Python script. It generates a very simple custom language that I call open sesame script. So it's not Python. You can edit this script directly. And that's quite nice. And then you can continue using the GUI. So the script is so simple that open sesame can parse this script and translate it back into the graphical user interface. And that makes it possible to do very cool things. Like for example, one, I guess you could say, the design pattern is to create a prototype display in the GUI and then make it variable using the script. So let's say for example, that you have, usually in the experiment you have a trial that shows some similar display. That is kind of the same on every trial, but not exactly, right? I mean, for example, you might have a smiley on every trial in the case here with paradigm, but sometimes the smiley looks straight ahead. Sometimes it looks to the left and sometimes it looks to the right. Now, ideally you don't wanna create three different displays for that. You wanna create one display that changes a little bit on every trial. And that's what I mean, but with creating a prototype display using the GUI and then add make it variable as follows. Say that you draw a smiley. You say you have a picture in your, that is called ps underscore left dot png and it has a smiley that looks to the left. Now, you create, you open user interface and you draw that image and it looks to the left, which is fine, but it only works for one trial, right? The trial where it looks to the left. Then what you can do, you take the script that oversees and it generates automatically and you replace the parts of the script that you want to make variable. So in this case, we assume that you also have a file that you have things that are called gays underscore right dot png and gays underscore neutral dot png, for example. And now what you do, you just replace the word left by gays queue between square brackets. And this means, but this tells open sesame, is that you have a variable in your experiment, which is called gays underscore queue decision. And this, and basically the value of that variable should be inserted here, right? So if gays queue has the value right, it will show gays right dot png. If it has the value neutral, it will show gays neutral dot png. So it's kind of like scripting light, right? It's pretty easy. I wouldn't go so far as calling this programming, but you can kind of, you can add a little bit of flexibility to your stimulus displays without needing to do anything fancy. Now, a little bit of technical background, backend. So if you have a program, right, there are always many different ways in which this program can control the display, collect keyboard, input, et cetera. Meaning that there are just a lot of software libraries that basically do that same task. And each of these software libraries have their own advantages and disadvantages. Now, the nice thing about obsesame is that it is not tied to one particular backend, not tied to one particular way, for example, presenting stimuli on the display. Rather, there is a selection box called backend that gives you a selection of various of these backends, various ways to control the display and collect input, et cetera. And each of these have kind of their own advantages and disadvantages. That's what I said, right? And you can basically add backends and remove them more or less like plugins, right? So it's quite easy in obsesame to add a backend to, say, for example, if you wanna do something crazy, you wanna present your stimuli on a printer for something you could, in theory, create a backend that shows stimuli by sending a print command to a printer. That would work, it would not work. Particularly sensible to, perhaps that would work. As I said, every backend has its own benefits, like, for example, one backend may be more temporally precise than another backend, right? So that you know with more, you have more fine-grained information about when stimuli have been presented on the screen, which some researchers care a lot about. Some backends are more stable than others, right? I mean, sometimes it will, it can happen that like on one particular operating system, you know, some backends just crash all the time, which is annoying. Some backends offer extra functionality for example, there is a library called Cycopyne, that is quite widely used within the Visual Psychophysics community that has all kinds of routines for presenting complex stimuli. Now, if you use the Cycopyne backend in obsessive, you can also use that extra functionality that Cycopyne gives you. And cross-platform support, like not all backends work really on all platforms. The best example of that is that there is a backend called Droid. If you wanna present your, if you want to play or run your experiment on a tablet, on an Android tablet, you need to use the Droid backend. So here are the ones that we have. We have the experiment backend, which is pretty basic, but it has pretty good temporal precision. It's a default. We have the legacy backend, which used to be the default legacy, means like remain, remain there from the past, essentially. It's actually pretty nice, but it doesn't have excellent temporal precision. There's the cycle backend, which allows you to use Cycopyne, the functionality of Cycopyne, and the Droid backend that you will only use, essentially, if you want to run your experiment on an Android device. Okay, now, before we gonna do the actual tutorial, let's take a look at what experiment we're gonna make. So it's gonna be a real experiment, but it's gonna be pretty simple. It's gonna be a categorical primal experiment, or a French amassage category. So participant, I just put the French word so that we know basically the, we are all familiar with what the corresponding English and French terms are. Participants first see a queue, which is called an amass in French, and the queue can be either the word animal or a string of axes, which is kind of like a neutral queue. And then they see a target, which is called sieble in French, and the target can either be an animal name, like chien, chat, or lapin, or a non-word, to my best knowledge of French, non-words, chien, show, and lapin. So it's a lexical decision-task. I don't think it's a non-word, because lapons are word names. Yes, I think so, because there is a country called lapony. Okay, all right. And people from there are lapons. I'm called lapons. Well, there won't be primed by the word animal. No, I hope I'm not familiar with the country or the people, but let's just assume that they're not primed by the word animal. So the task is a lexical decision-task, all our favorite tasks. So if you see a word, you press the word M. If you see a non-word, you press the word, type the, sorry, if you see a word, you type M. If you see a non-word, you type Q, which only makes sense if you have an assert keyboard, otherwise it's a bit awkward. But that's the task. And what we predict, obviously, the hypothesis is that a prime, an animal prime, reduces response times because all the words for words, right? Well, I should say, first of all, in a lexical decision-task, we generally only analyze the response times to the words, and not the non-words. So we'll throw all the non-words away. And then for the words, which are all animal names, we assume that participants respond a little bit faster if they're primed with the word animal, compared to when they're primed with this paper, right? So that's our hypothesis right there. So this is what the trial sequence is going to look like. We start with a fixation build for 500 milliseconds, then we present the Q, most animal, then an interval, then the target, and then participant gives a response, and then we log all the files to a data, all the information to a data file. That's it. Pretty simple. So in terms of the design, I always think it's nice to kind of specify the design formally, right? In this case, it's pretty trivial, because it's about as simple as it gets, but especially if you have a more complicated design, it can help you to really be, to specify what you're working with. So here in France, they have this, I think, quite kind of nice notation that you learn, I think you also learn at the university, right? With this thing. Does it look familiar to you? I know they teach it now anyway, because the logic teaches this. But anyway, what it means is you have the S with the underscore line below it, means you have an N number of subjects. The P2 means that we have the factor of P, which is the prime, has two levels, animal for the axis. And then, well, the C is a bit, the C blue, the target, also has two levels, because it's an animal, a word or not word. And then the process means that it's a fully cross design, right? If not a boxed in design or between subjects design, it's a fully crossed within subject design. So what kind of design is this? Well, I just said it, it's obviously within subjects. It's fully crossed, well, I just also said that, should probably anticipate my slides more. It's fully crossed, yes. How many factors with how many levels? Well, we have two factors with two levels. You could also reasonably consider maybe subject, a factor, but we generally don't, right? So if we don't consider subject to be a factor, then we talk, we have two factors with two levels. Okay, so let's start with the actual tutorial. Without further ado, well, oh, switch to open sesame. Okay, so if you just get, what's your name? Do you want to connect yourself to the power thing? No? You're fine? Okay. So I'll take also one. Okay, so what we're gonna do is basically we're going to walk step by step through this tutorial, which will be quite easy. And it's also a good moment for you to ask questions if you're like wondering, can I do also do this? Can I also do that? Then you just ask me and we will talk about it. So the first part, the introduction is basically what I told you during the presentation, so we don't really need to do that. What we're going to do is we're going to skip to step one, démarrer, open sesame, start with sesame. I think we will manage the first step. Has everyone started over sesame? Okay, good. So if you see over sesame, shoot. I will take it, well, I can use my mouse. So if you start over sesame, you see the screen like this. So in the beginning, in the middle, you have this general area, it's called the tab area, and that's where all the important stuff will happen, essentially, where all the controls of the items, et cetera, will appear. And right now what you're seeing is kind of a wizard that helps you to start a new experiment or to open a recently opened experiment, et cetera. Here on the left-hand side, we have what is called the overview area that shows, gives you a tree-like depiction of what the structure of your experiment is. Which is pretty simple now because we started with the default template. Now at the top, we have a whole bunch of icons, that's just a tool bar, tool O to start a new experiment, et cetera, a few ways to run your experiment, these play icons here, well, and a few other things which I won't go into, et cetera. Have a seat. You're just in time, you just begin the actual tutorial. And then here you have the item tool bar, which will look a little bit, I mean, you will have slightly different items there probably, but basically here you have all these building blocks of your experiment that you can just select and drag into your experiment to sort of add things, right? Say, I wanna collect a mouse response, you get the mouse icon, you drag it into that, right? And you have a new icon. That's kind of the flow that O access me uses. Now what we are going to do is we go to start, I will switch back to this get started thing. We're going to start with the extended template, the second one, and that's kind of nice because the extended template already has a pretty complicated structure that corresponds to what most cognitive experiments, the structure of most cognitive experiments, right? Because cognitive experiments tend to be quite stereotypical. So I double click on it, it asks me if I wanna save my own set changes, I don't. And there we go. And you see that immediately the overview area becomes quite full, right? Okay, now take your time. So what we have here is an experiment that starts with a practice loop. So it gives the participant a little bit of a practice thing. Each practice loop consists of a practice block, right? So it's really hierarchical. We have a practice phase, which consists of multiple blocks. And each block in itself, maybe I'm getting ahead of myself. Let's discuss it from the bottom, see. At the bottom, we have a trial. And the trial is just a sequence of something that is shown on the screen followed by collecting keyboard responses, as if followed by a Lord, something that records the data, right? We're gonna change that, of course, but that's the default trial when you use the extended template. Now, we want to execute the trial multiple times, right? Because we wanna repeat trials. So the trial is in a block loop. And the block loop is a block because a block is nothing but a bunch of trials, right? Repeated trials. So it's collapsed. Before each block, we reset the feedback. We do that because generally, if you wanna give participants feedback on how well they are doing, we wanna do that for every block and not like a run in total for the entire experiment. So we reset the feedback at the start of every block and then at the end of every block, we say to the participant, okay, you did so and so well. So we start by resetting feedback, then we have to rerun a block of trials and then we give the participant feedback. That whole sequence is part of the block sequence, right? So the block sequence is resetting feedback doing a block of trials, presenting feedback. We wanna do that again multiple times, usually, which is why this whole block sequence is again in another loop, which is called here the practice loop. So there is a pretty deep hierarchy here, but it's also pretty simple and it kind of corresponds conceptually, I think, to how we tend to think about the experiments. Now, let's see what the first step is. I think we're going to, yes, we don't wanna have a practice loop in our experiment. For some reason. So we're going to select the practice loop and then we're gonna right click on it and then we say delete or permanently delete all the inputs. Delete will do just fine. Yep, for a supreme, if you have the fresh version. Okay, now, if we don't have a practice phase, then this little end of practice message is also not very sensible, right? So we do the same thing, select it and we say delete. Okay, there we are. So now we already basically have the kind of the structure that we wanna have for our experiment, right? We have an experimental loop, which consists of a bunch of blocks which start by resetting feedback, running a block of trials and then giving feedback. Each block of trials consists of multiple trials and then in the trials, certain things happen which we will specify later. So that brings us to the end of step one. So are you guys with us? Yeah, if you wanna connect yourself to the power, are you've already done that, right? Good. In step two, we're gonna define our independent variables. So the independent variables are those variables that we wanna vary ourselves, right? We have deep, well, maybe insulting your knowledge a little bit, but just to be clear about that, we have the dependent variables, the VD, the variable dependent that you record like response time, accuracy, but can also be physiological measures, et cetera. And you have your independent variables which are the things that you manipulate, generally the factors of your experiment. So we're going to define our, we're going to click on the block loop and that's where we're going to define our independent variables. Because if we define it at this level, every trial will have a different, well, let's first do it and then explain it. So what are, so what are two main independent variables? Anyone? You know what the main independent variables are. So it's the prime and the queue. It's the prime and the queue. Yeah, exactly, exactly. So we start by, we start by clicking, we have a full vectorial design, I should say that again. And if you have a full vectorial design, there is the variable wizard which generates this pretty quick. So if you click on a variable wizard, you get another table. And this table is specifically designed to create a full vectorial design using the following logic. In the top row, you indicate the names of the things that you want to, the names of the variables that you want to create. So we'll create the, let's see, whatever they call there. Okay. Well, let's just call them, let's start with it. You just use the English words, say queue and target. So sorry, it's not a queue, right? I tend to call it a queue, but it's a prime. It's a prime. I'm a queueing guy, I do queueing experiments, but this is a primary experiment. So, and we have two primes, namely, animal and XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX We have six targets, namely, porta, soir, lapin, chen, it's a match, and let's say, lapin because lapin apparently is an absolute word. And that's it. Now, if I click on, if I click on, okay, what will happen is that Obsessimule will automatically create a full vectorial design. is 2 by 6 full factorial plan. Now this also shows that you can think of your design. You can choose how you want to conceptualize your design. First, during the presentation, I said, well, this is 2 by 2 design because we have two primes and we have two types of targets, which is true in a sense because the targets are either words or non-words. But if you really want to specify the details of your experiment, it suddenly becomes a 2 by 6 design, right? Because our targets actually essentially have three words, three non-words, so we have six targets. That's another equally valid way of specifying your design. Or you could say we have a 2 by 3 design because we have two primes, two targets, and each target has by itself three examples, in which case it would become non-public fast 2 by 2 by 3 design. So each of these ways of specifying your design kind of has its own advantages. For specifying your design in the software, you are as precise as possible usually. When you specify your design when explaining the logic behind your experiment to your colleagues, you tend to choose a more simpler way to describe your design. So I would say to my colleagues that this is actually a 2 by 2 design. I have a question. Is there any importance of the order of the columns? Because in the tutorial, you put it the other way around, so there is no need to be this. OK. The order of the columns doesn't matter. OK. Excuse me, sir. If I go correctly, you can specify different ways of your experiment. So in that respect, for me, it would be better to have prime and target like word and reward. And then items would be six items. You could do that as well. Well, I think for our purpose, for trying to run this experiment, this is fine. But I just wanted to make the general point that there were different ways in which you can think about design of your experiment, either at a high level, like saying only caring about the fact that you have words and non-words, or at a very detailed level, really caring about the fact of how many words you have. And the detailed level is what you need, if you want to actually implement your experiment. Yeah. If you are in the exercise, for example, if I choose the higher level, so prime and reward, then I have to specify all the items, right? Yes, of course. I would create an extra column specifying if it's a non-word or word, actually. That is perfectly sensible. Let's do that. Yeah. I don't know, is that actually in the tutorial as well? I don't think because, yeah, you're not doing analysis. But if you would, Daniel would do it. I think it would be word targeted non-word, right? And that just is only the three per column. So let's, I think Daniel is right. Like, just to make sure that we say, OK, we get a variable called category. I think, good name, and we say, OK, this is a word. This is a word, this is a word. This is a non-word. You can copy and paste too, well. And then we select, copy. This would be, like creating a column is fine. It's mostly for logging though, right? It's not, we're not really going to use that in the experiment itself. But if we're going to work with the data file afterwards, it might be nice to already have this coding there. And then we're going to add another variable, which we are going to use in our experiment. Namely, the correct, sorry, the correct response. So I say, add variable, correct response. In English, so with the s, not the response, response. We say, OK. And then we indicate for every target what the correct response is. And this was an m for the words. And a q for the non-words. So we're pretty redundant, huh? Yeah. Because we've specified that there are words and we specified also what the correct response are. Yes. So it's pretty redundant, but it's fine. I mean, there's nothing wrong with it. That brings us to the end of Etab Deux. Is everyone with us? Yes, we're good? One more question. People already have been, for example, Excel file with my table with all the words. Can I import it or do I have to type it in? Yes, you can. Well, you can copy and paste it from Excel into Open Sesame, but it's not as convenient as it should be, maybe. And in the next version of Open Sesame, there will actually be a pretty sweet way that you can just link it to an Excel file and it will read it directly from an Excel file. But like, for example, you can copy-paste it in here, but you cannot copy-paste the column headers. So that's what's not very convenient. And you have to make sure that the table is the correct size in advance, I think. So it's possible, but it's a bit of a hassle. Okay. I don't know why. It cannot be the 72. Great. So, what we're going to do now, in step three, is we're going to build our trial sequence, which is generally the exciting part of your experiment. So what our trial sequence is going to look like is, as I showed you before, right? Yep. It starts with a fixation dot. So that fixation dot will be in open sesame a sketch pad, because the sketch pad is the type of item that you use for visual stimulus presentation. It will be followed by the prime, which is the word, which is animal or in the axis, followed by a blank interval, followed by a target word, and all those four things are sketch pads because they're all visual stimuli. Followed by a response collection item, for which we're going to use keyboard response item in open sesame, followed by a saving the data file, which is done by the logger item. So basically, we can just take this graphical trial sequence, pretty much rotate it 90 degrees, and stick it into open sesame. That's it. So we already, if I click on trial sequence, you see we already have one sketch pad, but we want to have four. So we just get one more sketch pad, we drag it into open sesame, we low it up one, two, three. If it's kind of fidgety, if you, for example, you're working with a super high resolution display or whatever, it's kind of annoying to drag it, there's also this plus icon that you can use to append new items. That's the same thing. Now, and then we're already, essentially we already have the structure because we have four sketch pads for our visual things, followed by keyboard response, to record keyboard response, followed by a logger to write the data to file. So open sesame does not automagically write the data to a file. You have to explicitly tell open sesame to do so by inserting a logger item. Okay. So even though it's pretty complete, what is very, very, very wrong with this trial sequence? Anyone? You guys got to interact a little bit. What's wrong with this trial sequence? What makes it ugly instead of beautiful? Names? The names. Thank you, Daniel. The names, the names are really ugly, right? I mean, this is really asking, if you have like, and I see a lot of people do that, they just never choose proper names, they just stick to default, it just dirt your experiment into a mess. So always make sure that you choose proper names. So what we can do, we start by, the first one is a fixation dot. So you can just right click, say rename, and say fixation. The second one is the prime or the amos. We rename it to prime or amos, whatever you prefer. Then we have the interval. Rename it. Interval. And then we have the target. And now it's pretty instead of ugly. Now it actually makes sense. And it tells us what the trial sequence actually does, which is really important. One more thing that is kind of important to occasionally do, is save the experiment. I haven't done it now so far, so I said just save. I said, okay, well, tutorial, just so that you have, you know, okay, so the computer crashes or you run out of battery power or whatever. Okay. That's it. So now we have created this trial sequence in the sense that the trial sequence has all the items that we need, but the items themselves don't do what they should do yet, right? We kind of created the skeleton, but we have to fill in the skeleton of this trial sequence. So we're gonna start by clicking on the fixation dot. Oh, click on it. And it will open this thing here. And what you see here is really like open sesame really has a sort of a very simple paint-like thing that you can use to paint your visual stimuli, which is quite nice, I think. Say, for example, you wanna draw a square, you just click on it, you say, okay, you wanna draw a square, I wanna fill it, I wanna make it blue or purple or whatever. So that's pretty nice, I think. But we don't really wanna do that. Sorry, I selected press delete. We just wanna show this boring little fixation dot. So in principle, the fixation dot is fine, but if you look here at the duration, you see that it's set to zero. And that means that open sesame will present the fixation dot, but it will move on immediately to the next item in the line, which is gonna be the prime. And then the fixation dot will be immediately overwritten by the prime, which is not what we want, right? We want to show the fixation dot and then wait for 500 milliseconds. So we're gonna change this thing to 500. But that's it, other than that, this sketchpad is pretty fine. Okay? Done? Do you have a function like that things would disappear when you're in your stunts or something? Like that the iteration is dependent on? Yes, if you would wanna do that, you would simply add a blank sketchpad after a keyboard response. So the keyboard response will block. Will block, will not do anything basically until you give a response or until a time out occurs. If you then add a blank sketchpad after it, it will have the effect of blanking the display as soon as you get a keyboard response. If you wanna do more kind of what people ask quite often is doing things in parallel, kind of like combining, presenting visual displays and collecting keyboard responses in kind of a complicated way. If you wanna do that, but we're not going to go into that for this tutorial, you need what's called a code routines plugin that kind of like allows you to do things in separate tracks. But that becomes quite more complicated quickly. But just removing something when you give a keyboard response is just a blank. You know what? Let's do that. Let's actually get a key, get this one, a new sketchpad and put it behind the keyboard response. We call it blank, nothing on it. We say up, zero duration because we don't want to hold up the experiment's blank display. Now adding a blank display at the end of the trial can be convenient if the trial takes a little while to prepare. Like say, what happens is the trial is running. Then it prepares the next trial. But say that it takes for some reason because you have super complicated stimuli that this takes 500 milliseconds, which will be super long, let's say. Then it can be nice to add a blank display to the end of the trial so that the trial ends immediately and you don't like see the end of the last thing in your trial sequence during the inter-trial interval, if that makes sense. So let's do it. Okay, let's move to the prime. So what we want to do in the prime is show your prime. But the prime is not really a direct text, right? You can select text always, you can say, okay, I want to type animal. That will work, but it's not really what we want to do, right? Because we don't want to show animal on every trial. Does anyone know how you do that? How you present something that is defined by a variable? If you prime it between the square brackets. Exactly, and so you do in obfuscation. So we select it, I select the tool, I double click on it, and instead of typing literally animal or typing literally x, x, x, x, I type between square brackets, prime, and then I say, okay. So what this means is not that obfuscation is literally gonna show on the display square bracket, prime, square bracket, but it's gonna show whatever the value of the variable prime is, right? Okay, that's kind of nice. And it has also a certain duration. Oh, the prime is only shown for 100 milliseconds. So instead of a duration of key press, which means like show this until you press a key, we change the duration to 100 for 100 milliseconds. And then I save the experiment. Right, all right, all right. Are you all with me? As you are, it's pretty simple. It's pretty simple, but it's an actual experiment. It's an actual fully working experiment. Okay, yes. And Lordja obviously, she made in figure 12, she made a very quite nice depiction of what the logic behind this kind of variable text is. Yeah, so now we move on to the interval display. I have a very ridiculous question. How can you move it on the screen? Like when I click on it or dragging it, it opens each time you wind up or writing something. Yeah, so you see, so here on the left side, you have different tools. If you want to edit or select an existing thing, you click pointer tool and then you pick it up and you can, for example, move it like this. Or you can double click it to open the thing. If you have not, if you select something else, it will like, if you select, for example, the fixation build and I click, it will just draw fixation build on top. And you can also do right click. Up, up, sometimes it's a bit fidgety. I have to even have to, up. Okay, you can also do right click on it. And you have a few things, for example, raise to front, raise to bottom, and the other important thing is the fixation. All right, all right. Okay, so the interval. So what do we need to do for the interval? Just the duration, exactly. Just the duration. Because it's blank and it should be blank. And so, and we present the duration. So it should be a second year. So just as a sort of a more theoretical question, why shouldn't we present like a fixation build here during this interval? Well, why should, why, I think most people would say that's kind of a sub-ultimal thing to do. Come on. What would happen if we present like a fixation build or any other kind of stimulus here in this interval? It would mask the prime. It would mask the prime, exactly. It would mask the prime. We would get backward masking. So we don't want to do that. And we would get forward masking of the target as well. Okay, yeah. So, to the target. So what do we need to do for the target? The target, the idea for the target is kind of similar to the primary. So what do we need to do? Just put the text box and we write in between brackets, target. Yeah, exactly, exactly. In between square brackets, target. Okay? Are we done? No. No. Just change the duration. Exactly. And this is where it becomes a little bit counterintuitive. So we have to change the duration. But we have to change the duration to zero, which does not mean necessarily that the target is only shown for zero milliseconds. What it means is that the target is shown. And then immediately with the zero millisecond delay, open sesame moves on to the next item, which is a keyboard response. So it means like show it and start collecting keyboard response right away. That's what it means. All right. So in the duration set to the standard it says duration and keyboard. Key press? That's the default duration. What would it do if you leave it like this? It would, yeah, that's one of the, actually that's one of the, I suppose least intuitive aspects of it because what it means is show it until you press a key. Yeah. If you then have a keyboard response after as well, it means show it until you press a key. Then the participant presses a key. The experiment moves on to the keyboard response and waits for another key press. So what obviously people are inclined to sort of leave the target at duration key press because they reasonably think I wanted to be shown until they press a key, which is true. But you can think of it like if you add key press in the duration box, the target sort of automatically becomes a sketch pad plus a keyboard response behind it. But because it's such so common that people, for example, wanna show a whole bunch of instructions where you have to press this space bar every time after every instruction screen, you can add a key press duration so that you don't have to do sketch pad, keyboard response sketch pad. But bottom line, don't use a key press duration for actual response collection. Okay. Yeah, so this is not in the tutorial, I think. But I think it's never as useful to take a look at the keyboard response. All right. So we have a few fields. We have the correct response. Here you can, if this is empty, it will use the correct underscore response variable that we define ourselves. If you put between square brackets, the name of some other variable, it will use that. But usually it's kind of, it's fine just to define your correct underscore response variable, which we did, right? Remember, in the block loop, we have correct response here. Yep. This will be automatically used to define correct response because we don't specify anything else. The allowed responses is a semi column separated list of all the responses that the participant is allowed to press, which are the M and the Q in this case. The participant can also press escape, in which case there is like a, you will get like an escape screen. That's always, always possible. You cannot do that. But all other keys than M, Q, and escape will be ignored now. And then we have the timeout. And the timeout right now is infinite, so the participant can take an infinite amount of time to press a key. I think usually it is a good idea to select a reasonable timeout. What do you think a reasonable timeout is for a lexical decision task? Come on, you. A second? Sure. That's pretty, that's pretty hard. A second? Okay, second. I would say like, fine, okay? No one participating in your experiment then. You didn't know it? Okay, I did. Now the flash pen and key presses thing, what that means is that like, say that the participant is during the whole, like during the things that are presented is pressing keys. The participant shouldn't obviously, but maybe he or she does anyway. Then if you have this box ticked, all those buttons that are kind of lindering in the computer are discarded and the obsesim will only respond to new key presses. That's usually what you want, right? Okay, then we have our blank display, which is just blank with a zero generation. Then we have our logger. Now, the logger is by default, obsesim logs all variables. Obsesim has a certain level of introspection. It can tell which variables have been defined and it will log those, all of them. And that's a lot. I usually leave it like this because I don't really see any reason why you don't want to have a big data file, but say that you don't want that, you can say, okay, I disable it. And then what you can do is kind of nice. You have this, if you click here, you have the variable inspector. Fine, enable this. You see that it has a list. Well, my screen is a bit small to actually show all of it. It has a list of all the variables that obsesim is aware of. What is the variable inspector? It is hidden behind this thing that is called show variable inspector. By the way, if you guys are starting it for the first time, there may be like a thing below called the debug window, which takes up a fair amount of the screen and you're not using it. So you can use this ladybug icon to toggle it. So the debug window is actually an iPython interpreter, which may not get you excited depending on whether you have ever used iPython. Yeah, so then you can say, for example, okay, I obviously want a lot of response, right? Because obsesim automatically creates the keyboard response automatically creates a variable called response. And I say, okay, I drag this in here. I also want to log the correctness. You want to log the conditions, et cetera, et cetera. So I'm just pointing this out for completeness. I personally think it is generally the more wise thing to do to just log all correctness. But it's a matter of text. Okay, that brings us to the end of step four, I think. To the end of step four, I think. Right? Yes. Okay, what do you guys want to, like it's, we still have 15 minutes, which is more than enough to finish this tutorial. We can take a small coffee break or we can just continue, keep going. What do you guys want to do? Take a break? Who says take a break? And by default, we, all the other people, I guess it's a framing. If I ask the other way around, we'll probably having a break now, but okay. Who doesn't want to have a break? Okay, implicit break. Eric, why does anyone have like questions, more general questions about obsessing or things that you'd like to know for your own research? Yes, I would really like to know how to have, I mean, we were just talking about visuals in like how to define auditory ones and then have it simultaneously visual and auditory. Yes, well, there were two auditory items. You have the sampler item, here this one, that plays back a sound file. And you have the synth item that also plays back a sound file but it generates the sound file itself. So it generates like a B pulse or white noise or whatever it would, like it's a very basic sound synthesis inside. Now, playing it back is simultaneously with showing things on the screen is really easy because you can say, okay, I want to have a zero millisecond duration, which means kind of like in the same sense as the sketch pad, like start playing the sound and move on right away. And the sound just keeps playing in the background. And then, for example, you can show a visual stimulus. So that's pretty simple. And then for duration, for the auditory, it's similar, if my word, for example, is 400 milliseconds, the duration is just starting after presentation for like a duration. Well, the duration for the, that's maybe a bit counterintuitive, but the duration for the sampler and the synth means the time that the program basically waits. The time, so let's just drag in the synth into the experiment. So you have a duration here. Right now, the duration is set to sound, which means like, okay, start playing and stay with this item until the sound has stopped playing. Play the entire sound and then just move on. If I would change this to zero millisecond, it would not mean that the thing is just shown played for zero milliseconds. It means it starts play back and then moves on right away while the sound is playing in the background. Here for the synth, you actually have a length parameter which specifies the length of the actual sound, 100 milliseconds in this case. If you have a sampler, the length just depends on how long the sound is. So audio playback is quite easy. Okay, permanently played. All right. So we are now at a top sync, step five, the block sequence. Yes. Yeah, okay, so actually step five is more of an explanatory step than that it actually does anything. So if you click on the block sequence, what you see is that it starts by resetting feedback, running a block of trials. And a block of trials is what we just defined, right? This block loop, so 12 trials, one with animal, shan, word, m, one with two, shan, well, that's a trial. So we start by resetting feedback, running a block of trials, and then presenting feedback. If you click on the reset feedback, it will just say, okay, you cannot really, there's no settings, it just resets feedback. If you click on feedback, you will see this thing that really, really looks like a sketch pad. But, there's an important difference between the sketch pad, which is this thing, like the white icon here, and the feedback icon, the green one that's right next to it. They are both used for visual stimulus presentation, but they differ in the time at which the stimuli are prepared. And the logic is like this, say that you have a trial sequence, like this one, then what open sesame does to get the best possible timing, is it first says to each of the items, prepare yourself, like prepare fixation, and all these visual items, all these sketch pads will prepare some kind of offline canvas, that's what you think it will, or some, they will prepare what they're gonna show in advance. And then, once all the items are prepared, open sesame says, okay, now run, and then it goes, run, run, run, run. And also, in all the sketch pads, which have already prepared themselves, just need to show what they have prepared, and it goes really fast, so it has very good timing. The downside, what's the downside of doing that? There are many downsides, probably, but say that you wanna give feedback, what's the downside of this strategy? Now it is, if you prepare everything in advance, and you wanna give feedback, it's not... They can take out the next response, right? Exactly, exactly. So, if you wanna take into, for example, you wanna show the response time to the participant, you can't, because the sketch pad was already prepared before the response was collected. So, and that's why there is this feedback item, which does exactly the same thing as the sketch pad, but it prepares itself only at the moment that it is shown, which means that it can be quite slow, usually not noticeably slow, but slower than you would like, but it can take into account what happened just before, which is why feedback is usually shown using this, feedback item, and not a sketch pad item. Now, you see that the feedback item has a little bit of text on it, since your average response time was average underscore RT milliseconds. Average underscore RT is a variable that the open sesame automatically maintains that keeps the average response time up. Your accuracy was act percent. So, act is a variable that obviously maintains with the accuracy in percent. Press any key to continue. So, that's how we give feedback. Okay, that's how we give per block feedback. You can also give per trial feedback, right? But right now we're talking about giving feedback after every block of trials. So, let's move on to step six. La séquence de session, right? So, top level sequence, which is just called experiment by default. Okay, yes. Well, we don't really need to do that much. So, we start, we have, well, we start actually with this, about this template thing, which is just a notepad that has a little bit of information on it. Can go, delete. Then we start by presenting instructions. So, I think instructions are a pretty important part of an experiment, right? Actually, people often do give quite poor instructions, but I don't know, do you know John Duncan? He's a cognitive scientist. Anyway, he did a few pretty cool studies by giving participants difficult tasks to do, and then changing, basically manipulating whether their instructions are given in a structured or non-structured way. They were always giving the same instructions, and they always kind of understood what they had to do in the task, but if they were not, basically, if they were not giving the instructions in kind of like a bullet point kind of way, they just didn't follow the instructions really, even though they could repeat what the instructions were. So, I think that kind of shows that instructions are clear instructions, clear structured bullet point-like instructions are a very important part of the experiment. So, but we're not gonna spend too much time on that, so we're gonna violate this little pearl of wisdom in the same right way. So, instructions, press M, right? M for words, or is it, I think, right? M for words and Q for non-words, or was the other way around? Q for non-words, M for words, okay? Press M for words, press Q for non-words, press any key to begin, okay? And now you see we just leave the duration of key press, meaning that this display will be on screen until you press the key. Maybe like pick a nice font, say okay, see you leave, 32 pixels, whatever. You know, just to make it look nice. You can even use, if you want, you can even use a limited set of HTML tags. I don't know if you know what HTML tags are, or they're kind of a way to add some layout to your text. So, if you put a D followed by a slash B, it means that everything in between should be bold. You see, that works, it's kind of nice. Okay, and the same for the end of experiment, the experiment is finished. Now, all that is not so difficult, all right? You can do that yourself. What is more important is the experimental loop. So the experimental loop, right now, it says here in the information, block sequence will be called one times one is one times in random order. This is not usually what we want, right? We want to repeat the block of trials multiple times. So let's say that we want to repeat it two times, which is still not a lot, but we'll do for now. Then we can do things, two things. We can say either set the cycles to two, in which case you will see that this table will become bigger and we'll have two lines. So say, no, no, no, practice, no, no. Actually, this practice variable can go because we don't even have a practice phase. But if you have a practice phase, it's kind of useful to have a variable indicating whether trial is part of the practice phase or not. This is fine. Another way is to say, okay, we have actually only one cycle and we're gonna repeat it twice. It will have the same effect, right? The difference is more if you say, okay, I have two different cycles and I repeat them only once. You can change things in these cycles. If you say, well, I have only one cycle and I repeat it two times, then all cycles will be the same. So in our case, all cycles will be the same, we just repeat the same block of trials over and over again, so this is fine. Okay, I think it would make sense to kind of do the same thing here for the block loop. You see here, for the block loop, we have trial trials, which is not that much, I think, for one block of trials, right? The more sensible, what is the sensible length for a block of trials, I think? Short trials, 48, 48, I think it's a lot, okay, 48. Now, then you can say, okay, 48 trials and then you can copy-paste the whole thing. It's not very nice, right? It will work, but it's not very nice. So we just leave this at 12, reduce, yes. And we say, okay, repeat each cycle four times and then obsessively we'll say, okay, trial sequence will be called 12 times four is 48 times in random order, which is what we wanted. So then we have 12 times four is 48, times two is 96, trials in our experiment. For the random, there's only random and sequential, right? Yeah. Because I also have it always with e-prime. What if you want a super simple restriction, like go for the same item immediately? We need to put it in code? Yeah, in opposite, well, maybe I'll show you after. Well, I can give you a little preview maybe. So if you go to obsessively 3.1, which is now in development, but I think we're getting there. You see that the block loop is much more fancy to begin with. And it will have, it will support, it supports constraints. So you can say, okay, constrain the maximum number of repetitions of this in this column, constrain the minimum distance between recurring things. And the way you do that is then you have to edit the script a little bit, but it will give you very nice fine-grained control of what you wanna do. So you see obsessively 3.1, which is what you're looking at right now, is in general quite a bit more fancy than obsessively 3.1. But they both, they are, everything that you will learn today will be equally applicable to 3.1. Okay, back. But right now, doing pseudo-randomization is kind of a pain. Yeah, that's it, right? We can test our experiment, basically. Get up, sit, test the experience. Okay, so what we can do to test our experiment, we have three buttons here. We have the quick run button, the orange play button, which will run the experiment in the window without asking any questions. So it doesn't ask the participant number or the log file location, which is usually what you wanna do when, what's your question? Which is usually what you wanna do because now I was just programming the whole thing without running it even once. Usually, of course, when you're programming in your experiment, you're changing something, running, changing, running, et cetera. Then we have the run in window, which runs the experiment in the window, but it does ask you for a participant number and a log file, so it's actually not particularly useful. And the run full screen, which is obviously what you wanna do when you're actually running the experiment. So let's say a run full screen, okay, subject number zero, it's fine. Default location, you can press escape just to use the default thing, otherwise you can select the log file. You see, automatically, it suggests a log file that's just subject number, subject, dash, and then the subject number, right? This case, subject zero. If you run the orange one, it will create a data file. Yeah, yeah, it will create a data file called default log. So here we are, okay, presenting key to begin. Up, sham, up, shut. Yes, you see, now it's so fast, time out so fast, it's actually kind of tricky because even if I don't do anything, I will still like continue as though it is. So I think the one second time I was a bit harsh. But it works, it works, the experiment works. So I press escape, it will ask me, the experiment has been paused and you can press space bar if you just wanna continue, right, or if the participant accidentally pressed space bar and cue to read it quick. Cue, quick, okay. Okay, so that's it. We have a fully working experiment. But it's not perfect, right? It works, but it's not perfect. What in your opinion is kind of missing still from this experiment? What will be like a nice cherry on top? Just kind of for the usability, like from the participants perspective, if you just see how all these things go really quickly, what will make the experiment nicer? No idea? Sorry? Slower? Slower, yeah, slower in a sense. I think it should definitely be slower, yeah. So let's say the keyboard response of time out of three seconds, it's already fine. But I think it's also like in most experiments, it's a good idea to give the very subtle feedback on every trial so that the participant kind of gets some, you know, just sees whether the response was correct or not. Not by playing like a sound, because sounds are kind of annoying. And if you only play, for example, a sound when the participant makes a mistake and basically you're punishing the participant every time, right, which is kind of annoying. It gives a very, makes participants tense, I think. What is better, in my opinion, is to just present a very brief green fixation goal if the participant responds correctly and a very brief red fixation goal if the participant made a mistake. That way you don't mess up the flow of the experiment. It's very subtle, but nevertheless, the participant gets a little bit of extra feedback on every trial, which is motivating, I think, if it helps. So let's do that. So what we're gonna do is basically, after the keyboard response, we're going to add two sketch paths. One is already there, it's called blank, but we add another one, and we go to rename them, we rename the blank one to red dot, for example, and rename the second one to green dot. You can also rename things, by the way, by clicking on the name here. So this also causes a rename. Then, for example, what we wanna do with the green dot is just present the green dot for, say, 500 milliseconds. That's plenty. The participant will register that, it will be, that's 500, green. I select the fixation dot thing here, right? And then I click in the center, and it will be green dot. For the red dot, we do the same thing. I select the fixation dot, duration 500 milliseconds, color red. You can also, by the way, here I just type red. You can select green things like this, or select colors like this, but you can also do more fancy things, like for example, indicating illuminance is just as in value. For example, 128 would be medium luminance. Or you can use a CSS style, 0%, 0%, that's a correct thing. Those are all valid ways to specify colors in Open Sesame. This would be 100% red, 0% green, 0% blue. Those are all standardized CSS three color notations. But just the word red is by far the most obvious, way to do it obviously. So click red in the center. So now I have a keyword response followed by red dot and green dot. So what's wrong with that? Sorry? You need a condition, right? You don't want to show them both on every trial. You want to show them depending on the correctness of the response, of course. So what we can do, click on trial sequence, and then you see that every item has a run if column, which is my default set to always, which means that every item is always run. Most items should always be run, but the red dot shouldn't. The red dot should only be run when the response was incorrect. So we select this and we make use of the fact that Open Sesame automatically creates a variable which is called correct, which has the value zero if the response was not correct and one if the response was correct. And? And between square brackets. Because I can't read it correct. Yes, indeed, indeed, between square brackets. Yeah. So zero and one. Zero and one. So it is correct between square brackets. Space equals space zero. Now the timeout would be incorrect. It would be a zero. If the participant, if a timeout occurs, it's kind of a special situation, in which case the response gets the value non. And it is considered incorrect. And for the green dot, it's of course the same. Well, not the same, but you say correct between square brackets underscore. Or correct between square brackets space equals space one. Okay, so that's it. That's how you kind of define. And these conditional statements, these run-in statements are very simple with a pretty powerful way to sort of control the flow of your experiment depending on which one. The question is, is the software sensitive to space or things like that, for example, between the equal and the variable and equal? No, I don't think so actually. It doesn't matter if you don't put the space between the equal. I don't think so. No, it doesn't matter, no. And you can even, that's good. Well, if you use a space in your variable name, that's not possible, but you get a warning, right? If you use a space in the variable. Yeah, in the variable name. No, that's not possible. No, variable names cannot have space. You don't think so? No, no. No, no, variable names can only consist of letters and underscores. But in these conditional statements, I don't think they're space sensitive, like, but I have to actually look it up. And you can even, if you want, well, we get to that. If you start a conditional statement with an equal sign, then you can have it followed by actual biting code to do more complex evaluations, because that's what you wanna do. This is like a very basic thing. It just allows you to do a few simple comparisons, which you can do, can have quite complex evaluations. Anyway, yes, that's it. That works. Pretty sure that works. Okay, yeah. Now, then we have, now I think that, now the experiment is pretty, it's pretty good. It's a good experiment. But we can make it a little bit more fancy to illustrate another aspect of obsessive. Namely, as it says in step nine, we can vary an independent variable between books. Now, and the example that's given here, let's say that you, right now, we always have an interval of 1,000 milliseconds. You can imagine that a priming is pretty fast and it only works if the prime is presented immediately before the target, but not if it's presented more than a second before the target. So what we could do is we could experimentally manipulate the interval between the target and the prime. So, we could do that within a block, in which case, we would click on the block loop and then we would extend this block loop with another variable. For example, the example that's given here is 1,000 milliseconds and 3,000 milliseconds. So we would basically copy this. We get 24 trials that add an SOA variable or whatever we want to call it, the integral variable with first 1,000 and then 3,000. But oftentimes, you also want to vary things between blocks, right? So you want to have one complete, so if you vary it within block, it would mean that from one trial to another, the interval can change and usually does change. If you vary things between blocks, it means that you first want one entire block of trials with one interval and then an entire block of trials with another interval. And doing things between blocks and within blocks, they have their own advantages and some people prefer one thing over the other. I tend to personally vary most things within blocks, but other people tend to vary things between blocks. So what we can do is basically we go to the experimental loop and then we say we add a variable and we call it, for example, the interval. Then we set cycles to two. Practice still no, 1,000, oh, and 3,000. So, and what we have now is that, right? Block sequence offered will be called one time with interval of 1,000 and one time with an interval of 3,000. Actually, it will be called two times because the repeat is still on two, right? So we now have block sequences called two, two cycles times two to repeat is four times in random order. That's what's gonna happen. Now, so we have defined our variable interval but it's, of course, not automatically used in some kind of a magical way. So how can we use the variable interval to specify the interval? It's really easy. You put interval between the brackets. You put interval between the square brackets. Where? Instead of the 1,000 square brackets. Exactly, exactly. So we click on the interval item and we replace the interval by, we replace the 1,000 by interval between square brackets. That's it, that's it. I think we've gone really quickly. Yes, we've gone pretty quickly. So we have our experiment is entirely finished. So we can give it a quick test run. Run full screen. Now you know what? What I will show you, which is quite nice. So if I show the variable inspector here, it has all kinds of variables in it. Now say that I, for example, click on response time. I will show the response time. And then I run the experiment. You will see that it will actually show that it will keep track of the response time as I do the experiment. And this can be quite convenient, for example, for debugging. Because you can also, in the same way, keep track of what condition you're in trials in, et cetera. So if I start, I say, Shan, okay, M, oh no, wait, so it's Q1. Shan, Q, correct. You see how the things change? Shan, Q, yep, show, Q, all the wrong words. Shan, M, could I make a mistake? Show, M, right? So that's quite nice, right? So you see that the thing kind of updates as the experiment goes along. Which is, which can be very useful. Especially, for example, when you say that you wanna look at the category, you can say, okay, I look at while the experiment is running, I keep track of the category and I see kind of, I kind of verify whether the category actually corresponds to what I see happening during my experiment. You have a question? Okay. Okay, but our little experiment works. So what do you guys say? Shall we, because we're kind of ahead of time, we went really quickly, we can sort of take a, maybe take a, there's an extra section to the tutorial in which we're gonna do the same experiment, but we're gonna use pictures instead of words. Just so that you, do you guys wanna do that? Yeah? To say what the experiment is, please. I mean, how do, I mean, when you say the script's like in a normal route, is there any... To save the experimental script, you mean? Well, the experimental script is... And the responses also. It's automatic, the responses are automatically stuck in the where... So you mean the data file, actually? Yeah, both, well, both, actually. Both, yeah, the data file is, if you have this item, the lower item, it will automatically log all the variables in your experiment, especially if you have this one, this option indicated, log all the variables in your experiment to a data file. And the format of the data file is a comma separated values data file or .csv, which is just, which you can open in pretty much every text editor. So I will, I will show you an example. So say, here we have some, this is actually an experiment that I collected on a tablet. So you have a whole bunch of subject one, .csv, et cetera. If I look at those in a, in a text editor, you will see that they, right? They're comma separated values. So everything is quoted and there's comma and it's the next value, et cetera. But if you just open this in a program like LibreOffice, you will just get a nice spreadsheet, see? And it will show you all the variables on each column and every row is one trial, usually. So it's kind of the most basic, basic. In principle, you can customize your data files, you can log things in different ways, but I think this is usually the most easiest way. All right. Okay. So to work with pictures, we obviously need pictures. You can download some, but are you connected to the internet? We're all connected, good. Okay. If you're all connected, then what are we gonna do? I'm actually not connected. So I can already show you very well. If you go to alwaysdoc.coxci.nl, so the documentation side, and you then click on tutorials, and I'll start there. You will see the amosage category thing that we're doing now. So you will see the tutorial that I've printed out for you. Go there, oh, alwaysdoc. So if I click on tutorials here, and then my amosage category, we just see this tutorial that I printed out. Then if I click on extra, you see that there are, oh, I can actually do this well. Oh, oh, oh, oh. You will see that you can download these, you have these pictures here that you can just download. Save, save link, ask. I'll save them, okay. Save them here, save. You can use any kind of picture that you want, right? But these pictures are kind of in the theme of our experiment. Okay. So now what we're gonna do is we're gonna do, this is a bit of a funky experiment. It's more to illustrate the point of using pictures than I think it's really a good experiment. So what we're gonna do is we're gonna prime, we're gonna use prime that is a, and again, a, yes, we're gonna use, you're gonna prime the participants by showing either a picture of an animal or a, so this would be the picture of the animal prime, and this would be like the normal animal. This would be like the picture equivalent of the axis. And then the participant has to make a cat dog decision, and a cat being this, the dog being this, right? So basically, we prime, and then of course what we predict is that if, if we prime the participant with a little canary, the cat dog decision is faster because we've primed the concept of animals, so to say, compared to when we've primed the participant with a, what's the English word for this actually? Accordion. Accordion, accordion. All right, so that's the basic logic. So the first step, and that's kind of what it did, why this teaches us something new, is to work with the file pool. And the file pool that's hidden behind is this folder icon here. If I click on it, you will see that we have a empty thing. And this empty thing is just a collection of all the files that are associated with our experiment, which currently there are no files associated with our experiment. But if I go to this, this to my file thing, and this works the same if you use Finder in what Finder is called on the Mac I think, right? Or if you use Explorer on Windows, works the same way. You just select the things, the pictures that you wanna have. Check these four for me. And I drag them in here up to the file pool. Oh, this is okay, it's harmless warning. Okay, then I have four files in my file pool. Then, I can go to the block loop and the prime is now no longer the string animal or the string XXX, whether this either an accordion or a wasso, right? So, I change the prime here to, the animal equivalent is wasso, select, or an accordion. And you don't need to put the dot PNG behind it. I'm going to assume that you don't put the dot PNG behind it. The target is still gonna be the same because we still have a shine. And oh, wait, we have a shine and a shot, but we don't have a lapin. And so, and we only have a shine and a shot, okay? So, we're going to adjust, just follow me, we're going to adjust this table so that's lost, yes, right? So, we only have a wasso, an accordion prime, and a shine and a shot. Category is no longer relevant because they're both animals. So, I say remove, I say remove variable here. And I remove the category because the dog and the cat is the category that we're interested in. And then the response rule is that the M is for dog and the Q is for the cat. So, this is the table that we want to end up with, with the prime, which is wasso or accordion, spelled just like our pictures, picture names, right? And the target is shine, shine or shot. And the correct response is M for the shine and Q for the shot. Okay, okay, okay, are we good? Are we working on that? Okay, so, what we need to modify now is first of all, of course, the prime. So, I click on the prime thing, let's hide the file pool on because it takes a bit of space. And the prime is now a string on it. When does drag and drop not work to the file pool? It doesn't? No. Well, then you use the plus icon. Yeah, it's the other option. So, if for some reason drag and drop doesn't work, you can click on plus icon here to add files but through sort of a file browser or a dialogue. But usually you should be able to drag and drop things in the file pool as I just did. Okay, so, what we've done now is we've added these four pictures to the file pool. Here's that. We have changed our workflow so that it is good for our new experiment. And now we're going to change the prime. I click on prime. Prime is currently just the, right? If I would leave it like that, it would just show according to where it was. Which is not what we want. So, I select it and press the lead or right click, sorry, and press the lead. And instead we're going to use a picture. Now, the image element is this one, kind of the landscape, the icon. I click on it. Then I click on the center of the screen. And then I will get like a file pool selection dialog. And now we're going to use that trick that I showed you during the introduction of starting with a prototype display and then making it very good. So, for the prototype display, like one prototype display would be using the accordion. Select. So, this would be a prototype because the accordion is one of the, you know, one of the primes that there is, one of the two primes. But, we don't always want to show the accordion. Sometimes we want to show the waso, the bird. So, what we're going to do is I'm clicking on this thing here. Select, view. And there, here you see that you can view your item in three different ways. You can view the controls, which is what you usually do when you only see graphical things. You can view the script, in which case you'll see the script behind it. Or you can see a little bit of both, which can be kind of convenient. So, if I do that, you see that on the top, I will see just have the same controls I had before. And at the bottom, I will see the script that corresponds to this. I will zoom in so you guys can see it. You see the script that corresponds to this display. And what it does, it just has a duration of 100. It has a description, display stimuli, and it has this draw command. Now, how can we change this? This draw command here, draw image centers, one, et cetera, et cetera, from always statically presenting the accordion to sometimes presenting the accordion and sometimes presenting the bird, the waso. Any ideas? You have to change the file. We have to change the file, exactly. And how? Good question. I suppose you have an image between the brackets. Exactly. So, what exactly would it look like? You know? No. So, for example, just as if I start with this, like prime, is this gonna work? Yeah. Now, because the prime, the way we specify the prime, it's either the string accordion or the string waso, but the files are actually called waso, dot b and g, or accordion dot b and g. So, what should we, so the dot b and g is missing and it won't work. So, how should we change this? Just, you just add the dot b and g, exactly. So, file is prime dot b and g. It will change the prime thing by the value of the prime variable and the dot b and g will just take dot b and g. So, this will work. Okay, so once you've done that, you say, apply and close, and then we're happy. You see that obsesame gives you this little warning. Image named prime dot b and g is unnumberably defined using fallback image. That's just because obsesame doesn't know how to present this, right? It doesn't really have any meaning until you actually start running the experiment. But that's fine, right? It's not an error message. It is just letting us know, okay, something variable is going on here. I don't know how to represent this. Okay, now, and then we're gonna do the same thing for the target. So, we start this by doing the same thing. We select target, which is currently a string which we don't want, so we're gonna remove it, delete, then we select again the image element thing. We click it, okay, we click on the center. And by the way, you will always see here at the top, well, I cannot point that in to show you at the same time, but like here, you see the coordinates corresponding to where your thing is, right? So, you will see that, like, and zero, zero is the center. And you don't have to be perfectly exact because it has like this grid. So if you go up, it will either jump up by 32 pixels instead of that in the center. We're gonna draw a prototype. I'm more of a cat person, so my prototype's a cat. There's the cat. Now, then we're gonna take a look at the script again, so I say select view, split view, okay. So, and how do we check, wait, let's zoom in so you guys can see it. So how are we gonna change this? It's just the same as before, oh, so this is an easy one. Sorry? No, no ideas? We're gonna have brackets and we write target instead of shop. Yeah, exactly. So it's PNG. Exactly. So, like this, all right, that's what you had in mind. Yeah. Okay. And you see again, this kind of this message saying that our variables are in use, but that's fine because that's actually what we did. Okay. Yeah. So that's it. Now, if we're gonna run this experiment, well, we have to change the instruction, of course. So the M word, I think, M word dogs and keyword cats. Dogs, queue for cats. Let's run it. M for dogs, queue for cats. There you go. Prime by it. Interval dog and cat. Correct. Prime by cat. Okay, now this works. It's pretty trivial, huh? Works. Is there something that's structured as kind of subultimal about this experiment? There are many things, well, let's do vague. There are many things that are pretty sub-ultimal. We're focusing on how the pictures are presented. The background. Exactly. The background is kind of ugly, yeah? Because the pictures have a white background and obsessively uses a black background by default. So what we're gonna do is click on what is called the general tab, which is just what you see if you click on the top level thing in the overview item, overview area. And we say background, you need this Y2. Background is black. That works, but all the things that you made white to begin with will stay white. And that applies mostly to our instructions. So the instructions are now white on white, which is not generally what you want. So let's change them. You just select them and make them black. Up. And the same for the end of the experiment thing, which you cannot even read. Okay. Oh, and the same also for our fixation dot here. So if you change the foreground of your experiment, it doesn't automatically change all the things in your experiment that already had a color. But it does apply to new items, right? It does apply to new items. It will be used as a default for new items. But it can be a bit painful if you like have your whole experiment ready and then you say, okay, wait, you know, I want to change the foreground maybe to another color. Okay. And now if I run it, it will be nice. Up. Dog, you, oh no, dog was an M. All right. So now we made two working experiments in the time span of one hour and a half. Granted, we're not like super complicated experiments, but still quite quick, right? Well, that's it. I think we should, we're quite nicely in time. I think, thank you, thank you for your attention. Like if you have, maybe if you are the questions, do you want to have a question round? I think, yeah? Yeah, I got a question in terms of correct response. Can we use another layer instead of M? Yeah, of course, of course. Also with the fixation. Because I'm sure it doesn't make sense to move our country. No, no, no, no, I, I, I, I, I'm, I, yes, so it will, if you click on the blog loop, then in the correct response thing, you can put anything, M, Q, M, Q. Like if you have keys that don't have a name in that sense, for example, the left button, it will be called left. The right button will be called right, et cetera. Space bar will be called space. If you have, if you have like, what we call special characters in kind of a Western-centric way, things that are not Latin characters, they should also work. You should also be able to put them here in the, in the, as a correct response. Like, I don't know, anything, basically anything that corresponds to a character of a, of a keyboard that corresponds. Where things, to, to, that, any character that corresponds to a single key press, where things get difficult, and I don't have, I haven't found any satisfactory solution for that, is keyboard layouts where single characters are composed of multiple keystrokes, right? And that happens quite often in Asian, in Asian alphabets, where you kind of like, you type various things, and like, if you type only one letter, it will have one character, if you type another letter, it will kind of combine it to another character, et cetera. Obsessing doesn't support that. And that's, what, what, for example, I don't think, for example, that's the case for simplified Chinese, or, I don't, what language are you talking about? Cambodian. Cambodian. That is one of those combined, combined character things, right? Yeah. Yeah. Now, that will be difficult. Yeah. And in order to, I'm just saying that, what, what you're gonna, you're gonna provide to, participants, during their experiment, consumer, or, they can do it online, or? They can do it on, on a tablet or a computer. So, an Android tablet, not an iPhone or an iPad, but an Android tablet or a phone, or a computer. And actually, Daniel and I will start working on implementing, trying to implement the beginnings of an online runtime, so that it can run in a browser, but I don't see that being, being a realistic option for some time. Maybe just, can you open your, a system of defining the variables once more? Because, I have to, The variable. Yes. This one, the variable. Yes. So the logic is just very simple. Every level that you have here, will be combined with every level that you have here. Right? So if you have two, six here, you will end up with 12 things. So why, when you close it afterwards, you just have it like combined, or you have much less. When I do it this way, then I end up having many more combinations. So it gives me all the combinations. It gives me all the combinations as well, right? Ah, so you, Oh wait, I'm sorry. Now this is, if you click on the variable wizard, it will just have the values for the last time that you opened up the variable wizard. So at the last time I opened up the variable wizard, we were still working on the experiment with 12 levels, remember? So it will, that's why I have two times six, times that. If I wanted to recreate this one, I would say prime, wazo, orion, and only have the sham and the shat here. Sham the shat. Press okay, and now we'll get this thing. See? So it's like a pretty, pretty basic full factorial design generator. Okay. Well, unless there are any more questions, I considered meeting closed. If you have technical questions, I prefer that you don't send them to me by email because I tend to get quite a lot otherwise. But post them here on the support forum, forum.coxsci.nl and you will find a lot of answers to the questions that you have already. But also if you post new questions, you will get answers quite quickly. Of course you can drop by my office as well, right? But like to avoid being overloaded with emails with huge experiences.