Home

Formatting this post in WordPress.com was a great pain. It does not render correctly on some browser / device combinations, despite my rewrite efforts. So a Markdown copy of this post can be found as a gist here.


The year is 1998 and @mtheofy then at Glasgow tells me about a relatively new (then) language called Haskell. I’m intrigued but do not do much. A few years later I buy The Haskell School of Expression since The Craft of Functional Programming did not seem enough to motivate me. Time passes and around 2007 I try yet another start. Nothing. I promised my self yet another restart for a 2017 new year’s resolution. Still nothing. So when the current employer offered Haskell classes I could not say no. Armed with the weekly classes and a Safari Learning Path I am trying to correct this. And I am having some fun with list comprehensions. Because as a friend says, if it makes you feel good, go.

So how do you write an infinite list? Let’s say you want list x to include all numbers from 0 to infinity. stack ghci is my friend. Others might try repl.it:

x = [ n | n <- [0..]]

Now you can have the first 20 items of x:

Prelude> x = [ n | n <- [0..]]
Prelude> take 20 x
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
Prelude>

So next I wanted to make an infinite list of the same character. Enter the underscore variable:

Prelude> x = [ 'a' | _ <- [0..]]
Prelude> take 20 x
"aaaaaaaaaaaaaaaaaaaa"
Prelude>

OK, so now let’s try to cycle infinitely characters from a string. I end up with:

Prelude> x = [ c | i  take 20 x
"abcdabcdabcdabcdabcd"
Prelude>

I am kind of unsure why the let statements are needed since I am ~10 days into typing stuff and posted my creation to twitter. What my expression says is that x is comprised of characters from string “abcd”, where given a sequence of numbers, each time a character is chosen based on the sequence number modulo 4. Strings are lists of characters in Haskell and list indexing starts from zero.  Helpful comments come my way. Like the obvious cycle (there is a cycle function? Yes ):

Prelude> take 20 (cycle "abcd")
"abcdabcdabcdabcdabcd"
Prelude> take 20 $ cycle "abcd"
"abcdabcdabcdabcdabcd"
Prelude>

Is not the dollar operator nice to get rid of parentheses? Here is another suggestion about cycling a string:

Prelude> x = [ "abcd" !! (i `mod` 4) | i  take 20 x
"abcdabcdabcdabcdabcd"
Prelude>

This one is more concise and does the same thing, always picking a character from "abcd". If the infix notation for mod confuses you, you can:

Prelude> x = [ "abcd" !! (mod i 4) | i  take 20 x
"abcdabcdabcdabcdabcd"
Prelude>

But the Internet does not stop there. It comes back with more helpful suggestions:

Welcome! A little feedback then if I may: the !! operator should be used VERY cautiously it is not typesafe and lists are not random access anyway. Opt for a function returning Maybe x and for a random access datastructure (strings are by default lists).

Which made me think: How about an infinite string randomly chosen from “abcd”?

$ stack install random
$ stack ghci
:
Prelude> import System.Random
Prelude System.Random> g <- newStdGen 
Prelude System.Random> x = [ "abcd" !! i | i <- randomRs (0,3) g ]
Prelude System.Random> take 10 x
"bcbbddcdab"
Prelude System.Random>

If you want a sequence with a different order, you need to reinitialise both g and x. I will figure out a better way some other time when …I have time.

Adventures with Maybe maybe in another post.

Formatting this post in WordPress.com was a great pain.

Advertisements

DOW ↓

2018/02/06

“The stock was down 86 cents over the day. That means Bill lost $70 million today, whereas I only lost fuck all. But guess who’ll sleep better?”

Microserfs

[In-Reply-To:]

sleep

2017/12/31

These days I am reading Autonomous in which humans and autonomous robots coexist (there are also indentured humans and robots) and at one point a remark is made about a robotic research assistant that does not need to sleep, implied as an advantage.

This is not something new.  In Beggars in Spain (the first book) there are also genetically engineered people who do not sleep with this being a competitive advantage and causing friction among sleepers and non-sleepers.

And then I remember Marissa Mayer talking about being “strategic about when you sleep, when you shower, and how often you go to the bathroom”.

I think Age of Em deals with this in a better way having Ems slow down their CPUs (making it a matter of energy cost, but I have not finished that book, so I am not sure how this idea gets developed).

Which is why I want to leave you with the 6-2-1 rule that popped into my twitter stream: 6 hours of sleep, 2 meals per day, 1 shower. Analytics from my Nokia Go say that I am not really following this.

Happy New Year.

resolutions

2017/12/22

Last year I promised myself that I would revisit Haskell. Well I did not, so I did not escape the new year’s resolutions cliche. It was an interesting year though, considering that I left my country, worked for Intel, resigned and returned back to Greece and to my previous work.

So for this year I will promise myself something simpler, as a continuation of things I still do in 2017: simply improve my Go-fu. And yes, I also tried to learn Go and miserably failed. Let’s see about that too.

It has been a while since I last blogged, so here is something funny that I learned today while listening to Relatively Prime:

Matt Parker took it upon himself to debunk junk science related to precise geometry choices by Ancient People. The particular junk piece that triggered his analysis was the assertion of a prehistoric navigation system. However, you may not be familiar with it, but you may have heard terms like “holy geometry” and the like to prove that some Ancient tribe either held some technology now long gone or was in contact with some alien race. But do they really stand?

So Matt, took it upon himself to analyse the locations of the Woolworths in order to figure out whether they had some “outer” help in choosing their store locations:

The results revealed an exact and precise geometric placement of the Woolworths locations. Three stores around Birmingham formed an exact equilateral triangle (Wolverhampton, Lichfield and Birmingham stores) and if the base of the triangle is extended, it forms a 173.8 mile line linking the Conwy and Luton stores. Despite the 173.8 mile distance involved, the Conway Woolworths store is only 40 feet off the exact line and the Luton site is within 30 feet.  All four stores align with an accuracy of 0.05%

So there, proof! Aliens helped them :) Plus, sometimes you need to remind people that 3 points always make a triangle, no coincidence there.

You can read the whole analysis here thanks to the Internet Archive. Given enough data, if you’re looking for a pattern, you’re going to find it I guess.

As long as P versus NP remains a mystery we do not know what we cannot do, and that’s liberating.

I follow Lance Fortnow’s blog from time to time. So when the book was out, I fired up the kindle and bought it. And then it stayed there for some time. Most likely because two out of seven days of the week I am not sure I can explain P vs NP. The rest I might be able, but the difficulty of the problem makes one double think about it, even when it is a book that makes it accessible to the general public. After all, it is The Problem.

And then came a plane trip. And with nowhere to go for the next 2,5 hours I started reading it. Fast. The history of the problem is there. Examples that are very easily understood are there. The hop from the example to the equivalent real problem is there, so you get to understand vertex cover before ever knowing the name.  Plus you get to learn a bit about complexity during the Cold War and about quantum computing too.

We know for example that if P=NP, then cryptography as we know it will be defeated. But how will other aspects of our World change? Fortnow offers a glimpse. Is it worth it? Maybe. You will be the judge. Is it likely that P=NP? The author does not believe so (I do not want it to be, and want versus believe denotes the vast skill difference between him and me).

Chapter 2 was a bit boring for me and I almost gave up on the book. Fortunately I did not. If you are a computational complexity theorist then the book is not for you, but if you are not and you want to ask clear questions to one, then it will definitely help.

I’ve posted this in 2014, but a friend’s comment on facebook makes me want to repost this:

“I think we’ve had a reduction from, say, if you think about 1995, which was when I went to college, you could typically rely on an undergraduate having done a substantial amount of real programming, often quite a deep level of technical work on one or more platforms. Many of us could program in one or more assembly languages. And yeah, within 10 years of that point, we were getting to a point where your average applicant was maybe somebody who’d done, as you say, a little bit of Web design, maybe a little bit of Web programming—you know, we saw quite a bit of people who‘d maybe done some PHP but not that kind of deep technical understanding of how machines work.”

This was from an Eben Upton interview. So much progress has happened that people entering the profession do so with a distance from the hardware.