Dynamo for Software Developers: C#, Python, and More—Workshop - Part 1 of 4

PRESENTER 1: Cool. So I'm going to be real quick so that I can hand you over to Tom and start the first session, which is on Python. So a real quick summary of what we're going to look at today so you guys know what to expect. And if the clicker works-- it's plugged into yours already. I'm just going to stand here.

So today, we are going to be pretending that we are Spacework, a company that provides office space. And what we are going to be trying to do by the end of the day is subdivide the room with partitions, create a desk arrangement, and measure its efficiency, place desks in a Revit room, and then calculate the escape routes. And then finally, extend Dynamo with an extension that can make this kind of workflow easier. That's a lot of stuff to pack into a day, and it's stuff that we would have to do if we wanted to kind of be a very efficient office space provider.

So to do that, we've mapped these tasks to sessions. And without kind of going into too much detail, they're about Python, C#, Zero Touch nodes, and extensions. So as a very, very brief intro before we go into the first session, we wanted to let you know a bit about development for Dynamo in general. And we saw, we go all the way from Python to extensions and host integrations, like into Alias or Civil.

And this is a graph that kind of shows the relative complexity and difficulty of making one of these Dynamo things, whether a zero touch package or an extension, and the actual power they have. So starting off at the bottom, we have custom nodes, which are very easy to make, but also very kind of limited. You go up to zero touch and Python nodes, which we're going to have a look at. And then extensions are even more powerful, but they're a bit harder to make. And then right at the top, the most powerful, but also the very hardest to make are host integrations, like Dynamo Revit, for example. There's a lot of work that goes into that.

You should all be kind of familiar with how these things look like, but just as a refresher, custom nodes look like they're going back in time. They have this kind of nice fading out icon on the Dynamo canvas. Design scripts nodes are kind of code block nodes. So I'm sure you've seen those before.

Python nodes just [INAUDIBLE] Python script. And if you edit the script, you get a nice kind of visual interface to edit your code there. And then zero touch nodes look exactly like any other nodes, because that's what most Dynamo nodes actually are. So those you write with code, and we import them into Dynamo.

And finally, the last type of development we can do for Dynamo in terms of nodes are the UI nodes. These are nodes that have custom UI on them, so things like the color range node, or things like the dropdown lists that you have in Dynamo Revit. Those are custom UI nodes, which are relatively hard to make because of this thing called abstract syntax tree, which I won't go too far into, but you have to kind of start knowing these things when you go down the UI nodes, which isn't very nice. So we're not going to do them today. We're going to do other, more fun stuff.

So putting it all together, going from left to right, kind of from easy to harder, we have custom nodes, code blocks, Python scripts, zero touch, UI nodes, and then hovering somewhere behind this are our extensions. How many of you are familiar with extensions? Not that many. So maybe I should introduce what they are.

They are kind of a new addition to Dynamo where you can extend Dynamo itself. So rather than write code to make a node, we're putting a plug-in into Dynamo, where we can control Dynamo itself, and the graph, and the user interface. So you can do things like, I think this is DynaMonito. Yes. By Andreas Dieckmann. He's also made Clockwork, where you can zoom into error nodes or all of the nodes that have warnings. You can really speed up your Dynamo offering.

Other examples are-- shameless plug-- this Dyno server extension I made, which lets you remotely control Dynamo from a web browser. So I've put a little server inside Dynamo. And I could be halfway around the globe and be sending commands to my Dynamo application. Oh, run this graph, or clear that workspace and load a new one. So very powerful. You can think of lots of use cases for this.

Crash course into development. So now we are going to hand it over to Tom for the first session on Python. I don't think you need that. Do you? Oh. Disconnected the--

Whilst Tom is plugging in, if you guys have questions at any point during the workshop, raise your hand. Either me, Racelle, or Keith, or Erin will come and kind of help you out. Also, if you have a general question, just raise your hand and shout it out.

TOM: Good. Thank you. So yeah, good morning, everyone. And welcome to AU Vegas 2019. As you know, I'm Tom. I'll just introduce myself again very, very quickly.

