Saturday, November 12, 2011

Creating your First Android Application

From a .Net Developer's Perspective


I will be showing you how to create the same application that was shown in the tutorial titled 'Creating your First Mono for Android Application'. Over time, I will create more advanced Android application development tutorials using both the Mono for Android (using C#) and Eclipse Android Plugin (using Java) frameworks.


Setting Up the Development Environment
  1. Download and install the Java SE Development Kit (JDK):http://www.oracle.com/technetwork/java/javase/downloads/index.html I've installed JDK version 6 Update 27 (1.6.0.270).
  2. Download and install Eclipse IDE for Java EE Developers: http://www.eclipse.org/downloads/ I've installed version Indigo Service Release 1, build 20110916-0149.
    1. Extract the Eclipse files from the 'eclipse' folder into a folder on your PC. I've installed mine in C:\Eclipse.
  3. Install the Android SDK from http://developer.android.com/sdk/index.html. I installed Android SDK revision 15.
    1. Do not use any spaces in the installation path. I used C:\AndroidSDK.
    2. Leave the 'Start SDK Manager' checkbox checked.
    3. Ensure that the 'Android SDK Tools' and ''Android SDK Platform-tools' are fully installed.
    4. I also installed 'Android 2.2 (API 8)' and 'Android 2.3.3 (API 10)'.
    5. Click on the 'Install N packages...' when ready.
    6. Check the 'Accept all' radio button, then click on 'Install'. It will download and then install the packages. Please note that this download & installation process takes a long time to complete. Don't worry if the log shows an "'adb kill-server' failed -- run manually if necessary." error message. This is simply the package manager's attempt to stop the Android Debug Bridge's server process, which is not yet/already running.
    7. Click 'Yes' to restart ADB.
    8. Close the SDK manager.
  4. Configure the Android Simulator:
    1. Open up the Android SDK AVD Manager.
    2. Click on 'New...'.
    3. Enter MonoDroid in the 'Name' field.
    4. In the 'Target' drop-down, select 'Android 2.2 - API Level 8'.
    5. Choose 512MB for the 'SD Card' 'Size'.
    6. Select 'HVGA' as the 'Built-in' 'Skin'.
    7. In the 'Hardware' section, click on the 'New ...' button.
    8. Select the 'Device ram size' property from the drop-down list.
    9. Click on 'OK'.
    10. Enter 512 for the 'Device ram size' property.
    11. Click on 'Create AVD'. It will take about a minute to complete.
    12. Close out of all Android SDK windows.
  5. Install the Android Development Tools (ADT) Plugin for Eclipse: 
    1. Launch the 'eclipse.exe' file from the Eclipse folder.
    2. Specify your Workspace location. This is the folder in which Eclipse stores your Eclipse projects. I've set mine to C:\Documents and Settings\Mike\My Documents\Eclipse.
    3. Click on 'OK'.
    4. Click on the 'Help' menu, then click on 'Install New Software...'.
    5. Enter the following URL in the 'Work with:' text box: http://dl-ssl.google.com/android/eclipse
    6. Click on 'Add...'.
    7. Name the repository. I've called mine Android Plugin for Eclipse.
    8. Click on 'OK'.  Wait until you see the 'Developer Tools' checkbox in the list.
    9. Check the 'Developer Tools' checkbox.
    10. Click on 'Next'.
    11. Click on 'Next'.
    12. Check the license terms radio checkbox.
    13. Click on 'Finish'.
    14. Click on 'OK' when and if you see a 'Security Warning' dialog box regarding installing unsigned software.
    15. Click on 'Restart Now' to restart Eclipse.
    16. In the 'Welcome to Android Development' / 'Configure SDK' dialog box, check the radio checkbox labeled 'Use existing SDKs'.
    17. Browse to and select the location of the Android SDK installed previously. I've set my 'Existing Location' to C:\AndroidSDK.
    18. Click on 'Next'.
    19. I've opted not to send usage statistics to Google.
    20. Click on 'Finish'.
Creating the First, Hello World Android Application
  1. If it's not already open, launch the 'eclipse.exe' application.
  2. Click on the 'File' menu, then go to 'New' and click on 'Project'.
  3. Open up the 'Android' folder and select 'Android Project'.
  4. Click on 'Next'.
  5. In the 'Project Name' text box, enter HelloWorld.
  6. Click on 'Next'.
  7. Select the 'Android 2.2' SDK target.
  8. Click on 'Next'.
  9. In the 'Package Name' text box, change the name to net.DotNetFun.HelloWorld.
  10. In the 'Create Activity' text box, change the activity to MainActivity.
  11. Click on 'Finish'.
  12. Close the 'Welcome' tab in the upper-right corner.
  13. Rearrange the workspace so the panes are more appropriate spaced. This is what mine looks like:
  14. In the 'Package Explorer', expand the 'HelloWorld', then expand the 'res' and 'layout' folders.
  15. Double-click on the 'main.xml' file to open it. This file is equivalent to the Main.axml XML file used in the various Mono for Android Visual Studio project templates. It defines, declaratively, the layout for one or more activities. For more info about declaring XML layouts, visit this URL: http://developer.android.com/guide/topics/ui/declaring-layout.html
  16. Click on the 'main.xml' tab.
  17. Use the following XML as the 'main.xml' contents:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        >
    <Button  
        android:id="@+id/MyButton"
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content" 
        android:text="@string/Hello"
        />
    <Button
          android:id="@+id/DialogButton"
          android:layout_width="fill_parent"
          android:layout_height="wrap_content"
          android:text="Dialog Button"
        />
    </LinearLayout>
    
    

    For more info about Android XML layouts, visit this URL: 

  18. In the 'Package Explorer', expand the 'values' folder.
  19. Double-click on the 'strings.xml' file to open it. This is equivalent to the the 'Strings.xml' file used in the various Mono for Android Visual Studio project templates. It defines, declaratively, string resources. One difference you'll notice, however, is the 'app_name' resource. The Eclipse project requires, by default, this resource exist. For more info about declaring string resources, visit this URL: http://developer.android.com/guide/topics/resources/string-resource.html
  20. Use the following XML as the 'strings.xml' contents:

    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="Hello">Hello World, Click Me!</string>
        <string name="app_name">DotNetFun.Android.HelloWorld</string>
        <string name="HelloButtonText">Button Text via Strings.xml</string>
    </resources>
    
    

    For more info about Android string resources, visit this URL: http://developer.android.com/guide/topics/resources/string-resource.html

  21. In the 'Package Explorer', expand the 'src', and 'net.DotNetFun.HelloWorld' folders.
  22. Double-click on the 'MainActivity.java' file to open it.
  23. Ensure that the java code in this file has exactly what you see here:

    package net.DotNetFun.HelloWorld;
    
    import android.app.Activity;
    import android.app.AlertDialog;
    import android.content.res.Resources;
    import android.os.Bundle;
    import android.widget.*;
    import android.view.*;
    import android.view.View.OnClickListener;
    
    public class MainActivity extends Activity implements OnClickListener {
     
     private int count;
     
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            
            this.count = 0;
            
            Button button = (Button) findViewById(R.id.MyButton);
            
            button.setOnClickListener(this);
            
            Resources res = this.getResources();
            button.setText(res.getString(R.string.HelloButtonText));
            
            Button dialogButton = (Button) findViewById(R.id.DialogButton);
            dialogButton.setText("Dialog Button");
            
            dialogButton.setOnClickListener(this);
        }
        
        public void onClick(View v) {
         
         Button button = (Button) v;
         
      if (button.getId() == R.id.MyButton)
      {
       this.count++;
       button.setText(String.format("%s clicks!", this.count));
      }
      else if (button.getId() == R.id.DialogButton)
      {
       AlertDialog.Builder builder = new AlertDialog.Builder(this);
       builder.setMessage("Hello, World!");
       builder.setCancelable(false);
       builder.setPositiveButton("OK", null);
       AlertDialog dialog = builder.create();
       dialog.show();
      }
     }
    }
    
    
  24. Click on the 'Run' menu, then click on 'Debug Configurations...'.
  25. Click on the 'Target' tab.
  26. In the 'Select a preferred Android Virtual Device for deployment' list, select/check the 'MonoDroid' emulator created earlier.
  27. Click on 'Apply', then click on 'Close'.
  28. Press F11 to debug and start the Android application. If you get a dialog box stating it's waiting for the debugger to attach, and it doesn't go away after a while, you'll need to restart Eclipse, re-check your debug configuration, and press F11 again.
  29. Slide over the button to get to the Android desktop, then click on the applications icon/button.
  30. Click on the 'DotNetFun.Android.HelloWorld' application.
  31. Click on the 'Button Text via Strings.xml' button. A dialog box stating ''Hello, World!' should appear. Close it.
  32. Click on the 'Hello World, Click me!' button several times. With each click, the button's text/caption changes to the number of times it has been clicked.

