Upgrading Server to version 22.1? We’ve enabled the faster AMP engine by default. Read about how these system settings changes might affect you.

We’re aware of an intermittent issue with our My Alteryx login and are actively working to have the issue corrected. If you run into an error when logging in, please try clearing all cookies or accessing the community on a different browser. Thank you for your patience!
alteryx Community

# Engine Works

Under the hood of Alteryx: tips, tricks and how-tos.

## Learn Macros Through Code (for Non-Coders)

Alteryx Community Team

Editor's note: you may need some background on what Macro Maynia is. Find it here.

If you know zero things about programming, by the end of this blog you'll know three. And you'll learn how those three things are like the different flavors of Alteryx macros.

# Functions - They're Like Standard Macros

A function is a way to make a program snippet repeatable and abstract-able, so that you don't need to keep repeating the same code blocks all the time. Let's say you want to calculate the length of the hypotenuse of a right triangle given the lengths of the other two sides. If you've taken a geometry course, you know it's not hard...

In the Python programming language, you can calculate c given a and b like so: `c = (a ** 2 + b ** 2) ** 0.5`

But what if you need to calculate c a lot, and don't want to have to type it out every time? That's where functions come in...

``` def pythagoras( a, b ): c = (a ** 2 + b ** 2) ** 0.5 return c print( pythagoras( 1, 2 ) ) print( pythagoras( 3, 4 ) ) ```

Try it yourself!

Now instead of needing to type in the entire formula every time we need c, we just call the pythagoras function that we've defined and pass in the values of a and b. Note how we call the function twice with different values without needing to copy/paste the contents of the function itself. Anyone can reuse this function without needing to know how it works inside.

The equivalent in Alteryx is a macro! Macros are a way to create a new tool in Alteryx Designer by creating a special kind of workflow that includes interface tools. The macro appears to the end user as a tool, but the complexity of underlying workflow is hidden.

Calculating the length of the hypotenuse in Alteryx is easily accomplished in a Formula tool. Bookending the Formula tool with Macro Input and Macro Output tools turns the workflow into a macro.

Get this math out of my face!

And this is how the macro appears to the end user that no longer needs to worry about the equation itself...

Much better - just like any other tool.

# While Loops - They're Like Iterative Macros

If you need to do the same thing over and over until a condition is met, you need a while loop. In keeping with the math theme, what better example than the Fibonacci sequence. Here's a Fibonacci sequence generator built in Python using a while loop within a function. All you need to do is specify the maximum value you want in the sequence, and the function will print out each number in the sequence below that limit...

``` def fibonacci( max ): i = 0 j = 1 while i < max: print(i) temp = j j = j + i i = temp return fibonacci( 10 ) ```

In Designer, an iterative macro is like a while loop inside a function.

You can see the Formula tool is performing the same calculations on i and j and temp that are taking place inside the while loop above, and the `i < max` condition is performed in the Filter tool. The user of the tool specifies the max, and to them, it simply looks like this:

Finally, the data that flows out of the I Output gets fed back into the Input. You configure this in the interface designer.

# For Loops - They're Like Batch Macros

Ever heard of Gottfried Leibniz? Among many other things, he came up with a cool way to calculate the value of pi.

If we wanted to write a script to approximate the value of pi to an arbitrary number of terms in the above series, we'd want a for loop - a loop that repeats a certain number of times. (Side note: math is weird.) Here's the leibniz function with a for loop inside. Try changing the terms parameter to see how high it has to be before you get to 3.14.

``` def leibniz( terms ): denominator = 1 multiplier = 1 sum = 0 for x in range(0, terms): sum += multiplier / denominator denominator += 2 multiplier = multiplier * -1 return sum * 4 print( leibniz( 100 ) ) ```

An Alteryx batch macro is like a for loop - the contents of the macro will execute as many times as the number of rows being fed into it through the control parameter. But (surprise!) you can easily replicate the above logic in an Alteryx workflow (and therefore a standard macro) because a workflow is also like a for loop in that a tool's logic is applied across all rows of a dataset. Here's the guts of the standard macro...

See? No control parameter. Another standard macro.

Here's what the configuration looks like to the end user:

One way you'll likely know if you need a batch macro is if you need to change the configuration of one or more tools for each iteration of the loop based on incoming data. For example, let's say you're constantly calculating statistics based on census data. People ask you to get the average county population in the state of Maryland, or the most populated county in California, etc. Finally, you just tell them to make you a list, and include the state and the statistic they're after. You can make your life a lot easier with a batch macro.

Here's what that list that your coworkers put together looks like: