Forem: Sócrates Díaz

Software is like gardening

Sócrates Díaz — Mon, 12 Nov 2018 17:14:32 +0000

Recently I've been reading The Pragmatic Programmer (for the second time 😁), and I came to one analogy that struck me hard, and changed my whole thinking about software development.

In the chapter 6, called While you are coding, page 184, the author says:

Unfortunately, the most common metaphor for software development is building construction. [...] Rather than construction, software is more like gardening--it is more organic than concrete.[...] You constantly monitor the health of the garden, and make adjustments (to the soil, the plants, the layout) as needed.

This just made me realize the contradictions I've been living with and the need to come to terms with software development and its real lifecycle. More often than not, software is not just written and that's it. It evolves over time as needs arise. The code you wrote 6 months ago might be rewritten, and that's fine. Dependencies update, your software changes due to it. Et cetera.

This may not be news to you as a software developer, but an unpleasant quantity of non-technical people who works with developers, may not understand this and think this is like building construction (as I did before). This is your pitch for them:

Software is not static. Software is alive.

Thanks for reading.

Credits: Photo by Markus Spiske on Unsplash

Optimizing code with algebra

Sócrates Díaz — Sun, 30 Sep 2018 03:38:06 +0000

Photo by Roman Mager on Unsplash

During a semester in college I took a subject called "Discrete Mathematics". The lecturer decided to split the class in groups. Each group consisted of 2 or 3 students. They were meant to do expositions about a particular subject assigned by the lecturer.

In the group I was on (we were only two, actually), we were assigned with the subject of recurrency relations. According to Wikipedia, this is:

an equation that recursively defines a sequence or multidimensional array of values, once one or more initial terms are given: each further term of the sequence or array is defined as a function of the preceding terms.

In other words, a recursive function ;)

A perfect situation to explain this concept with code :D

Hanoi Towers

Do you remember this toy?

The famous Hanoi Towers. The game consists of moving every disk from the first pole to the last one (from left to right or viceversa) in the least amount of steps possible. The rules are that a bigger disk cannot be over a smaller one and you can move only one disk at the time. Something like this:

This problem has an algorithm that solves it, it goes like this:

Where n is the amount of disks in the problem.

Let's code that

Let's use Python to write that algorithm. It's something like this:

def hanoi(n):
    if n <= 1: return 1
    else: return 2 * hanoi(n-1) + 1

So if we have 4 disks...

>>> hanoi(4)
15

Good. It works. Let's give it a few tries

>>> hanoi(5)
31
>>> hanoi(10)
1023
>>> hanoi(40)
1099511627775

Looks pretty good. Now I know how many moves it will take me if I'm using 40 disks (btw, this is gonna take you 10460 years, never try this at home). But what if I have 7000?

>>> hanoi(7000)
Traceback (most recent call last):which
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in hanoi
  File "<stdin>", line 3, in hanoi
  File "<stdin>", line 3, in hanoi
  [Previous line repeated 994 more times]
  File "<stdin>", line 2, in hanoi
RecursionError: maximum recursion depth exceeded in comparison

Oh... It seems this is not performant enough. Of course you could "solve" this just increasing the maximum recursion depth in Python (with sys.setrecursionlimit(n)), but it's a much better idea to optimize this.

Optimizing

There are several ways to solve recurrence relations, one of them is iteration. It consists of solving the operation step by step and deducting the non-recursive equation from the process. First we try to solve a given value:

Then, from the last line, we can deduce an equivalent equation:

If you notice, t(4) = 8 + 7 is the same as t(4) = 2^(4-1) + (2^(4-1) - 1), that's why it's our initial statement. But now we have solved the recurrence relation, let's use that in our code.

def better_hanoi(n):
    return 2**n - 1

And then...

Now we know how many steps will take to solve it with 7000 disks (probably the lifetime of the universe, several times).

Conclusion

We have optimized a small algorithm with concepts of discrete mathematics, this is just to give a little insight on how we can benefit of such simple concepts to build better programs.

How to teach programming to my 10 years old nephew?

Sócrates Díaz — Sun, 30 Sep 2018 01:11:50 +0000

Often my sister and her children come home during the weekend, and my nephew is always around to see what I'm up to. I asked him, "do you want to make your own game?" to which he replied "well, yeah, but I need to learn to code first". And then this question struck me "How do I teach him?".