So I run Biomorph. It's a digital engineering company. And I typically develop apps for either Dynamo or Revit. [INAUDIBLE] apps for organizations thta are in construction that want to automate their processes. And it can range from, say, applying comp sci techniques, all the way through to comp design, comp bim. And really, a lot of this has been kind of informed through my career as an architect. And I kind of migrate into doing what I do today, which is basically program every single day.

So I've got a lot of experience using comp design tools like Dynamo. Also other applications like [INAUDIBLE] Components for many years. And I've just got a real passion for it. So hopefully by the end of today, both [INAUDIBLE] and I will be able to kind of share some of our knowledge and some of our kind of pro dev techniques, and really help you guys to kind of kick start your kind of journey into programming.

Because that is actually what it is. You never stop learning. And it's incredibly rewarding. So I would encourage all of you, even if today you find it a bit difficult. Because it can be very difficult. You don't learn programming overnight. It takes a long time to perfect. It's like really any kind of discipline. But yeah, stay focused, because it is really an amazing skill to have, certainly with within construction. And it can really augment what you do on a day to day basis.

So to kick things off then, we're going to start with Python. Python itself is actually a very easy language to learn. Part of the reason why is the syntaxes are very clean. It's very readable. Python, it's almost like reading English. That's how the syntax actually appears. And it's a very powerful language.

It's generally pretty quick so when it comes to execution. Although, C# actually gives you a performance edge. It depends on what you're trying to do. So today, in this first session, what I'm going to introduce you to are some professional techniques for using Python within Dynamo. It uses a variant of Python called Iron Python. And the only difference being it can read and understand something known as .net libraries.

So, for example, the Revit API is a library. And in that library there are all methods which you can call. And that library is built on .net. So if you're just using ordinary Python, it can't read that library. If you're using Iron Python, it can, which is why Dynamo uses it.

But really, there's no actual major difference in the languages. So the first exercise then, which I'm going to get all of you to do, is, first of all, configure something called Visual Studio Code, which is just an IDE. So that is an Integrated Development Environment. And generally, that's what programmers use to help structure their programs. So when they're writing their code and they're organizing all of their various different documents, they'll use an IDE. And a really, really powerful and useful IDE for Iron Python is Visual Studio Code.

So we'll get that set up in a second. It's very easy to do. I'll also introduce you to something called a boilerplate, and also teach you some little shortcuts, which all good developers do. And then we're actually going to start doing some basic code, and then gradually kind of ramp up, throughout today, the exercises.

So they're gradually going to get more and more kind of interesting and more complicated. But all the data sets are on GitHub. They're all freely available. So if you do find that perhaps you're struggling, or if maybe you just want to sit back and watch, by all means, do that, cause you can always redo all these exercises in your own time, and drill into it and understand it. And, of course, if you've got any questions, ask Radu, myself, or any of the other guys from Dynamo, or on the forum as well. That's really active as well.

OK. So first of all, the first exercise. It's going to be really straightforward. All we're going to do is we're going to learn about some built in functions within Python. We're going to simply select some desks in our sample project file. And we're just going to get our Python script to tell us how many desks we've selected.

So you notice I'm just using some out of the box nodes here. If I go ahead and select some desks, it's going to tell me how many there are. Dead simple. And really the purpose of this first exercise is to actually introduce you to some of the core concepts, and kind of like a foundational understanding of how Python is implemented into Dynamo just to kind of get you guys kickstarted.

So without further ado then, within the data set, if you can just make sure that you've got this file open. So it's the AU 2019 S1 Python file. You'll find that if you just log into the cloud environment, go to the Dynamo For Software Developers folder. Inside Python, you'll find a file called AU 2019 S1 Python. And if you just open up that file.

AUDIENCE: Can you run through the file again?

TOM: Oh, yeah. Sure. So if you open up all the sample files for our workshop, you'll find S1 Python, which is what we're doing now. So this is the first session. S2 C# Fundamentals is what we're going to be doing for the second session. That'll be Radu. Then we'll do S3 Zero Touch in the afternoon. That'll be me. And then finally, we're doing extensions, which is S4. And that's what Radu will be doing.

So inside the first folder, the S1 Python folder, you'll find the complete data set, which you guys don't need to touch, because that is only if you just want to, perhaps, sit back.

PRESENTER 1: Two seconds, Tom. So if you're struggling to find where the folder is, there should be a shortcut on the desktop called Data Sets. If you double click that, it'll launch you into a very long list of folders. Look for something starting with DW. And then it says Dynamo For Software Developers.

TOM: Thanks.

PRESENTER 1: I feel like I'm struggling.

TOM: OK? OK. So if you're already there--

PRESENTER 1: [INAUDIBLE]

TOM: Yeah. That's what I'm going to do. Yeah. Thanks.

AUDIENCE: [INAUDIBLE]. There are two folders [INAUDIBLE].

PRESENTER 1: If there's two folders, pick the one that's shorter. Not the one that says C# Python stuff. The one that just says Dynamo for Software Development.

TOM: Yeah.

OK. So if everyone is there, if you can also launch Dynamo. And inside the same location where you opened up the Revit file, you'll find the folder called Start Data Set. And in that folder, there's something called the boilerplate, which we'll use in just a second. But if you just go to the DYN folder, and if you just open up Exercise One, DYN. And you should see a graph that looks like this.

OK. So this graph then, you can see that there's a Python node already there, which is going to be reading our code, which we're about to write. There's actually two different Python nodes which you can use within Dynamo, which I'm sure a lot of you are probably already aware of. There's the ordinary Python script, and there's the Python script from string.

We're going to be using the Python script from string. Reason being, that's actually how we can get that node to read our Python files, which we're going to be developing within Visual Studio Code. You can, of course, just use the ordinary Python script node. And if you do want to use that, you can double click on it. And then from there, modify your code through the editor.

But generally, this is actually not as flexible when it comes to actually developing your code. So there's the first pro tip. That's why we would use Visual Studio Code, because what we can do is we can actually create a range of different Python files. They're easy to then distribute. And we can also add a lot of other useful files inside our IDE, which we can always reuse, which we're actually going to be doing in just a second. And I'll show you that as soon as we get on to that step.

So to actually explain then what we're doing here, we're going to be browsing to a file which contains Python code. That file's going to be read, converted into a string, and then it's going to be passed into our Python script from string node. And that's going to execute a process for us.

So if you jump into Visual Studio Code, what I'd like you to do is, perhaps on your desktops, create a new folder. And we're can just call that folder AU Vegas 2019. And within that folder perhaps create another folder. And just call that S1 Python.

So I've already got my-- or I'll create it now. So yeah. Just a new folder. And we'll just call that AU Vegas 2019. And in that folder, we're just going to call this one S1 Python.

So this folder, S1 Python, is where we're going to store all of our code files which we're going to be developing today. And within Visual Studio Code, what we're going to do is we're just going to reference this folder by going File at the top there, and then Open Folder. And we just want to browse to this location, and then select that folder. And this just tells Visual Studio Code that the folder which we're about to open is going to contain all of our code.

OK. Right. So one of the first things which is really useful to have at your disposal whenever it comes to developing within Python is something called boilerplate.

PRESENTER 1: Tom, can you repeat again from making the file in the folder.

TOM: Yeah. Sure. So on your desktop, just create a folder called AU Vegas 2019. That's just going to be our folder for today where we can just develop all of our code.

So on your desktop, once you've created that folder, create another folder inside AU Vegas 2019, and just call that one S1 Python. And once you've done that, in Visual Studio Code, you just want to do File, and then Open Folder. And then just select that folder there. So S1 Python.

And when you do select that folder, and when you actually find it, just click on the folder. Do Select Folder. And then that will then load it into the Explorer on the left. So you'll know that you've done it correctly, because you'll see S1 Python in the dropdown there.

All right. Is that OK? OK. So this concept then of a boilerplate. All a boilerplate is is it's essentially reusable code. It's a term used mainly in programming. And that reusable code, for our purposes, basically contains a range of different import statements, which I'll explain in a second. Which basically just loads in things like the Revit API into the Python interpreter. Cause the interpreter's what actually reads your code and executes on your behalf all the instructions which you've written.

