[00:00] In this lesson, we'll give an introductory getting started overview of the Ignition Software Development Kit or SDK. Welcome to this IU Elective Studies course on the Ignition SDK. This course will introduce new users to the Ignition SDK, and help you get rolling with it. We'll discuss: what the SDK is, why you might want or need to use it, how to set up the needed development environment, how to build and run a simple SDK example module, and how you would get started on creating and debugging your own new Ignition SDK modules. This first of several course lessons is going to give a broad introductory overview of the Ignition SDK and discuss how the progression of the following lessons will be structured. So what's the Ignition SDK anyway? The Ignition SDK allows users to extend Ignition's core capabilities with their own custom capabilities. This is done by writing new custom modules in Java. Modules are add-ons, which plug into Ignition's existing modular, extensible architecture.

[01:10] A module is to Ignition as an app is to some smartphone. Many of Ignition's key capabilities are already implemented as modules: for example, Vision, Perspective, Reporting, and the various device drivers. The Ignition SDK makes this framework available to users so they can augment Ignition with their own custom capabilities. There are several good reasons why you might want to put the Ignition SDK to use. The SDK allows users to extend and customize Ignition. For example, you could add your own scripting and expression functions, components, tag providers or device drivers. The SDK allows users to leverage other expertise, both in-house and external. Maybe you have some internal algorithm or capability you want to make use of, or perhaps you'd like to link to some outside third party Java library. Finally, using the SDK makes it possible to package and share some new capability you've developed, such as: in the Ignition Module Development Community, or potentially as a licensed, monetized third party module.

[02:16] Having said all that, use of the Ignition SDK does assume a certain skill level on the part of the user. This course assumes the following: obviously, that you're already familiar with Ignition itself. You're reasonably proficient in Java programming, and you're familiar with some basics of software development, such as an IDE, the build process, and using a Java API. The target audience for this course would be: the skilled, curious yet SDK, unfamiliar beginner, someone who might or might not be in a full-time development role, someone who's already familiar with Ignition, but maybe not yet the Ignition API, and perhaps someone who's heard of the Ignition SDK, but just needs an expedited path to getting started. They just need a quick path to a starting development environment so they can begin their own investigation and prototyping. If most of these things are true, then this course will be for you.

[03:09] This course is structured as a logical progression of short individual lessons covering the various phases of getting started with SDK development. Here is the overall SDK development workflow we'll cover. We'll start by talking about installing the software applications needed to set up your dev environment. There are a couple preliminary installs that need to be done. These are the four items in lighter blue in this diagram: Git, IntelliJ, the JDK, and Gradle. Then we'll focus on obtaining a simple initial SDK training example. This will come from a GitHub repository using Git. You'll probably only need to do this part once as you're getting started. Since it's already a working example, all we need to do is simply import it into our dev environment. Once we have a working example on hand, we'll talk about how to build that example into an Ignition module, an .modl file, and how to install and run it on Ignition.

[04:08] Once we have one simple example working, we'll circle back and look inside that code a bit, get a little familiar with its basic structure and some key aspects of an SDK module. We'll also talk about how to see inside that code using some debug capability, which will be useful once you're doing your own discovery or development with the SDK. Finally, we'll talk a bit about how to create a brand new skeleton SDK module using available module tools. At that point, you'll be ready to begin exploring the Ignition API in more depth in developing your own module content. But there are some practical limitations to the scope of what can be covered in this introductory course. The following things will not be covered in this course. This course will not offer a deep dive into the specifics of the Ignition API, that realistically will require much more experimentation and in-depth review on the part of the user.

[05:04] We also won't talk too much about how to build a specific module to meet a specific purpose. Again, this requires greater familiarity with the SDK API and its available methods. The interested user is encouraged to examine other SDK examples that are available. And finally, we will not cover the use of Docker for module testing. For more insight on using Docker, please see a separate Inductive University elective studies course or other available resources on the Inductive Automation website. And before getting started, there are several primary references you may want to bookmark as you progress through this course. All of these URLs are linked beneath this course in IU. The Ignition SDK Programmer's Guide contains a wealth of technical details on the implementation of the Ignition SDK. As such, it should be considered required reading before getting too deeply into any SDK development. It's also linked from the online Ignition Users Manual. The Ignition Javadoc Archive is a by-version archive of all Ignition Java Docs hosted on GitHub. All available method APIs will be found here.

[06:11] The SDK Training Examples is a GitHub repository containing the SDK training examples used for this course. The SDK Module Tools is another GitHub repository containing some SDK tools, which we will use to create new empty SDK skeleton projects. The Ignition SDK Examples is yet another GitHub repository containing other SDK examples. While most of its examples are natively built using another build tool, Maven, the SDK Java code itself is portable to other build systems such as Gradle, which we'll be using here. The Ignition Third-Party Module Showcase will give you a taste of what kinds of modules one can create with the Ignition SDK. While most of these modules are for purchase, there are also some no-cost ones, which you can try out for yourself. And the Ignition Module Development Community is another GitHub repository of user contributed freely downloadable modules you can try out with Ignition.

[07:10] Well, hopefully all of that has given you an introductory overview of what the Ignition SDK is all about and how the remainder of this course will proceed. Okay, ready to start diving into the Ignition SDK? Good! In the next lesson, we'll talk about getting the needed development environment all set up.