Friday, November 11, 2011

Debugging a VS.NET 2010 ASP Development Server Hosted Application Running via All Browsers

  1. In Visual Studio 2010, set your breakpoints.
  2. Click on the 'Debug' menu.
  3. Click on 'Attach to Process...'.
  4. Find the 'ASP.NET Development Server - Port #' process hosting the ASP.NET application you'd like to debug.
  5. Click on 'Attach'.
You're all set. You can now debug your ASP.NET application from any web browser pointed at that server's URL.

Wednesday, November 09, 2011

Creating your First Windows Workflow v4 Application

The following WF console application (written in C#) will 1) pause for 5 seconds, 2) write the line "Hello," 3) pause another 5 seconds, and then 4) write the line "World!" I know, not terribly practical, but it will get you familiar with creating WF v4 applications for the first time, assuming you'r new to this, that is.
  1. Open up Visual Studio 2010.
  2. Press Ctrl-Shift-N to create a new project.
  3. In the 'Installed Templates' pane, select 'Workflow'.
  4. Select the 'Workflow Console Application' template.
  5. Name the project DotNetFun.Workflow.HelloWorld.
  6. Click on OK.
  7. Ensure that the 'Workflow1.xaml' file is open.
  8. Drag a 'Sequence' from the toolbox's 'Control Flow' section onto the area of the designer labeled 'Drop activity here'.
  9. Click on the sequence to select it.
  10. At the bottom of the designer, click on the 'Variable' tab button.
  11. Click on where it says 'Create Variable'.
  12. Type pauseWaitTime. This will be the variable that stores how long each pause will be.
  13. In the 'Variable type' column, select 'Browse for Types...', then in 'Type Name:' text box, type System.TimeSpan.
  14. Click on 'OK'.
  15. In the 'Default' column, type the following code expression: new TimeSpan(0,0,5)
    The 'pauseWaitTime' variable will now be available within the 'Sequence' scope, available to the sequence  and all of its child elements.
  16. In the 'Primitives' section of the toolbox, drag a 'Delay' activity into the 'Sequence' sequence.
  17. In the properties explorer for the Delay activity, enter pauseWaitTime in the 'Duration' text box.
  18. In the properties explorer for the Delay activity, change the name to Delay1.
  19. In the 'Primitives' section of the toolbox, drag a 'WriteLine' activity directly beneath the 'Delay1' activity.
  20. Click on the 'Enter a VB expression' text box and enter "Hello," (with double quotes, as this is a string literal expression).
  21. In the properties explorer for the WriteLine activity, change the name to WriteLine1.
  22. In the 'Primitives' section of the toolbox, drag a 'Delay' directly beneath the 'WriteLine1' activity.
  23. In the properties explorer for the Delay activity, enter pauseWaitTime in the 'Duration' text box.
  24. In the properties explorer for the Delay activity, change the name to Delay2.
  25. In the 'Primitives' section of the toolbox, drag a 'WriteLine' activity directly beneath the 'Delay2' activity.
  26. Click on the 'Enter a VB expression' text box and enter "World!" (with double quotes, as this is a string literal expression).
  27. In the properties explorer for the WriteLine activity, change the name to WriteLine2. The workflow designer should now look like the following:
  28. Open the Program.cs class file.
  29. Add the following code after the WorkflowInvoker.Invoke method call:

        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    
    
    
    
  30. Press F5 to run and test the workflow application.
That does it for this very simple introduction to WF v4 workflows. Be on the lookout for more!

Tuesday, November 08, 2011

Testing Mono for Android Applications on an Android Device

Please note that the following steps were performed on an HTC smartphone running Android version 2.1.


Setting Up the Android Device

  1. Ensure the Android device is not yet plugged into the PC.
  2. Go the the desktop/home of the Android device.
  3. Go to Settings.
  4. Click on 'Applications'.
  5. Click on 'Development'.
  6. Check the following checkboxes:  'USB debugging', 'Stay awake', and 'Allow mock locations'.
Setting Up the Android SDK

  1. Visit the following URL to download and install the appropriate USB driver for ADB for the device: http://developer.android.com/sdk/oem-usb.html

Setting Up the Visual Studio Mono for Android Application

  1. Open up Visual Studio 2010.
  2. Open the Mono for Android application.
  3. Open up the 'AndroidManifest.xml' file.
  4. Add the following XML attribute to the 'application' element:

    android:debuggable="true"
  5. Press F5 to debug and deploy the application.
  6. Select the Android device from the 'Running devices' list.
  7. Click on OK.

Sunday, November 06, 2011

Creating your First Mono for Android Application

From a .Net Developer's Perspective


I will be showing you how to create the same application that was shown in the tutorial titled 'Creating your First Android Application'. Over time, I will create more advanced Android application development tutorials using both the Mono for Android (using C#) and Eclipse Android Plugin (using Java) frameworks.


Getting the Environment Setup
  1. Install the Java 1.6 JDK.
  2. Install the Android SDK from http://developer.android.com/sdk/index.html. I installed Android SDK revision 15.
    1. Do not use any spaces in the installation path. I used C:\AndroidSDK.
    2. Leave the 'Start SDK Manager' checkbox checked.
    3. Ensure that the 'Android SDK Tools' and ''Android SDK Platform-tools' are fully installed.
    4. I also installed 'Android 2.2 (API 8)' and 'Android 2.3.3 (API 10)'.
    5. Click on the 'Install N packages...' when ready.
    6. Check the 'Accept all' radio button, then click on 'Install'. It will download and then install the packages. Please note that this download & installation process takes a long time to complete. Don't worry if the log shows an "'adb kill-server' failed -- run manually if necessary." error message. This is simply the package manager's attempt to stop the Android Debug Bridge's server process, which is not yet/already running.
    7. Click 'Yes' to restart ADB.
    8. Close the SDK manager.
  3. Configure the Android Simulator:
    1. Open up the Android SDK AVD Manager.
    2. Click on 'New...'.
    3. Enter MonoDroid in the 'Name' field.
    4. In the 'Target' drop-down, select 'Android 2.2 - API Level 8'.
    5. Choose 512MB for the 'SD Card' 'Size'.
    6. Select 'HVGA' as the 'Built-in' 'Skin'.
    7. In the 'Hardware' section, click on the 'New ...' button.
    8. Select the 'Device ram size' property from the drop-down list.
    9. Click on 'OK'.
    10. Enter 512 for the 'Device ram size' property.
    11. Click on 'Create AVD'. It will take about a minute to complete.
    12. Close out of all Android SDK windows.
  4.  Install the 'Mono for Android for Windows' SDK from http://xamarin.com/trial. I've installed the Mono for Android SDK v1.2.
    1. If you get a message saying that Android SDK 14 is required, don't worry about it.
    2. Click on 'Next'.
    3. Close the installer.
Creating the First, Hello World Android Application
  1. Open up Visual Studio 2010.
  2. Choose the option to create a new project.
  3. In the 'Visual C#' tree, select 'Mono for Android Application'.
  4. Name the project DotNetFun.Android.HelloWorld.
  5. Click on OK.
  6. Rigkt-click on the 'DotNetFun.Android.HelloWorld' project, then click on 'Properties'.
  7. Click on the 'Android Manifest' tab.
  8. Click on the link to add an 'AndroidManifest.xml' file.
  9. Name the 'Application' Hello World.
  10. Name the 'Package' DotNetFun.Android.HelloWorld.
  11. Enter 1 for the 'Version number'.
  12. Enter v1 for the 'Version name'.
  13. Select 'API Level 8 - Android 2.2' in the 'Minimum Android version' drop-down.
  14. Save the project.
Dissecting the 'Mono for Android Application' Application


The Mono for Android folks have done a great job of recreating the look and feel of a typical Java and Eclipse based Android application in Visual Studio with their various templates, so kudos to them for a job well done.


The following is a summary description of the various aspects of a typical Android and Mono for Android Visual Studio application:
  • Android Activities
    Android Activities are akin to ASP.NET Web Form pages, ASP.NET MVC views, and Windows Forms forms. They are the screen areas where UI elements are rendered and interaction between the user and the application typically take place. Just like web forms and Windows forms raise events and have life-cycles, so, too, do Android Activities. The default Activity1.cs class file that's created when creating a new 'Mono for Android Application' application derives from the Android.Views.Activity class to provide base activity functionality, much like web forms pages typically derive from System.Web.UI.Page and Windows forms derive from System.Windows.Forms.Form. And much like web forms and Windows forms raise events and call event handlers, such as Init and PreRender, so, too, do Mono for Android Activities, such as the overridable OnCreate and OnStart methods respectively. For more about activities as used in Mono for Android, read Xamarin's 'Mono for Android Activity Lifecycle' documentation here: https://docs.google.com/open?id=1nTEo_ZLGWG4oTb6aUtZspVpPYRQzskyONr6g5iUPwKFqIG7Lpcuka-a1Y7FH For more about Android activities, visit this URL: http://developer.android.com/reference/android/app/Activity.html
  • Android Layouts
    Android layouts define how visual elements in an Activity are displayed. Layouts are Views per se (read below). Android supports the following layouts: FrameLayout, LinearLayout, TableLayout, and RelativeLayout. Layouts can be created either decoratively, using XML, or via code, using layout classes. The default 'Mono for Android Application' uses the declarative model, uses the LinearLayout, and is defined in the 'Main.axml' file, inside of the project's 'Resources\Layout' folder. For more about Android layouts, visit this URL: http://developer.android.com/guide/topics/ui/declaring-layout.html
  • Android Views
    Android views are basic UI controls that represent visual elements in activities that render content, handle UI interaction events, etc. They are akin to the typical.Net controls, such as buttons, text labels, checkboxes, etc. Some examples of Android views are the Button, CalendarView, CheckBox, DatePicker, EditText, GridView, LinearLayout, and TableLayout. TheViewGroup is a view that only holds other views. It's analogous to the .Net Panel control. The default 'Mono for Android Application' template comes with a Button view. Views can be included in the application either declaratively or via objects in code. For more about Android views, visit this URL: http://developer.android.com/reference/android/view/View.html
  • Resources
    Android and the Mono for Android framework support storing information in XML resource files. The Mono for Android framework generates designer class files that reflect these resources. Each type of resource is located in the project's 'Resources' folder. The 'Mono for Android Application' template does a good job of providing these resources via the Resource.Designer.cs designer-generated class file. Rather than reading an explanation about how resources work, take a look at figures #1 - #4 below for a more visual explanation. For more information about leveraging XML based resources, visit this URL: http://developer.android.com/guide/topics/resources/index.html
  • Activity1.cs
    This activity class is created by default when adding a new 'Mono for Android Application'. In its 'OnCreate' method, you'll see code that sets the content to be rendered in the Android Activity as well as an event handler to handle a button click. Each time this button is clicked, the button's caption is updated to the number of times it's been clicked.
Fig. 1

Fig. 2
Fig. 3
Fig. 4

Deploying & Testing the Mono for Android Application
  1. Press the F5 key to debug and deploy the application to the Android simulator created earlier.
  2. In the 'Select Device' dialog box, click on the 'Start emulator image' link.
  3. Do NOT choose any of the simulators created by the Android SDK.
  4. Select the 'MonoDroid' simulator created earlier.
  5. Click on 'OK'. Wait for the 'Select Device' dialog box to show the emulator in the list. During this time, it will seem as is nothing's happening. Don't worry, something is.
  6. The emulator will be setup on port, so the next screen you will see is the same 'Select Device' dialog box, except, you'll now see an emulator listed that's titled something like emulator-5554. Click on the OK to select the emulator and get the application deployed.
  7. The first time the emulator is deployed, the Mono for Android framework takes some time to package the application for use with the simulator, install the Mono runtime and platform framework, etc, so please be patient. During this phase, it might seem like nothing's going on, but take a look at the Visual Studio status bar. It will show 'Deploy started...'. While this is the status, let the process proceed, even though you see the actual emulator in another window. This process can take up to 10 minutes to complete. Each time the project changes, the framework will detect this and re-package and deploy the application, so prepare for some ample wait times accordingly.
  8. Eventually, the application is deployed (if no errors were encountered, that is). Drag the unlock button in the emulator to the right to unlock the Android.
  9. Click on the application button.
  10. Click on the application to launch it. It will take a few seconds for the application to load. It's ready when you can see the 'Hello World, Click Me!' button.
  11. Click on the button to test the application.
  12. Close the emulator window.
Let's Change Some Things

The application's name isn't very unintuitive, so let's change it. There are several ways to set the application's name: via 1) the Visual Studio property pages, 2) editing the 'AndroidManifest.xml' file, and 3) the main class' Activity attribute's Label property.

Setting the Application Name via the Main Class' Activity Attribute
  1. Open up the 'Activity1.cs' class file.
  2. Change the Activity attribute's Label property to "App Name via Label Property".
  3. Press F5 to test the new name.
Setting the Application Name via the Visual Studio project's Property Pages

When the main class' Activity attribute's Label property is set, that label will override whatever the application's name is set to in other areas.
  1. Remove the main class' Activity attribute's Label property, entirely.
  2. Right-click on the project, then click on 'Properties'.
  3. Click on the 'Android Manifest' tab.
  4. Change the 'Application name:' to App Name via Prop Pages.
  5. Press F5 to test the new name.
Setting the Application Name via the AndroidManifest.xml File


Setting the application name via the VS property pages simply results in the 'AndroidManifest.xml' file's application element being changed.
  1. Open up the 'AndroidManifest.xml' file in the 'Properties' folder in Visual Studio.
  2. Locate and the 'application' element and change the 'android:label's string to App Name via AndroidManifest.xml.
  3. Press F5 to test the new name.
Saving Strings in the Strings.xml Resource File


You can save strings in the 'Strings.xml' resource file and retrieve them at runtime via code. Let's create a new string resource for the Hello Button's Text property.
  1. Open up the 'Strings.xml' file in the 'Resources\Values' folder.
  2. Add the following XML element within the 'resources' element:

    <string name="HelloButtonText">Button Text via Strings.xml</string>

  3. Press F6 to compile the application. This will result in the 'Resource.Designer.cs' class being updated to reflect the new string resource.
  4. Open up the 'Activity1.cs' class file.
  5. Add the following line to the end of the 'OnCreate' method:

    button.Text = this.GetString(Resource.String.HelloButtonText);

  6. Press F5 to test the changes.
