These excerpts are from a response to a reader on the wonderful tumblr by Jerome Herr, Experiments In Processing.
Learning to code is like learning a natural language: it’s quite hard and slow at first but if you hold on just a little then suddenly you start seeing all the beauty of it and you’re amazed about how you suddenly understand what’s going on and how you can create stuff (designs or sentences) on your own!
Start with something that you understand and then, VERY IMPORTANT, play with it! What I often do is that I simply add a new instruction, maybe one from a previous tutorial or sketch, to see how that will look. Or I wonder: what will the animation look like if I use very big ellipses? or very small ones? only 10 of them? or a 1000? What if I make this rectangles rotate a bit? A lot? What if I apply this to only some of them?
So it’s not just about staring at the screen. It’s also about sketching stuff on paper and about letting yourself be inspired by everything you see in the world around you! Look at all the patterns that you can see in the natural world, day in and day out: in buildings, on the sidewalks, in the behaviour of cars or birds. Try to recreate those patterns. Start with the easy ones, obviously Look at Muslim art, lots of patterns to be found there. Or the art of Sol Levitt. And go to art museums, they can be very inspiring anyway!
Hat tip to Jim Olsen and John Golden:
Great activity for kids (and adults) of many levels:
How many rotations until the loop is closed?
(This is a crosspost from my weekly photo site.)
The Introduction to Computer Programming Class had a Skype Q and A with Jason from Dark Sky (Dark Sky is an iOS weather app, check it out, it’s fantastic. They also make the great weather site forecast.io.) Super nice guy, I just emailed and asked, and it was scheduled a day later. Great experience for these kids.
Here’s some student responses to the prompt: “What blew your socks off? What’d advice/stories/information was surprising?”
- When how he told that if you really want to learn something. you need to be able to do it on your own time
- I think it is motivational that someone who is successful had a hard time and still does sometimes and still does what he wants to do.
- I thought it was really interesting when he talked about “reverse engineering” video games, and that was how he learned trigonometry. But now that I think about it, it isn’t surprising that it was easier for him to learn something difficult while immersing in something he was passionate about.
- The most surprising fact was that he wrote 45,000 lines of code to make the app originally, and then he modified it to do more, but only required 8,000 lines of code. I also really liked how he encouraged people to go on their own and explore other programs by themselves.
- What I guess what surprised me the most was how he compared computer programming to dance or singing or art. Going into this class I perceived computer programming as a very technical and systematic subject…that everything is by the book. While this may be true… talking to the developer brought to my attention that computer programming can be largely reliant on self discovery and self error.
- I was shocked when Jay told us how long it took to create his app and how many lines of code it required (45,000).
A student talked about Kaprekar’s constant (6174) during their my favorite presentation.
Steps (from wikipedia):
- Take any four-digit number, using at least two different digits. (Leading zeros are allowed.)
- Arrange the digits in descending and then in ascending order to get two four-digit numbers, adding leading zeros if necessary.
- Subtract the smaller number from the bigger number.
- Go back to step 2.
Here’s an example (also from wikipedia):
For example, choose 3524:
5432 – 2345 = 3087
8730 – 0378 = 8352
8532 – 2358 = 6174
Fun right? Also fun to program, here’s the python code that tries every number from 1000 to 10000, and counts how many steps it takes to get to 6174 and puts the results in a csv file:
if (len(nstr) == 0):
elif (len(nstr)==4) and (nstr == nstr == nstr == nstr):
digit = -1
index = 0
for i in range(0,len(nstr)):
if (digit < int(nstr[i])):
digit = int(nstr[i])
index = i
return str(digit) + largest(nstr[0:index]+nstr[index+1:len(nstr)])
count = 0
nstr = str(n)
while (n != 6174):
l = int(largest(str(nstr)))
lstring = str(l)
s = int(lstring[::-1])
n = l - s
nstr = str(n)
while (len(nstr) < 4):
nstr = "0" + nstr
count += 1
f = open('kaprekar.csv','w')
c = 1000
while (c < 10000):
f.write(str(c)+ "," + str(kaprekarSteps(c)) + "\n")
c += 1
I saw this toot by Matt yesterday morning and I loved the visual of the color based on the number of steps of Euclid’s GCD algorithm. The algorithm is pretty straightforward and it’s a nice example for either using recursion or using a loop. The coloring is fun to mess with too. The coding went quickly for me because I already had the code for breaking a 1D pixel array (why processing??) into x and y coordinates.
There’s two variations:
Here’s the link for the GCD steps version.
And here’s the link for the GCD version where the closer the GCD is to the minimum of x and y, the more white the pixel is.
Here’s the recursive algorithm:
int euclidGCD(int x, int y)
if (y == 0)
else if (x >= y && y > 0)
Here’s the loop algorithm to count the number of steps:
int euclidGCDsteps(int x, int y)
int steps = 0;
if (x >= y)
while (y != 0)
t = y;
y = x % y;
x += t;