Devraj Mehta

4Clojure for learning Clojure

Sun, 07 Jun 2015 00:00:00 +0000

I completed all of the 4clojure problems!

After four weeks of consistent focus I made it through all 156 problems on 4clojure.com Proof: my user page and list of top users.

You can see most of my solutions in the github repo I used for this project. I only committed problems to the repo that I needed to develop inside the editor. Some problems were simple enough to be solved on the website. The ones in the repo should be the more interesting problems.

I’d like to share some of my favorite problems and solutions. Warning: these are spoilers for 4clojure, of course. If you’re interested in learning clojure I’d highly recommend not reading this post and attempting the problems without looking at any answers. The problems start with the basics of the language and build up to substantive and challenging coding exercises in their own right. Each problem is presented with a set of unit tests. Once you solve a problem you can see everyone else’s solutions. This is great for benchmarking yourself and picking up other people’s tricks.

This was my first adventure into clojure and I found the 4clojure problems great for motivating me through the initial learning curve, perhaps a bit past it. Of course, after 4 weeks I’m definitely still a beginner with clojure so I welcome any feedback!

Fibonacci

http://www.4clojure.com/problem/26

The classic Fibonacci series problem. A goto for learning any language especially a functional language. This was the first problem I had to write down because I kept tripping myself with how conj adds to the beginning of lists. This frustration is definitely apparent in my submitted solution.

(defn fib [n]
  (if (< n 3)
    (repeat n 1)
    (let [prev (reverse (fib (dec n)))]
      (reverse (conj prev (+ (first prev) (second prev)))))))

This approach works but is kludgy and far from efficient. Knowing what I know now I’d opt for using a lazy sequence.

(defn fibo [n]
  (letfn [(fib [a b] (cons a (lazy-seq (fib b (+ a b)))))]
    (take n (fib 1 1))))

Another good approach would be using loop and recur because clojure doesn’t tail optimize unless recur is used.

(defn fibloop [n]
  (loop [remain n ret [] a 0 b 1]
    (if (= 0 remain) ret
      (recur (dec remain)
             (conj ret a)
             b
             (+ a b)))))

Replicate a sequence

http://www.4clojure.com/problem/33

While I came up with the alternative fibonacci solutions above many of the alternatives I saved with my solutions were other user’s solutions. For example, let’s take problem 33: repeating each element in a series. This was my solution:

(defn repf [col num]
  (reduce #(concat %1 (repeat num %2)) '() col))

While there’s nothing wrong with my solution per se I learned a better alternative from another user (_pcl). Their solution uses a core API call that does part of what I was doing: mapcat.

(defn better_repf [col num]
  (mapcat (partial repeat num) col))

Insights like this from other users’ solutions were tremendously useful in learning different parts of the clojure API’s very quickly.

Sequence Reductions

http://www.4clojure.com/problem/60

Another place that I got great feedback was the clojure source code. I was introduced to clojure code by the 4clojure problems that consist of reimplementing core functions. The clojure docs link to the relevant line in the source. I really appreciate when documentation links to the source it’s describing.

https://clojuredocs.org/clojure.core/reductions See the link to source in the top right under clojure.core.

https://github.com/clojure/clojure/blob/clojure-1.6.0/src/clj/clojure/core.clj#L6628

(defn reductions
  "Returns a lazy seq of the intermediate values of the reduction (as
  per reduce) of coll by f, starting with init."
  {:added "1.2"}
  ([f coll]
     (lazy-seq
      (if-let [s (seq coll)]
        (reductions f (first s) (rest s))
        (list (f)))))
  ([f init coll]
     (cons init
           (lazy-seq
            (when-let [s (seq coll)]
              (reductions f (f init (first s)) (rest s)))))))

I found the clojure source very readable and approachable. Once I started reading the source for the core function problems I started referencing it for other problems as well.

Prime Numbers

http://www.4clojure.com/problem/67

I didn’t learn anything in particular from this problem. I just love this method of testing primality.

; first n prime numbers
; sneaky regex version ;]

(defn __ [n]
  (take
    n
    (filter
      #(empty? (re-matches #"^1?$|^(11+?)\1+$" (apply str (repeat % "1"))))
      (range))))

Naming the solution function __ double underscores was a trick that I picked up to make copying and pasting the testcases from 4clojure quicker.

(assert (= (__ 2) [2 3]))

(assert (= (__ 5) [2 3 5 7 11]))

(assert (= (last (__ 100)) 541))

I used a vim mapping for adding the asserts. The vim set up for clojure should probably be a post to itself because that took a minute.

Language of a DFA

http://www.4clojure.com/problem/164

The problems on 4clojure are divided into four tiers of difficulty: elementary, easy, medium, and hard. Elementary and easy often could be solved on the website sometimes in one line or one word. The medium and many of the hard were great for making me think a little deeper about the language and use it a more throughly in a substantive problem. The last ten or so of the hard category, however, were a different kind of beast entirely. While I was able to solve the first 140 problems in the first three weeks, the last dozen or so problems took up a disportionate amount of time. I really liked them. They were legitimately difficult.

One of my favorite problems from this group asks to produce the language of deterministic finite automaton (DFA). The class that introduced me to formal languages and their machines was one of my favorite in college, so I’m always excited to see something like a DFA come up. I also like this problem because it makes use of lazy execution which is readily available in clojure.

(defn __ [dfa]
  (letfn
    [(map-trans [cur trans]
       (when trans
         (map (fn [[t s]] {:state s :path (str (:path cur) t)}) trans)))
     (enq [trails]
       (when (not-empty trails)
         (lazy-seq
           (let [cur (first trails)
                 next-trans (get-in dfa [:transitions (:state cur)])
                 next-trails (concat (rest trails) (map-trans cur next-trans))]
             (if ((:accepts dfa) (:state cur))
               (cons (:path cur) (enq next-trails))
               (enq next-trails))))))]
    (enq [{:state (:start dfa) :path ""}])))

(assert (= #{"a" "ab" "abc"}
           (set (__ '{:states #{q0 q1 q2 q3}
                      :alphabet #{a b c}
                      :start q0
                      :accepts #{q1 q2 q3}
                      :transitions {q0 {a q1}
                                    q1 {b q2}
                                    q2 {c q3}}}))))

At each step in the recursion I have passed down a sequence of substring objects trails, which is used as a queue. For the first substring out of this queue, I enqueue all the states to which the DFA could transition from that substring’s state. Finally, before recurring I check if the current substring is accepted by the DFA by simply checking its’ state. If so, I add it to the lazy sequence. Either way, I recurse with the new queue of substrings and states next-trails.

While the problem wasn’t the hardest of the hard (see 140, 152, or 127) it’s a great example of the progress of my clojure writing at the end of these four weeks. I really enjoy several aspects of the language which are used here:

hashmap objects

{:state (:start dfa) :path ""}

keywords as getter functions from hashmap objects

(:start dfa)

argument destructuring

(map
  (fn [[t s]]
    ; this function is passed a key-value pair for each character
    ; state pair in the iterated map of transitions
    {:state s :path (str (:path cur) t)})
  trans)

the let macro’s first-to-last evaluation

