Let a be any expression. We will call x the fixed point of expression a if x names ax. (Reminder: lower-case letters in our programming language represent a combination of upper-case letters.)

The fixed-point principle says that for each expression a there exists its fixed point x. Furthermore there is a (quite simple) “manual” for constructing the fixed point x of any expression a.

So the question of the day is: can you find that “manual” proving fixed-point principle?
(E.g. a program x that names ABCx, for a = ABC.)

Solution

The post Programming Brain Teaser #6: Fixed-point principle appeared first on Salsita Software.

As usual, we’ll use only Q and R rules (described here).

Question 1: Find expressions x so that RQx names (resolves to) QRx.

Question 2: … RRx –> QQx

Question 3: … RQx –> RRx

(You can check how previous riddles were solved. This could help a lot in case you don’t know how to approach solving this.)

Solution

The post Programming Brain Teaser #5: More curiosities appeared first on Salsita Software.

Question 1:
For what statement x the following is true:
Rx = x

Question 2:
For what statement x the following is true:
Rx = Qx

Solution

The post Programming Brain Teaser #4: More Rx riddles appeared first on Salsita Software.

From the rules definition you know that for any statement x the following is true:
RQx = xx.

But is there such a statement x for which the following is true?:
Rx = xx.

Solution

The post Programming Brain Teaser #3: Repetition riddle appeared first on Salsita Software.

The brain-teaser of the day is: can you find statement x that names itself (i.e. “resolves to string” x)?

Are there more of them or just one? Find the self-reference statement pattern or explain why there is no such pattern and only one self-referencing statement exists in this programming language.

Side note: this question is similar to what is in computer science known as quine. It is a program that has no input and prints its own source code on its output. After solving the brain-teaser here, you can apply the same idea and create a quine in your favorite programming language.

Solution

The post Programming Brain Teaser #2: Self-reference appeared first on Salsita Software.

So if you are interested, take your seat and let’s get started with the first story.

The isle of robots, cloning program

Once upon a time, there was an island, which was very noisy. There were plenty of robots buzzing among piles of their own spare parts, busy with creating new robots, fighting each other, meeting their “friends”, or planning conspiracies against their “enemies”.

Each robot had a label written on its chest. At first glance, one could say that the string was some sort of identification, but it turned out that it actually was a program telling the robot what exactly to do.

There were many different kinds of robots (very likely as many as programming languages), we’ll check a few of them.

Let’s start the discussion about the first programming system with the following definitions:

• A term is a sequence of (any number of) CAPITAL letters, e.g. LLAZBPWS.
• Lower case letters (e.g. x, y, z, a, b, c, …) are used as shortcuts for terms, e.g. we can say that x represents ABC, or that y stands for DEFGHI.

We can combine terms with shortcuts, to get the final term, we substitute all lower case letters with what they represent. For example, using the definitions for x and y above, the statement AxC corresponds to term AABCC, and statement LxQy evaluates to term LABCQDEFGHI.

In the programming system we are about to explore now, certain selected statements are used as names for other statements. The system contains two rules for naming the terms:

• Rule Q (quotation): For every statement x, the statement Qx names x.
• Rule R (repetition): For every statement x that names y, the statement Rx names yy.

You can imagine that operation Q takes the rest of the statement and creates a quoted string out of it. E.g. QABC –> “ABC”.
The rule R can be thought of as a function that takes a string and creates another string: R “ABCD” –> “ABCDABCD”.

But let’s see some examples in the syntax of the explored programming language now, where the quotation marks are NOT part of the syntax: RQB names BB (because QB names B). Similarly, RQBR names BRBR (because QBR names BR). Remember: the terms are (as usual programs in any other programming languages) interpretted from left to right.  That means that the first Q in the term makes the rest of the term a string / an argument for function “calls” of the operators to the left.

To complete the initial set of programming rules, let’s add one rule for creating new robots:

• Rule C (creation): If x names y, then Cx constructs robot y.

Examples: For any statement y we know that robot CQy creates robot y (simply because Qy names y).  And robot CRQA will create a new robot with program AA.

OK, enough definitions and rules, now something for you to solve (using the programming system described above):

Describe a program of the robot creating its own clone. That is: the resulting program of the newly created robot must be the same as is its creator’s program.

Solution

The post Programming Brain Teaser #1: Getting Started appeared first on Salsita Software.

Every now and then you come across an array and you want to combine its items somehow to compute a value. But the final result depends on the intermediate results of each step so you need to use an acumulator that holds those. And things get messy.

That’s where reduce shines.

You give it an array, a function and an initial value and it builds up a return value for you by recursively applying the function to each of the items while passing in the intermediate result.

Gee, that sounds complicated

But it’s not, really. All that happens is you take the initial value and combine it with the first item of the array to get an intermediate result (let’s call it result1). Then you you combine result1 with the second item of the array and get result2. And so on and so forth until you combine with the last item N and get resultN (which is the final one). That’s it, no rocket science here.

Also: good for the planet.