Adding UI Elements Declaratively
  1. Open up the 'Main.axml' layout resource file in 'Resources\Layout'.
  2. Add the following element inside of the 'LinearLayout' element:

    <Button
          android:id="@+id/DialogButton"
          android:layout_width="fill_parent"
          android:layout_height="wrap_content"
          android:text="Dialog Button"
        />
    
    
  3. Press F6 to compile the project in order for 'Resource.Designer.cs' to get updated.
  4. Open up the 'Activity1.cs file'.
  5. Add the following code to the end of the 'OnCreate' method:

    var dialogButton = FindViewById<Button>(Resource.Id.DialogButton);
    dialogButton.Click += delegate 
    {
                    var builder = new AlertDialog.Builder(this);
                    builder.SetMessage("Hello, World!");
                    builder.SetCancelable(false);
                    builder.SetPositiveButton("OK", delegate {  });
                    var dialog = builder.Create();
                    dialog.Show();
    };
    
    
  6. Press F5 to test your changes.

Adding UI Elements Using Code



  1. Remove the Button element you added to the 'Main.axml' file earlier.
  2. Open up the 'Activity1.cs' class file.
  3. Remove the dialogButton line of code added earlier and replace it with the following code:

    var dialogButton = new Button(this);
                dialogButton.Text = "Dialog Button";
    
    
  4. Press F5 to test your changes. The results should be exactly the same. Instead of using the XML based Button, however, we created the button via the runtime code.
That about does it for this tutorial. Be on the lookout for more!