And you need to tell the interpreter where to actually look to make certain commands, or [INAUDIBLE] certain commands. So, for example, if you want to build a wall, programmatically use the Revit API, you can't just make a call to API and expect Python to know where to look, because that call could have come from anywhere. So in the import statements within the boilerplate-- and I'll just show you that now-- you'll actually see a reference to the Revit API. And that's what you can see up here.

So you've got a range of numbers that are being imported, proto geometry, which is from Dynamo, Revit nodes, also from Dynamo. And then here you've got Revit API. And all you're doing there is you're just telling the Python interpreter to load in those libraries. And then you can make calls to those libraries to do really cool stuff.

So that's what the import statements are for. Generally, with the boilerplate you don't even need to learn these things. Literally just have the boilerplate at your disposal. And then every time you want to start writing a new Python code, you just copy and paste your boilerplate into a new PY file, and then you're good to go, which is what we're going to do now.

So inside Visual Studio then, if you go back to your S1 folder, what I'd like you to do is from the data set you'll find there is a file aptly named Boilerplate. What I'd like you to do is just drag it into here. And that's going to copy the boilerplate for you. So all I've done is just found a file from the data set, and then just drag it over into the Explorer. And that's going to create a copy of the boilerplate for you. And now you can view it within Visual Studio Code.

And the boilerplate should just be left as is. And you should always just copy it into a new file, which is, as I said, what we're about to do in just a second. OK. Yes. OK. Yeah, thanks.

OK. Next step then, we're actually going to start writing some code. Now, this is the technique which you need to learn. Whenever it comes to writing any Python code, you should always just copy that boilerplate. So what I'd like you to do is where you've got your AU Vegas 2019 and you've got the option for a new file, click on that. And inside here we're just going to call this Exercise1.py. So you just need to tell Visual Studio Code what kind of code file that is. And for Python, it always uses the PY file extension.

So this is actually just a raw Python script. And we're going to be loading that into Dynamo. And that's what our Python from string is actually going to be reading and executing. So as soon as you've done that, you'll notice that you've just got like a blank canvas. And as already mentioned, the boilerplate, go back to it just by clicking on it within the Explorer. We just do Control All, Control-C. Go back to Exercise1.py, and just paste it in there.

So that step that I just took of copying the boilerplate and pasting it into an new PY file is the step that all of you should be taking every time you want to start writing any bit of Python code. Because it just basically configures that script so it's compatible with Dynamo. And then it's going to be reading all the various different libraries, which you're typically going to be calling from when it comes to writing your code.

And don't forget, the boilerplate only contains a few libraries. There's nothing stopping you from also referencing any other library out there which you can think of. I mean, you could even, in theory, develop your own set of, say, zero touch nodes, which are going to be compiled libraries, which, as you know, you're going to be learning today. And even import that into your Python scripts.

I mean, as an example, I've developed Bimorph nodes for Dynamo. That's a compiled library written in C#. And on the forum, sometimes users want to be able to write in Python and make calls to Bimoprh nodes by importing the library. And they can do that very easily using this technique.

AUDIENCE: [INAUDIBLE]

TOM: Ah. OK. Sure. OK. I'll let everyone just catch up a bit as well. So while you're catching up, what I will do is maybe just kind of give a very, very kind of brief, I guess, overview of what these import statements are actually doing.

They are literally just finding a DLL library on your computer. That library will contain a bunch of instructions to do stuff. So let's just take the Revit API as an example. There'll be methods inside the API that enable us to build a wall, or place a family instance. And those libraries need to be imported into your Python interpreter. And when it's in the interpreter, you can then tell that interpreter to go and do something for you.

So you might write an instruction saying, place a desk instance in my model. And to do that, you need to import the library. Yeah.

AUDIENCE: [INAUDIBLE]

TOM: OK. Can I just have a raise of hands as to where everyone is at? First of all, has everyone managed to get their folder into Visual Studio Code?

OK. Does anyone want to catch up now? Cause if you do, then [INAUDIBLE], go ahead and do that now.