A few real-world examples should make this clear.

Compute a sum of an array of integers:

sum = _.reduce [1, 3, 5, 7, 9], ((memo, i) -> memo + i), 0

…which basically resolves into:

( ( ( ( ( 0 + 1 ) + 3 ) + 5 ) + 7 ) + 9 )

The third parameter to reduce is the initial value used to ‘seed’ the computation; the iterator function is always called with an intermediate result – in the case of the first call the intermediate result is simply the initial value. In this case, we want a sum of ints so the initial value should be the additive identity (i.e. zero).

Flatten an array of arrays:

flat = _.reduce [[1, 2], [3, 4], [5, 6]], ((memo, arr) -> memo.concat arr), []

…which is an equivalent of:

( ( [].concat( [1, 2] ) ).concat( [3, 4] ) ).concat( [5, 6] )

Recursively access a property of an object:

item = {post: author: id: '42'}
_.reduce 'post.author.id'.split('.'), ((obj, part) -> obj[part]), item

…which is effectively the same as:

( ( ( item['post'] )['author'] )['id'] )

foldl vs. foldr

If you take a look at the examples above you’ll probably notice they’re all left-associative – the combinations always start with the first item in the array.

What if you wanted right-associativity (i.e., start with the last item)? Well, in such a case you’re looking for a function conveniently named foldr or reduceRight (in Underscore.js). Unfortunately, foldr is more useful in languages with lazy evaluation such as Haskell (foldr recurses into an argument and hence can be used on infinite lists).

Next in the series we’ll cover a handful of useful little utility functions like ‘all’ and ‘any’.

The post Going Functional – Reduce appeared first on Salsita Software.

What’s it all about then? Here comes the important bit: the new array will have the same size as the original one. Always. In other words, the map function defines an ‘N -> N’ mapping. If you see it used, you immediately know the author wants a homomorphism.

cleanStrings = _.map dirtyStrings, (str) -> str.trim()

_.map list, (obj) -> obj.doStuffWithSideEffectsAndNoReturnValue()

cleanStrings = (str.trim() for str in dirtyStrings)

cleanStrings = (s.trim() for s in dirtyStrings when s.length > 2)

The post Going Functional: Map appeared first on Salsita Software.

But what if you are writing a bootstrapped extension? XUL overlays are not supported, so you have to add the button to the toolbar palette by hand. Coordinating the toolbar palette, the visible toolbar and the toolbar’s persistent current set isn’t rocket science, but it is a bit tricky. You want to make sure that the button is added to the toolbar on first run and is visible on subsequent runs. At the same time, it should be possible to remove it and add it back using the toolbar customization feature.

After some trial and error, as well as plundering Dmitry Gutov‘s nicely written Replace Bookmark extension for ideas, I came up with the following function:

This function ensures that the button is always added to the palette (i.e. what the overlay would normally do). On first run, it adds it to the far-right of the toolbar. On subsequent runs, it inserts the button manually into the correct position if it is in the currentset. This is the only bit that is substantially different from the behavior in a traditional extension. I suspect this is necessary because the button is not in the palette yet at the point when Firefox processes the currentset and adds the buttons automatically.

Remember that you should remove the button from the palette and toolbar manually when the extension is disabled or uninstalled to avoid memory leaks.

The post Adding a Toolbar Button in a Bootstrapped Firefox Extension appeared first on Salsita Software.

Take a look at the following piece of code. What’s wrong with it?

myAwesomeFunction = (objects) ->
   isGreat = false
   for item in objects
     if not item.isImportant
       continue
     if item.isGreat
       isGreat = true
       break
  return isGreat

Does it go through all the items? No but, man, is that break on the last line easy to miss.
What does it do? Too bad a for loop has no return value. In order to get any idea you need to look into the loop code.

Now compare it with the following version:

myAwesomeFunction = (objects) ->
  return _.any objects, (o) -> o.isImportant && o.isGreat

Even if you’re not familiar with the (wonderful, by the way) Underscore.js library, you can pretty much guess that myAwesomeFunction returns true iff objects contain a great important object.

Now, you could make a (valid) point that the original function is not a shining example of super-ninja programming skills. But that’s just another thing to point out: using for loops doesn’t push us, programmers, to be any clearer. Actually quite the opposite – it stands in our way by forcing us to remember we’re in a loop and we’ve to deal with it.

When it comes to expressing our intentions, a for cycle is a low level construct; unless you read the code thoroughly and really understand, you can’t know what the purpose of the loop is. It can filter something out or transform all the items in the list. It can signal whether a certain item is present. Frankly, for all I know it can brush your teeth and sleep with your wife.

It’s just too powerful. Too universal.

Now, in case CoffeeScript (or JavaScript) is your language of choice, chances are you’re not writing the type of software where speed is essential. Which means (or should mean, anyway) readability beats raw speed. Hands down. And that’s when functional programming saves the day.

In the next article of this series, we’ll take a look at the ‘map’ function.

The post Going Functional appeared first on Salsita Software.