(let [cur (first trails)
      next-trans (get-in dfa [:transitions (:state cur)])

and as I already mentioned availablity of lazy evaluation functions

I had a lot of fun going through 4clojure and I am very thankful to the creators and maintainers. I look forward to more fun with clojure in the future.

Motivation Chrome Extension

Thu, 04 Dec 2014 00:00:00 +0000

The latest project I have been working on is a fork of a chrome extension. I saw a friend running this chrome extension which replaces the newtab page in chrome with a page that displays his age to nine decimal places.

This extension caught my attention because I liked the idea of getting rid of the thumbnails on the default new tab page. I found myself often getting distracted by my most visited sites whenever I opened a new tab. Having my age ticking by instead seemed like it would be much more motivational. It turns out there is a whole genre of motivational new tab page chrome extensions.

Despite how much I liked maccman’s implementation I wanted to tweak the appearance a little. Thanks to github, I soon had a fork of the motivation extension and after some css tweaks I was very happy. Of course, once you give a moose a muffin the moose decides to refactor the backbone to angular, add grunt, and start adding features. I had an idea for bookmarks on the new tab page. When you open a new tab you should be able to quickly access your frequent bookmarks. I implemented this vim-style so that after focusing on the page ¹ pressing the number ² of the bookmark opens it. Going further with inspiration from vim, hitting the spacebar and then the number of a bookmark folder opens all of the folder’s contents in tabs. Of course, basic mouse clicking works as expected and middle clicking on a bookmark folder also opens all of the folder’s contents in tabs.

At this point, the bookmarks feature is complete and separable from the rest of the extension (thanks angular!) If I ever get tired of the age counter, I would definitely reuse the bookmarks module for my next new tab chrome extension.

I also have more development plans for the bookmarks component. Currently, I’m interested in duplicating all the functionality of the native bookmarks ³. Right now I have completed navigating and deleting. On the backlog is renaming/editing and rearranging.

The project is on github devm33/motivation and the latest release of the extension is available on the chrome webstore.

Default focus for new tab page is the url bar. A single tab brings focus to the page or more specifically to the first link on the page. I’ve noticed some chrome extension widgets will insert themselves in the focus chain after the url bar though, so shift-tab is useful in that case to go backwards through the focus chain, i.e. the last link on the page. ↩
The key for a bookmark will be a number if the bookmark is in the first nine bookmarks. After that the characters are used in the order the are defined by character code, starting with ‘:’ at 58, ‘9’ is 57. ↩
Or, at least I will implement as much as is possible with the chrome extension bookmarks api which I currently believe is everything. ↩

Jekyll on NearlyFreeSpeech

Mon, 22 Sep 2014 00:00:00 +0000

This turned out to be a bit of an adventure…

Gem install setup

By default ruby and rubygems are available, but the default gem install location is not writable from a user account. In order to work around this set up gem to install into your home directory:

export GEM_HOME=/home/private/gems
export GEM_PATH=/home/private/gems:/usr/local/lib/ruby/gems/1.8/
export PATH=$PATH:/home/private/gems/bin
export RB_USER_INSTALL='true'

Which I conveniently found the jekyll docs themselves: http://jekyllrb.com/docs/troubleshooting/

Then on that shell install jekyll

gem install jekyll

In order to run the jekyll just installed it needs to be found in

/home/private/gems/bin/jekyll

This may be useful to prepend to your PATH for convenience.

In any case the next issue I came across was not having a valid javascript runtime.

/home/private/gems/gems/execjs-2.2.1/lib/execjs/runtimes.rb:51:in `autodetect': Could not find a JavaScript runtime.
See https://github.com/sstephenson/execjs for a list of available runtimes. (ExecJS::RuntimeUnavailable)
...

After some cursory perusal it appeared installing node on NFS might be hard, but since the gem environment was all set up it made sense to use a ruby alternative. execjs was the rubygem complaining about not being able to find a runtime and on its github page serveral alteratives are listed: https://github.com/sstephenson/execjs#execjs I went with therubyracer since it was recommended by the jekyll docs (see that helpful troubleshooting page again)

After installing therubyracer my local gem install did work, but I noticed as well the system provided jekyll executable (installed in the main gem directory) was also working. But there was a catch both jekyll binaries were broken again if I opened up a new session, most likely because the environmental variables exported above were lost.

Gem installing take 2

Persusing the literature a little further I came across this very helpful post installing custom gems on your hosted jekyll blog which outlined how to install gems in a more sustainable fashion, but within a users permissions. The key takeaway was to run

gem install therubyracer --user-install

which installed the gem in the user’s home directory but on the gem search path which can be checked by running

gem env

and looking for gem_path another neat tidbit from the article.

The next issue I ran across seemed similar:

/usr/local/lib/ruby/site_ruby/1.9/rubygems/dependency.rb:247:in `to_specs': Could not find kramdown (~> 1.0.2) amongst

Learning that ~> 1.0.2 meant between version 1.0.2 and 1.1 from this issue I simply applied a similar process to get the right version of kramdown

gem install kramdown --user-install -v 1.0.2

This went fine and I could tell I had progressed since I was now getting a new error from jekyll --version complaining about a different gem. This was no longer a path I wanted to go down.

New Approach

Putting it down and walking away for a bit allowed me to think about the problem I was facing with all these old versions of gems and of jekyll: why don’t I just get on the bleeding edge right? Then it occurred to me that NearlyFreeSpeech very kindly provides a smooth system for swapping out the version of FreeBSD you’re running. It’s quick and easy!

I upgraded twice from green (Stable/Default) to blue (Stable/Upcoming), and then to white (Beta/Current) in which jekyll ran by default without any of my messing tampering and it was great!

Conclusion

I am deploying this with git on NearlyFreeSpeech.net. All my files are available on github https://github.com/devm33/devm33 including the git hooks I use in a bare repo on the server (in the util folder). You can find a good post on setting that up here: http://majorursa.net/content/using-jekyll-nearlyfreespeechnet

Cheers!

Welcome to Jekyll!

Sun, 21 Sep 2014 03:11:32 +0000

Hello,

I know this looks like the default jekyll generated post and it might seem a bit unkempt to leave the title unchanged, but it was a very warm and welcoming starter post so I’m sticking with it. Overall setting up jekyll was pretty warm and welcoming. So far at least… the next post planned will be about getting up on the server, so hopefully that one will be short and sweet as well. I’m excited to have finally convinced myself to start putting some content on this site. I look forward to making more internet.

Setup

This wasn’t bad at all. So far I have stayed very vanilla. No plugins and I intend to keep it that way in case I decide to switch hosting over to github pages at some point. I had relatively little content to migrate:

A couple static pages which were quick to convert to liquid templates and partials. In fact they refactored quite positively, dropping a lot of boilerplate.
And some custom styling that plopped right into the starter sass project. There’s some work left to do in integrating that and customizing the default rules, but with perhaps a little extra a bloat it all works quite nicely as is.
I did end up moving the rest of my asset files over to AWS s3 without fallbacks, just because I mostly done it already out of concern for latency and because it seemed like a good thing to work into the templating while I was configuring things.

Note on the configuring: I chose to place the s3 url as a site-wide variable, by placing it in the _config.yml file. But I have noticed already that this file seems like it may be prone to bloat. I’ll be looking out for mitigation strategies around that.

Next Steps

Release the git hooks and ship it!