Has everyone copied the boilerplate into their S1 folder? OK. Cool. And has everyone created their brand new PY file called Exercise1 and copied the boilerplate into there?

OK. Good. All right. Is anyone--

AUDIENCE: [INAUDIBLE]

TOM: That's just the folder. This one here. So you've got the S1 folder, and then these two files here. Yeah.

AUDIENCE: Tom, can you zoom in [INAUDIBLE].

TOM: Yeah. I can't zoom in for some reason. It's not allowing me to do it. I don't know why. Ah, there we go. Is that better?

AUDIENCE: [INAUDIBLE]

TOM: More?

PRESENTER 3: OK. If anybody's not at this point, can you raise your hand and we'll come and help you? OK.

TOM: OK.

[INTERPOSING VOICES]

TOM: Yeah. Sure. So just to clarify where that folder should be, on your desktop, well, just create a folder called AU Vegas 2019. Inside that folder, create another folder called S1 Python. My folders are a little bit in disarray on my desktop. But yeah, AU Vegas 2019. And then a new folder in there called S1 Python. So your folder should look like this.

What's the status, [INAUDIBLE]? Am I going too fast?

[LAUGHS]

[INTERPOSING VOICES]

TOM: OK.

PRESENTER 1: Particularly this.

TOM: Yeah. OK. All right. Should I give everyone two more minutes? Should I give everyone two more minutes, or should I carry on?

PRESENTER 1: Like one minute and [INAUDIBLE].

TOM: Yeah. All right.

You can if you want. It actually makes no difference. Yeah.

PRESENTER 1: Anyone else need help to get to this point? No? We're good. All right.

PRESENTER 3: Wait.

TOM: Oh, right, it is in the corner over there.

PRESENTER 1: One more. All right. Yeah.

PRESENTER 3: [INAUDIBLE]

TOM: Yeah.

PRESENTER 3: [INAUDIBLE]. This guy is asking me [INAUDIBLE].

TOM: Yeah.

PRESENTER 3: So what was he supposed to do? He was supposed to make a folder on the desktop.

TOM: Yeah.

PRESENTER 3: And then do what?

TOM: And just call it AU Vegas.

PRESENTER 3: OK.

TOM: And then inside there, another folder called S1 Python.

PRESENTER 3: Yeah.

TOM: And then what I want you to do is go File, Open Folder.

PRESENTER 3: Yeah.

TOM: And then browse that location.

PRESENTER 3: OK. Yeah.

TOM: Find the folder. And then Set Folder.

PRESENTER 3: And then where does he get the boilerplate from?

TOM: The data set.

PRESENTER 3: OK. And the data set is?

TOM: From the set frame.

PRESENTER 3: Yeah.

TOM: So if he goes to the data set, it would look like this. Dynamo for Developers. S1 Python. There.

PRESENTER 3: And he just drags it.

TOM: Yeah.

PRESENTER 3: Got it. OK.

TOM: Can I turn up here?

PRESENTER 3: I think it has to be on the-- just try to talk loud, as loud as you can.

TOM: I will try and bellow. I'll just start shouting. OK.

PRESENTER 3: Try maybe recalculating your act [INAUDIBLE].

TOM: OK. OK. I think everyone is kind of up to where we are now. So just to do a quick recap then, we've created a brand new folder called S1 Python. Inside there we're going to be developing all of our Python code. And in that folder, you should have your boilerplate, which we've copied from the data set. And that boilerplate is kind of your Swiss army knife. It contains all of the various bits of code which you need to get you started writing Python code.

And by the way, part of the reason why I'm not going to drill into any detail about the import statements is-- here's another tip-- if there's [INAUDIBLE] disposal, which you can reuse them, all good developers do this. And part of the reason why is because actually it enables you as developers to focus on actually solving a problem.

So when it comes to this boilerplate, I'm not joking. I don't even think about it. I copy it, paste it, and then I start writing my code. I just don't want to even think about it. And all good developers do this. So these are kind of skills which you should learn.

That's not to say be completely ignorant of all these things. It's still important to understand what all of that syntax actually means. But just in terms of getting started, I would recommend that you focus more on actually solving a problem and making progress, rather than, I guess, getting bogged down by all of the nitty gritty details about programming language, because they're vast, and you might find that actually you just lose interest, because it gets boring. Don't do that. Just get into coding. And then as time goes by, learn what, say, more of the nuances of the language actually mean as you start developing as a developer.

OK. So if we're here then, you should have your Exercise1.py file inside your Visual Studio project. And you've copied the boilerplate ever, so we're actually good to go.

Now, this first exercise, as you know, is very, very straightforward. All we're going to be doing is getting our Python script to count the number of desks for us. It's dead easy. And the purpose of this exercise is more just to show you a few things.

So first thing's first, what we're going to be doing is selecting a bunch of desks using an out of the box select model elements node. And from this node we're going to be selecting some desks. That's going to be input into our Python script. And then our Python script is going to tell us how many of those desks there are. So it's dead simple. And this is more just to convey some of the other concepts, which you're going to need to understand for passing data into your Python script, and also passing data out of your Python script as well.

So how this actually works then. Since we know what our inputs are going to be-- it's just going to be some desks-- what I'd like you to do is to where you've got this command line here in your boilerplate, uncomment it. And to uncomment in Python you just remove the hash. So if you want to write a comment in Python, you just type a hash and start typing a comment.

Your interpreter will never ever attempt to execute anything which is preceded by a hash. So it is just a comment. It's for you as a developer just to add some additional commentary to your code, which you can do if it's necessary to do so.

So we're going to declare our first variable. There's actually already a kind of temporary variable declared for you. It's just called T. And all good developers always use descriptive phraseology for their variables. And a variable [INAUDIBLE], by the way, is just a container.

When you declare a variable, you could put anything you want into that variable. And to actually put something in it, you use the assignment operator, which is just the equals sign. So you just do my variable equals, and then any object you like.

And to get a bit techy with you, because I am a bit of a tech head, but I think it's worthwhile just mentioning what that is actually doing inside your computer is actually allocating memory on your machine. And in that memory address, whatever object you've assigned to that variable gets put in there and stored on memory.

And I think the reason why it's worthwhile saying that is just to help you guys actually understand behind the scenes what's happening here. I mean, really you don't need to know that. But I think it's useful just to be aware of, as you're typing code, what is actually doing? And it is doing something. And that's actually what it's doing.

So a variable, it just allocates some memory. And in that memory you can store objects into it. That's literally all a variable is. So just imagine a bit like a container. That's what a variable is.

But we should be descriptive. So since we know the input into our Python script is going to be a collection of desks, then really what we should call this then is desks, cause it's meaningful. Now we know what that is.

Another pro tip, try to avoid abbreviations unless it's a variable or node abbreviation. Min and max. Doc I'm not so keen on, but most people know doc means document within Revit. The reason why you shouldn't abbreviate, and the reason why you should be very descriptive with your naming variables is because your code then reads almost like a paragraph. It's then human readable. If anyone else reads your code, they understand it. If in a few months time, your manager says, ah, that great script, can we just update it? And you're rereading your own code, and you've just use meaningless names everywhere, you're going to have to unpick your entire code line by line to work out what it was doing just to be able to make the change that your manager's asking you to do.

So a pro tip is always be descriptive with your variable names. I would actually say probably the single biggest barrier for people that are just getting into developing is poor naming convention. That is one of the biggest barriers. So don't do it.

Always be descriptive. Don't go too over the top, like trying to be kind of pertinent and concise with your naming. And this technique is true no matter what language you're using, whether it's C#, Python, I mean, you name it. That's actually, I would say, one of the single most important things you should learn. Always be descriptive.

We also camel case as well. So camel casing just means that when you declare your variable name, say we were to call this desk list or something, then every new word that we put inside that variable name should be capitalized. That's why it's called camel casing. Variables always start with lowercase. So these are some well-known kind of standards.

They're not enforced by the interpreter or the language we're using. They're actually, ultimately, down to you as a developer to make sure that you adhere to these standards. But these are widely known standards which you should adhere to. And I guess one last comment. You can't start a variable with a number in C# or Python. So it has always got to start with a letter.

