Remove free functions?

[dimsumthinking]

Currently, I have an adapter file so that someone can just type:

forward()
right()
forward(60)

The implementation of forward() in turn calls turtle.forward()

So what I'm wondering is:

(1) Is it pedagogically harder to replace the above with either

turtle.forward()
turtle.right()

or

turtle.forward()
.right()

(2) Given that we make that change, is it a burden for them to first create the turtle

turtle = Turtle()

?

[dimsumthinking]

My impulse is that I'll start with free functions and remove them later in the book.

[rnapier]

I think the free functions definitely lower the barrier to entry. We start off with very simple "do this, turtle!" Then we're off the races already drawing cool stuff without worrying about "variables" or "types" or "objects" or anything else. We just have commands. (Which is pretty much how I learned to program AppleBASIC. Everything was global and I didn't make subroutines. Just do stuff, computer! Interestingly, when I picked up assembly language, I came right back to global variables, which let me get a handle on how things work without having to learn "calling conventions" and other complicated concepts.

Then we begin to think about "hey, what if there were two turtles?" Is there any way to do that? And once that's working, we can peak behind the curtain and answer the question "so how did it work before?"

I think you original functions approach definitely is best.

[nwreg]

TL:DR. Sticking with free functions.
Actually, my first instinct was to go with the dot notation because I was thinking in terms of Object-Oriented Programming (which is pretty much what I started with). You have your turtle. It can do stuff. Make it do stuff. It is the turtle's ways to action.

But I came around to your view of starting with forward() and right() directly and you make a "bridge", a "pretend" way to make it work. (what I assume you are calling your adapter file)
First contact for the reader/doer is with the code, and that code is an active verb. (here your free functions)
Let's see it do something. Immediate interaction. A function or method is directly understandable.
This is a function, then you introduce parameters (as seen in your README), etc...

As long as you have a smooth transition later to explain the initialization of turtle and then the dot notation, this should work. It is like "now I should you what's behind the curtain".

I feel the transition if presented logically gets over the hurdle of having to "undo" some of the earlier magic. It is valid in my view as a preparation for software engineering... Now you see this level, but actually, there is a layer under this. If you get to understand this, actually, there are more details underneath, etc.. It is one level of comprehension at a time and in my opinion a great way to teach how to learn and not be intimidated.
I hope I make sense.

I had not asked who your target is for this code and the accompanying book? I have not seen your latest conference talks about this either, so I was wondering. You could email me to discuss this if you wish. I am curious of this project.
Forward()