OK. So we create our variable called desks. We use our equals assignment to assign something to it. And what we're going to assign to it, we can actually get rid of the unwrap element, because we'll explore that in a few of the other exercises later. But we're just going to assign to it this weird word called in, followed by some square brackets with a number in the middle of it. And this will all make sense in just a second.

So if you've done that, then you've actually already configured your Python script to accept an input from Dynamo. And so what does that actually mean? First of all, in is a variable, just like desks. It's just a bit of memory which has been allocated in your machine. And it's going to store something.

And the in variable name within Python is actually Dynamo specific. So it's not some special keyword in Python. It's actually a configuration of Python within Dynamo. And the in variable is literally just a list. And that list can store a collection of any object you'd like within Python. And you'll notice that on your Python node, if we just go back to our graph, it's got a bunch of input ports which have, funnily enough, the word in, followed by square brackets, and then an integer or a number in the square brackets.

So just to get a bit more techy then and explain what this actually means, a list, as you know, is a collection of objects. So you can store an unlimited number of-- well, not unlimited. It depends on how big your computer's memory is, but it stores an unlimited number of elements or entities.

And when it comes to actually selecting elements out of that list-- so imagine, the best way to kind of visualize a list, everyone is familiar with Excel. If you visualize the first row in Excel, each row has a cell, and in that cell you can put what you like in there, a number, a date, even an image, that actually represents a list. So inside each cell you can put something inside each slot. And in each slot in Excel it's called a reference.

And the same is true within programming languages. And it's actually very simple to understand. And this is true for actually any language which you can use as far as I'm aware of. That slot is indexed. And the index always starts from zero.

So, for example, if you have a list of inputs into a Python script stored inside that in variable, the very first item in that list is what you connect into your node. That's the first item. So if we want to grab that first item, we index the list, which is always using square bracket notation. And inside the square brackets, we always have to input an integer, which is an index.

So again, we can either use Excel as an analogy, or even like a library. Imagine if you go to a library and you want to find a book, that book's got a reference number. And if you want to locate that book you have to go to the right shelf. And then you find the number of the book, and you can get the book off the shelf. That is the concept of indexing a list. It's exactly the same.

Just remember that it always starts from zero. So if you declare your own list, first index is zero. And it just increments sequentially. And all of this is done on your behalf by the interpreter, and by the language which you're using. So you do not need to specify an index. Just remember that it starts from zero, and if you want to index a list, it's always square brackets. And the syntax is always the variable name. And it's immediately preceded by the square brackets.

So if we just check this out then, we've got the in variable, which is Dynamo specific. It's just a list. And we want to say, OK, give us whatever you've got at index zero, so the first item in the list, and assign it to desks.

So what's happening back in Dynamo then, if you connect your [INAUDIBLE] elements into the first index--

PRESENTER 1: [INAUDIBLE]

TOM: OK. Yeah. It's all right. Yeah. So sorry, Radu was just saying that not everyone's opened up exercise one yet inside Dynamo.

PRESENTER 1: [INAUDIBLE]

TOM: Ah. Yeah. OK. I've not got to that step yet. OK. So yeah. Just going back to our script then.

So yeah. You can see what's happening hopefully when we actually just compare the two side by side. We're connecting our [INAUDIBLE] elements into the first input port of our Python script node. And our in variable is basically capturing that input. And it's placing it at the first index in the in list.

And so them back in our Python code all we're doing is we're giving that in variable, and the first item in that list a meaningful name. In theory, we could actually just use in, and then index that first item throughout our entire code base. But that would not only be bad programming, because it's ambiguous. Like what does index 0 actually mean? Like it's got no meaning in our code. And also, it would be quite cumbersome. And imagine if you needed to change an input port. You'd then have to go back through all your code, modify the indexes at every place where you've put it. And it would just be a nightmare. So this is actually a really good dev technique as well.

Typically all good Python developers within Dynamo will do this. They will have a list of variables at the start of their script. And that will then just be taking an item out of their in list and just assigning it to a more meaningful variable. So that's the concept there. So now you know how to pass inputs into your Python script from Dynamo. It's just using this in keyword, and then you just index.

And if that's still a bit confusing, then here's an even simpler way of putting it. Whatever the name of the input port is in your Python script, just type that out again inside Python, and it's going to work. I mean, it's literally that simple.

OK. So we're almost there. We've got our input going in. And if we want to just double check that this is most certainly working, then here's another little trick. If you just uncomment that out variable-- and this should now be self-explanatory if you've understood what the in variable does-- out is the variable which Dynamo uses-- again, it's Dynamo specific-- to return items out of your Python script. So what we're going to see inside Dynamo itself will be an output from the Python node. Whatever the output is is what we define as developers. So whatever we assign to that out variable is what is returned.

And the output can either be a single item, or it can be at list. It's up to you as a developer to decide and determine what your script should be outputting. But what we can do is we can just pass desks in, and we can pass desks out, and just check that this is all working. So I'd like you to just go ahead and do that.

If you just copy your desks variable, assign it to out, if you just save your script, which is the most important thing to do, and we're finally going to get to the point where we can actually start reading the script which you've just written within Dynamo. And to do that, you just literally browse to your PWAR file using this file path node. And that's going to do the rest of the necessary steps for you.

So if I go ahead and find that file-- OK. So what I'm basically putting into the node is also coming out of the node. So I know that everything's working. And as you know, the purpose of this exercise was to count the number of desks which we're actually inputting into the node. And so for that we can use one of Python's built in functions.

So a function, again, if we use Excel as an analogy. If you're familiar with Excel, which a lot of construction professionals are, whenever you use any kind of function within Excel, that is a method. So a method and a function, kind of they mean the same thing. And typically, what a function will do is you provide a bunch of inputs. And then it gives you an output. That's usually what a function does, a bit like a calculator.

Although, there is a caveat to that. Not all functions will return something. It depends. Like within programming, you can declare a function that returns something. And you can also declare a function that just doesn't return anything. Because it might do something for you. It might, I don't know, set a parameter within a family instance. If that method sets the parameter, you don't need to return anything out of it. Cause all it's doing is just setting a bit of data for you. So that's the caveat there.

But nevertheless, all we're going to be doing here then is just measuring the total length of this list, as in we're going to count. And then we're going to output this from a Python script. So we just return back to our code. And all we're going to do is in the out variable, we're just going to wrap our desks variable inside a function. And that function which we're going to use is a built in function in Python. And it's called len. And all len does is it counts the length, or the total number of items inside a collection, so inside a list.

And as soon as I do that-- and you need to remember to save it. So you've got to save your file. And when you do that, your script should automatically update. And now it's going to tell you how many desks that you've actually selected.

So the purpose of this exercise then is to show you the boilerplate, to have you guys understand what the in and out variable do, and also to understand the basics of indexing a list. And you're going to be doing that a lot no matter what language you use. So these are really important concepts to understand.

OK. Sure. Go ahead.

AUDIENCE: [INAUDIBLE]

PRESENTER 1: Yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER 1: You can to a certain extent. So the only way to do it, say if you want to get-- it's known [INAUDIBLE]. That's the kind of more common word for it. You can only do that with the Revit API using stubs. And stubs, I think they are essentially text files, which store a representation of the Revit API. And that is then cached inside, say, Visual Studio Code. So when you type, it'll give you a list of suggestions when you do your dot operator. But it's not quite, I would say, as powerful and as useful as, say, running in C# and using it there. But you can do it, but that's the only way that I'm aware of that you can do it. Yeah.

AUDIENCE: [INAUDIBLE]

TOM: Yeah. If you just Google-- so if you want to get kind of like a dropdown of suggestions, I think it is-- hang on.

Yeah. So you want to go to this repo here. If you just do Iron Python stubs, it's in there. There's really good instructions. I can never pronounce the gentleman's name who's done this. But he does Revit API docs. A really amazing guy. But yeah, all the instructions are on there if you did want suggestions when you type your code.

OK. So first of all, has everyone got to this stage here? I'm sorry. Go ahead.

AUDIENCE: [INAUDIBLE]