Briefing

First let’s figure out how our tetris game model will be represented. The first idea that comes to mind is to represent the glass (and the blocks) as a two-dimensional array (array of rows to be more precise). The glass and the falling figure in our game will be stored in two different atoms, so we will also need an atom to store figure’s current coordinates. The glass will contain numbers that will mean a state of the cell – empty (0) or stationary filled (2). The filled cells in the moving figure will be represented by ones (1). Why this distinction is crucial we will see a bit later.

Preparation

We will use leiningen, so open the project.clj of the newly created project and put these lines there:

(defproject tetris "1.0.0-SNAPSHOT"
  :description "Simple tetris written in Clojure"
  :dependencies [[org.clojure/clojure "1.2.0"]
                 [org.clojure/clojure-contrib "1.2.0"]
                 [deflayout "0.9.0-SNAPSHOT"]]
  :dev-dependencies [[swank-clojure "1.2.1"]]
  :main tetris.core)

Note: deflayout is a small library (actually, a couple of macros) I once wrote to define Swing GUI more easily. I don’t maintain it anymore, so please consider using mature Clojure GUI frameworks like Seesaw or GUIFTW for larger projects.

Now open the src/tetris/core.clj file and start with this snippet:

(ns tetris.core
  (:import (java.awt Color Dimension BorderLayout)
    (javax.swing JPanel JFrame JOptionPane JButton JLabel)
    (java.awt.event KeyListener))
  (:use clojure.contrib.import-static deflayout.core
        clojure.contrib.swing-utils)
  (:gen-class))

(import-static java.awt.event.KeyEvent VK_LEFT VK_RIGHT VK_DOWN VK_UP VK_SPACE)

We have just declared what we are going to use in our Tetris implementation.

(def empty-cell 0)
(def moving-cell 1)
(def filled-cell 2)
(def glass-width 10)
(def glass-height 20)
(def zero-coords [3 0])

(def stick [[0 0 0 0] 
            [1 1 1 1] 
            [0 0 0 0] 
            [0 0 0 0]])

(def square [[1 1]
             [1 1]])

(def tblock [[0 0 0]
             [1 1 1] 
             [0 1 0]])

(def sblock [[0 1 0] 
             [0 1 1] 
             [0 0 1]])

(def zblock [[0 0 1] 
             [0 1 1] 
             [0 1 0]])

(def lblock [[1 1 0] 
             [0 1 0] 
             [0 1 0]])

(def jblock [[0 1 1] 
             [0 1 0] 
             [0 1 0]])

(def figures [stick square tblock sblock zblock lblock jblock])

Everything was very simple so far. We have defined some constants and the main characters of our game.

Functional code

First we need to write a few helper functions to work with our data structures more in terms of the problem domain.

(def create-vector (comp vec repeat))
  
(defn create-glass[]
  (create-vector glass-height
                 (create-vector glass-width empty-cell)))

As we have stated earlier our glass would be an array of rows. In order to avoid the confusion of what coordinate to put first let’s write the following function:

(defn pick-cell [figure x y]
  (get-in figure [y x]))

Next we need a function that will work like map but for matrices. Here is its implementation:

(defn mapmatrix [func matrix]
  (into [] (map-indexed (fn[y vect]
                          (into [] (map-indexed (fn[x el]
                                                  (func el x y))
                                                vect)))
                        matrix)))

This code is fairly simple. We map through the list of rows using map-indexed (which consequently applies to a given function each element of the collection alongside with element’s number), and for each row we map through it replacing each cell value with the result of applying the function func to the current cell state and its coordinates.

(defn rotate-figure [fig]
  (let [fsize (count fig)]
    (mapmatrix #(pick-cell fig (- fsize %3 1) %2) fig)))

Note how we have defined the rotate function in the language of the problem domain. To rotate a figure of the size S we need to replace each cell with the coordinates (X,Y) by a cell with the coordinates (S-Y,X). This is exactly how the function is defined.

(defn apply-fig [glass fig [figx figy]]
  (let [fsize (count fig)]
    (mapmatrix (fn[el gx gy]
                 (if (and
                       (<= figx gx (+ figx fsize -1))
                       (<= figy gy (+ figy fsize -1)))
                   (+ el (pick-cell fig (- gx figx) (- gy figy)))
                   el))
      glass)))

This is the most important function in the whole program. It takes a glass, a figure and figure’s coordinates and puts the figure onto the glass. To do this it maps through entire glass and substitutes those cells on the glass that are covered by the figure with the sum of current glass’ cell and the respective cell from the figure. So to say it adds the figure to the glass. As a result a new glass will be returned with zeros as empty cells, ones as figure’s cells, twos as fixed cells and threes being the cells where fixed cell and figure’s cell overlapped. This fact will be used later on to determine the correctness of the current glass.

(defn destroy-filled [glass]
  (let [clear-glass
        (remove (fn[vect] 
                  (not-any? #(= % empty-cell) vect)) glass)
        destroyed (- glass-height (count clear-glass))]
    [(into (vec (repeat 
                 destroyed
                 (create-vector glass-width empty-cell)))
           (vec clear-glass)) destroyed]))

This function removes the field rows from the glass and instead adds empty rows to the top of the glass. It is implemented just as the previous sentence stated: first it removes all rows that have no empty cells. Then it counts how many rows were removed by substituting the new number of rows from the initial one. Finally it creates the necessary number of empty rows and adds them to the top of the glass. Note that this function returns a vector of two values – a new glass and the number of destroyed rows. We’ll make use of it later.

(defn fix-figure [glass-with-fig]
  (mapmatrix (fn[el & _]
               (if (= el moving-cell)
                  filled-cell
                  el))
    glass-with-fig))

This function given the glass with the figure applied to it replaces moving cells (represented by 1s) by fixed cells. We will call this function on the glass when the figure will fall to the bottom of the glass.

(defn count-cells [glass value]
  (reduce + (map (fn[vect]
                   (count (filter #(= % value) vect)))
                 glass)))

This simple function counts how many occurences of value is there in the glass.

(defn legal? [glass]
  (= (count-cells glass moving-cell) 4))

Now when we have the function count-cells we can define the function legal? very easily. The glass is legal if the number of moving cells equals four. Thus this function will instantly tell us that some part of the falling figure was lost (when rotated near the edge of the glass or near the fixed blocks or the figure was just moved out from the glass) and we won’t accept such player’s move.

(defn move 
  ([glass fig [figx figy] shiftx shifty]
    (let [newx (+ figx shiftx)
          newy (+ figy shifty)
          newglass (apply-fig glass fig [newx newy])]
      (when (legal? newglass) [newx newy])))
  ([glass fig coords direction]
    (cond
      (= direction :down) (move glass fig coords 0 1)
      (= direction :left) (move glass fig coords -1 0)
      (= direction :right) (move glass fig coords 1 0))))

This function acts the following way: given the glass, figure, figure’s coordinates and the direction of movement it tries to apply the figure to the glass with the new coordinates. If the glass stays legal after the move (the figure is not out of the glass’ bounds and is not inside the fixed cells) then these new coordinates are returned, nil otherwise.

Side-effects code

Now when all the purely functional code is written (and its size is only about 100 hundred lines) we can get to the code that will change something. But first as always we need to define some constants:

(def score-per-line 10)
 
(defmacro defatoms [& atoms]
  `(do
     ~@(map (fn[a#] `(def ~a# (atom nil))) atoms)))

(defatoms *glass* *fig-coords* *current-fig* *next-fig* *score*)

Here I used a tiny bit of metaprogramming to avoid writing (def atomname (atom nil)) for each of the atoms I want to define. Not that it would be so cumbersome to do it for five atoms but I wanted to show an example how macros do the repetitive stuff for you.
I mark all atoms with asterisks just to distinct them easier.

(defn complete-glass[]
  (apply-fig @*glass* @*current-fig* @*fig-coords*))

(defn done-callback [n]
  (swap! *score* #(+ % (* n score-per-line))))

The first function just applies our mutable figure to our mutable glass yielding a new glass. The second one is a callback function that we will call after calling destroy-filled on the glass in order to count the points scored.

(defn move-to-side [dir]
  (let [newcoords
        (move @*glass* @*current-fig* @*fig-coords* dir)]
    (if newcoords
      (reset! *fig-coords* newcoords))))

This function takes :left or :right as an argument. It tries to move the current figure to the given direction with the function move. If it returns a non-nil value (which means that the move is legal) then it sets the new coordinates for the current figure.

(defn move-down[]
  (let [newcoords
        (move @*glass* @*current-fig* @*fig-coords* :down)]
    (if newcoords
      (reset! *fig-coords* newcoords)
      (let [[newglass d-count] (-> (complete-glass) 
                                   fix-figure
                                   destroy-filled)]
        (reset! *glass* newglass)
        (reset! *fig-coords* zero-coords)
        (reset! *current-fig* @*next-fig*)
        (reset! *next-fig* (rand-nth figures))
        (done-callback d-count)
        (when-not (legal? (complete-glass)) :lose)))))

This function works a bit differently from the previous one. It also tries to move the figure down and checks if the result position is legal. If it is not then it means that the figure has fallen all the way to the bottom. So we should fix it, destroy the filled rows in the new glass (if any), swap the current figure with the next one, randomly pick new next figure and set its coordinates to initial and call the done-callback function so it can update the score. Finally we have to check if the new current figure is positioned illegally from the start (this means that the glass is completely filled) and if so return :lose.

(defn move-all-down[]
  (move-down)
  (let [newcoords
        (move @*glass* @*current-fig* @*fig-coords* :down)]
    (when newcoords (recur))))

This function moves the figure down until it hits the floor.

(defn rotate-current[]
  (let [rotated (rotate-figure @*current-fig*)]
    (if (legal? (apply-fig @*glass* rotated @*fig-coords*))
      (swap! *current-fig* rotate-figure))))

The job of this function is to try rotating the current figure, see if the outcoming position is legal and if so replace the current figure with rotated one.

(defn new-game[]
  (reset! *glass* (create-glass))
  (reset! *fig-coords* zero-coords)
  (reset! *current-fig* (rand-nth figures))
  (reset! *next-fig* (rand-nth figures))
  (reset! *score* 0))

This function just sets the atoms to the initial values.

GUI code

In the final chapter we will write the code that will display and allow us to control our Tetris game.

(def cell-size 20)
(def border-size 3)
(def timer-interval 300)
(def game-running (atom false))

Some constants defining the size of the cell in pixels, the speed of the game and the flag that will tell the main loop if the game is in progress.

(defn fill-point [g [x y] color]
  (.setColor g color)
  (.fillRect g 
    (* x cell-size) (* y cell-size)
    cell-size cell-size)
  (when-not (= color (Color/gray))
    (.setColor g (.brighter color))
    (.fillRect g
      (* x cell-size) (* y cell-size)
      border-size cell-size)
    (.fillRect g
      (* x cell-size) (* y cell-size)
      cell-size border-size)
    (.setColor g (.darker color))
    (.fillRect g
      (- (* (inc x) cell-size) border-size) (* y cell-size)
      border-size cell-size)
    (.fillRect g
      (* x cell-size) (- (* (inc y) cell-size) border-size)
      cell-size border-size)))

(defn get-color [cell]
  (cond
    (= cell empty-cell) (Color/gray)
    (= cell filled-cell) (new Color 128 0 0)
    (= cell moving-cell) (new Color 0 128 0)
    :else (new Color 0 128 0)))

This scary function actually just draws a cell with the given coordinates and a color, and if the cell is not empty draws a border for the cell to give it some kind of 3D look. The second is a helper function which returns a color for every cell type.

(defn paint-glass [g glass]
  (mapmatrix (fn[cell x y]
               (fill-point g [x y] (get-color cell)))
    glass))

The function paints the whole glass on the given Graphics object by calling the function fill-point on every cell of the glass.

(defn game-panel []
  (proxy [JPanel KeyListener] []
    (paintComponent [g]
      (proxy-super paintComponent g)
      (doall (paint-glass g (complete-glass))))
    (keyPressed [e]
      (let [keycode (.getKeyCode e)]
        (do (cond
              (= keycode VK_LEFT) (move-to-side :left)
              (= keycode VK_RIGHT) (move-to-side :right)
              (= keycode VK_DOWN) (move-down)
              (= keycode VK_UP) (rotate-current)
              (= keycode VK_SPACE) (move-all-down))
          (.repaint this))))
    (getPreferredSize []
      (Dimension. (* glass-width cell-size)
        (* glass-height cell-size)))
    (keyReleased [e])
    (keyTyped [e])))

This function returns a JPanel instance with a few overridden methods. We override paintComponent method to make this panel draw the glass on itself and keyPressed to be able to control the game from the keyboard.

(defn next-panel []
  (proxy [JPanel] []
    (paintComponent [g]
      (proxy-super paintComponent g)
      (doall (paint-glass g @*next-fig*)))
    (getPreferredSize []
      (Dimension. (* 4 cell-size)
        (* 4 cell-size)))))

This panel will draw the next figure on itself.

(defn game[]
  (new-game)
  (reset! game-running true)
  (let [gamepanel (game-panel)
        sidepanel (new JPanel)
        nextpanel (next-panel)
        scorelabel (JLabel. "Score: 0")
        exitbutton (JButton. "Exit")
        frame (JFrame. "Tetris")]
    (deflayout
      frame (:border)
      {:WEST gamepanel
       :EAST (deflayout (JPanel.) (:border)
               {:NORTH (deflayout sidepanel (:flow :TRAILING)
                         [nextpanel scorelabel])
                :SOUTH exitbutton})})
    (doto gamepanel
      (.setFocusable true)
      (.addKeyListener gamepanel)
      (.repaint))
    (doto frame
      (.pack)
      (.setVisible true))
    (doto exitbutton
      (add-action-listener (fn[_]
                             (do
                               (.setVisible frame false)
                               (reset! game-running false)))))
    (loop []
      (when @game-running
        (let [res (move-down)]    
          (if (= res :lose)
            (JOptionPane/showMessageDialog frame "You lose!" )
            (do               
              (.repaint gamepanel)
              (.repaint nextpanel)
              (.setText scorelabel (str "Score: " @*score*))
              (. Thread sleep timer-interval)
              (recur))))))))

(defn -main [& args]
  (game))

Finally we define our main function that creates a frame, puts everything on it, finishes some GUI business and starts the main loop. The main loop ticks every timer-interval milliseconds, forces the current figure to move one cell down, checks if the player haven’t lost yet and updates the information on the screen.

And that’s all! We’ve managed to write a compact and concise Tetris implementation in Clojure. It is still pretty rough around the edges, especially its visual part but the code we came up with is extendable enough to fix it and add new features (like increasing the game speed) and so on.

I sincerely hope you liked this article and learned something while reading. If you have some questions or noticed some mistakes feel free to contact me here or any way you are comfortable with.
Happy hacking!

Hope this would help somebody.

Note: most of the information here should be also relevant for VT8500 netbooks.

Links/Elinks/Lynx

The family of text browsers that can work even without X Server. elinks is available in the Debian squeeze repository (I didn’t check others). You may consider using any of these browsers to quickly find and read some plain-text information without starting Xorg.

+ the fastest browser, can run in console

- text-only, does not support CSS, Javascript, images

Website: http://elinks.or.cz/

Dillo

Unfortunatelly I didn’t manage to run Dillo on my WM8505. The reason is I couldn’t find any debian-arm ports it and failed to compile it myself. Maybe in future I would finally beat it and update this entry.

Netsurf

Fast and lightweight graphical browser standing somewhere near Dillo on our speed/functionality ladder. It is available in the repo by the name netsurf, it supports images and CSS, it has tabs. True candidate for the title of default browser for your mini netbook.

+ pretty fast, supports CSS and images

- doesn’t support JavaScript

Website: http://www.netsurf-browser.org/

Luakit

This browser is not so popular as others and that is strange. Luakit is a Webkit-based browser written in C and Lua, configurable in Lua itself (it is even referred not as browser, but as a browser-framework), uses Vim-like user interaction, supports JavaScript and at the top of that is very fast, sometimes even faster than Netsurf! If you use Awesome WM, then configuring luakit by editing rc.lua file will be very familiar to you. So far luakit is the best browser for my netbook I tried so I ended up using it as my default browser.

Like all featured browsers on this list luakit is available at the repo.

+ very fast, very functional, highly configurable

- Vim-like hotkeys could be unusual for new users, doesn’t have many features (like password storage) out of the box

Website: http://luakit.org/projects/luakit/

Arora

Arora is considered to be one of the fastest “heavyweight” browsers. It can be installed from the repository, but uses Qt and I suppose because of that it fails to run on my netbook (actually, it shows up for a minute, doesn’t respond for anything and then closes). If anyone can run it on WM8505 write me how you did it:).

Iceweasel(Firefox)/Iceape(Seamonkey)

The heaviest browsers in the review. These two differs only in that Firefox is only a browser, but Iceape is an internet suite containing browser, mail client and some other modules. Though they both use the same engine for webpage rendering.

Firefox is indeed the most functional browser here, it is plugin-extendable and supports all modern standarts. Though with capabilities comes the price – Firefox is very slow when running on WM8505. Loading it takes about a minute and the browsing itself is much slower compared to above-mentioned browsers. You can still keep it as a reserve browser to open some complex website but day-to-day usage of Firefox is uncomfortable.

+ “adult” browser, supports everything, customizable with plugins

- slow, heavy, big loading time

Conclusion

After trying all these browsers I came up with keeping three of them: elinks, luakit and firefox. Elinks is good for fast browsing, luakit is the best daily browser and firefox is always capable of displaying some tricky page that luakit failed to do.

Hope this information helps someone.

• shows on-demand calendar with marked schedules and deadlines

• shows schedules and deadlines ordered by date

• supports multiple org-files

If you are interested visit this link for further information about installation and usage.

Widget uses *.desktop files for specifying the shortcuts, so you don’t have to edit your configuration file in order to add another shortcut. Also, you can just give the widget your Desktop folder as the folder for shortcuts, and they all will appear at the taskbar without any additional efforts.

For information about widget configuration and for the widget itself visit https://awesome.naquadah.org/wiki/Quick_launch_bar_widget

(ns coffee-time.server)

(import '(java.util StringTokenizer)
        '(java.net ServerSocket Socket SocketException)
        '(java.io PrintWriter InputStreamReader BufferedReader))

Next we have to define the following global variables (presented as atoms):

(def storage (atom {}))
(def exit? (atom false))

Variable storage will be our hashmap that stores key-value pairs. Variable exit? is just a flag indicating if server should keep running.

(def parsing-re #"([A-Z]+)\s*(\S+)\s*(\S*)")

Variable parsing-re is the regular expression that will break the request to our server into separate tokens – command, key (if exists) and value (if exists).

(defn accept-connection [server-socket]
  (try (. server-socket accept)
       (catch SocketException e)))

This little function takes the ServerSocket as an argument, accepts the client connecting to it and returns the socket interacting with a client.
Note: in this entry I won’t explain the concepts of sockets and how they interact. For this information you can check the original entry.

(defmulti operate (fn[command & _]
                    (keyword command)))

Now this gets interesting. Here we define a multimethod – a method with an arbitrary dispatch function, which we define right here. The dispatch function does nothing but takes any number of arguments and returns the keyword from the first of arguments.

(defmethod operate :GET [c key & _]
           (if (contains? @storage key)
             (str key " = " (@storage key))
             "No such key found"))

(defmethod operate :PUT [c key value & _]
           (do (swap! storage assoc key value)
               (str "Value of " key " added")))

(defmethod operate :DELETE [c key & _]
           (if (contains? @storage key)
             (do (swap! storage dissoc key)
                 (str "Value of " key " deleted"))
             "No such key found"))

(defmethod operate :EXIT [& _]
           (reset! exit? true))

(defmethod operate :default [& _]
           "Wrong command")

Four functions above are the implementations for our multimethod. What you see next to the method name is a dispatch value. When we call the method operate on some arguments, Clojure applies the dispatch function
on them, which as we now know, returns the keywordized first argument. Then Clojure seeks a multimethod implementation with this value in its definition.
Multimethods are a beautiful technique for implementation decoupling. Whenever we decide to add more commands to our server we have just to add the appropriate methods. Actually the function overloading technique is just a multimethod with dispatch function that returns types of its arguments. Multimethods in general allow much more than that.
Note the last method in the previous snippet. It has the dispatch value :default. This means that when the result of the dispatch function doesn’t match any of existing methods then this default method will be invoked.

(defn parse-and-operate [s]
  (->> s
       (re-find parsing-re)
       rest
       (apply operate)))

With multimethods the original parse-and-operate function is extremely short and concise. The operator ->> is actually a macro that takes a value as an argument and then consequently applies all the forms to it, placing the value at the tail of the form. So this expression should be read as: Take the value s, then find the regular expression in it, drop the first item from the result and then apply the function operate to what has left.

(defn start-server [port]
  (with-open [s-socket (new ServerSocket port)
              c-socket (accept-connection s-socket)
              in (new BufferedReader
                      (new InputStreamReader (. c-socket getInputStream)))
              out (new PrintWriter (. c-socket getOutputStream) true)]
    (do (reset! exit? false)
        (while (not @exit?)
          (->> (. in readLine)
               parse-and-operate
               (. out println))))))

Here we introduce one more awesome macro – with-open. It takes a group of variables that are bound to some resources and at the end of the macro with-open automatically calls .close on this resources even if the exception was raised. So this macro completely replaces the try..finally block that is often used in such cases.
What about the function itself? It is pretty self-explanatory. It creates a new ServerSocket, gets the client Socket from the function accept-connection that we defined above, binds input and output streams, and then repeatedly passes the incoming message from client to the function parse-and-operate.

So, that’s the whole server! Its size is only 53 lines of pretty “vertical” and extendable code. For sure, this code is rather proof of concept than the real code you would write, but the result is still impressive.

So now to the client part. This time I won’t use System.in stream for interaction with user, I decided to use the power of REPL instead. But first come the declarations:

(ns coffee-time.client)

(import '(java.net Socket)
        '(java.io PrintWriter InputStreamReader BufferedReader))

(def socket (atom nil))
(def in (atom nil))
(def out (atom nil))

Nothing interesting here. socket is used to store Socket object, in and out speak for themselves.

(defn start-client [port]
    (do
      (reset! socket (Socket. "localhost" port))
      (reset! out (PrintWriter. (. @socket getOutputStream) true))
      (reset! in (BufferedReader. (InputStreamReader. (. @socket getInputStream))))))

This function tries to connect to server (hardcoded localhost) on the specified port and gets necessary streams.

(defn send-message [m]
  (do
    (. @out println m)
    (println (. @in readLine))))

Again pretty simple – the function gets the message as an argument, passes it to the output stream, gets response from input stream and prints it on the screen.

(defn stop-client []
  (do (. @in close)
      (. @out close)
      (. @socket close)))

We should invoke this last function to tidy everything up after we did our work.

Once again, the client lacks a lot of try/catch cases because I didn’t want to bloat the code and since this is toy problem, clarity > robustness.

Now, after both server and client are done, you can test them. First, in one repl, execute:

coffee-time.server> (start-server 1234)

In another repl, run:

coffee-time.client> (start-client 1234)

and then you can send messages to the server as following:

coffee-time.client> (send-message "PAT message Hello world!")
Wrong command
nil
coffee-time.client> (send-message "PUT message Hello world!")
Value of message added
nil
coffee-time.client> (send-message "GET message")
message = Hello world!
nil
coffee-time.client> (send-message "DELETE message")
Value of message deleted
nil
coffee-time.client> (send-message "GET message")
No such key found
nil

Thus, we ported our Java simple client-server application to Clojure. The code has less noise in it, more expressive, understandable and accurately put together. There is still much left to be done – you can introduce a few macros to eliminate code duplication, break the code into few more functions, but it is now up to you what to do.
I hope, this topic was somehow helpful to you. If you want to learn Clojure more, you can start with the book of Luke VanderHart and Stuart Sierra “Programming Clojure” or “The Pragmatic Bookshelf Programming Clojure” by Stuart Halloway. For deeper Clojure understanding I recommend reading an awesome book “The Joy of Clojure” by Michael Fogus and Chris Houser.
Thank you for your attention.

• Provides an ability to control playback, switch songs, playlists, change volume and other options.

• Displays information through a scrolling widget and naughty notifications.

• Supports multiple servers and able to switch them on the fly.

• Supports UTF encodings.

For information where to download and how to setup it see http://awesome.naquadah.org/wiki/Awesompd_widget .

Of course, you cannot so easily jump into writing DSLs and DSLs in DSLs and so on. This requires a host language capable of easy metaprogramming. Most of such languages are the Lisp derivatives that may ring you a bell. The mainstream languages come and go – ten years before the software companies were flooded with C++ coders, five years ago they all were replaced by Java/Python ones, now it seems like C# is the new cycle runner. But Lisp remains popular and useful for half a century now in any of its variations.

Code that writes code is a key. That is the natural way of development and not a rocket science as it is thought to be. Machines that build machines led to the scientific and technical revolution. Further research in the code-writing code industry can set up another one. Learn it, use it and you’ll see that programming is more magical than you ever thought.

If you want to learn more about metaprogramming and DSLs, you can start off with reading this article.

Answer to the comment about “No silver bullet”: the metaprogramming implicitly states that there is no silver bullet. It provides an ability to write the language for the problem itself, hence eliminating the “silver bullet” principle. You can create a bullet for your very task and it would be better than any existing all-purpose languages.

I tried a lot of software (offline and online) to help me with my tasks. I tried using specialized software, I tried different built-in things (like Firefox\Thunderbird plugins), I tried Rememberthemilk and similar services on the Web, but the same problem remained – the information was too far from my eyes. It was either not noticeable, or stayed on my screen for not enough time, or I had to remember myself to view my to-do list.

Then conky came into my sight. I see it everyday, it stays on my desktop all the time, and I got an idea – why not show the to-do list in it? The idea isn’t new, one can say, but there is another problem – I’m too lazy to keep updated one more file for this list. But wait, I regularly work with Freemind, and it is fairly easy to create another branch directly for to-do management. Thus, I wrote this script that eased my life and may someday ease another one’s.

Instructions

To use this script, follow the next steps:

1. Download the file conkytodo.sh from here and place it somewhere safe(e.g. into the Scripts folder).
2. Open conkytodo.sh in the text editor and change the following options:
   MINDMAP_FILE – the Freemind file where you keep your to-do list
   TODO_NODE – name of the root element of your to-do list. For example, you can create a node in Freemind called “To-Do” and provide this name to this option, and all child nodes of this branch will be shown in conky.
3. Allow the file conkytodo.sh to be executable. To do this, open the terminal window, go to the directory where the file lies and enter the following:
   

   chmod +x conkytodo.sh

4. Open your conky configuration file and append there these lines:
   

   max_user_text 16384
   ${execpi 10 ~/Scripts/conkytodo.sh}

   The first option extends the limit for a text that a command can write. The second one actually outputs the text and specifies the delay between updates (here it is 10 seconds) and the path to the script (of course, change it to where your script is).

5. That’s all, now if everything is right, your conky will print the name of nodes from the to-do branch (which name you specified in step 2).

Another option why you should like working in a console is if you use ssh a lot. Sure you can connect to a remote terminal with ssh using -X option, so it would transfer the windows directly from one X11 server to another. But this can still be a bit slow and annoying.

Though, today we’ll try to modify our working environment for active console usage and maximal convenience for that. I won’t describe you common hot-keys or basic tips and tricks because there are loads of them on the Internet. I just want to share with some software that can make your migration to a console less hard and painful. So, here we go.

1. First of all, to use console effectively you have to have a good shell. You are probably equipped with bash or dash, but my choice is zsh. Why zsh? It’s command completion feature is really nice, it can complete arguments and parameters for most popular commands, it can correct your spelling mistakes, it shares the command history across all active shells. And above all that, zsh is very customizable.

2. After that, we need a terminal multiplexer, if we don’t want to spawn dozens of terminal windows (or we just cannot, as in ssh case). GNU Screen is perfect for this. It can store multiple sessions in just one window, switch between them, operate them however you like. But the most toasty feature is sharable sessions, so that you can join remotely to a server, create a session, and then reconnect to the same session later (even from the other computer).

3. Now, file manager. For sure, you’d like to use mc. It is a huge piece of software, very extensible and constantly evolving. It somehow resembles the well-known Norton Commander, so it will be easy for former nc users to get used to mc.

4. Talking. If you use Pidgin, you’ll be glad there is finch. Finch is a console clone of pidgin, it has the same interface, it uses pidgin configuration, so you don’t have to configure it at all. Another nice program is mcabber – a lightweight console XMPP client. It is highly configurable and has many handy features like external action triggers.

5. Music. You probably already heard about mpd. Music Player Daemon is an fascinating software used all over the place where a network exists. It is a music server that can be controlled by any of the large amount of clients on the same computer or remotely. The simplest client for mpd is mpc – it has no interface at all, you just type commands to control the player. Hence, it requires no resources at all, neither does mpd – it is extremely lightweight. The list of most popular mpd clients you can find here.

6. Torrents. If you use transmission then your choice would probably be transmission-daemon with transmission-cli. Daemon should be working on the server that would download torrents, and using client you can control the process, locally or remotely. Another option is a well-known rtorrent, even more client-server oriented and very extensible. There are clients for it that allow you manage your torrents via web interface from any computer which is really convenient.

So, as you see, console is full of programs that can easily replace their GUI counterparts. And although, you cannot do everything you want from the console (for instance, browsing. Times ago, there was links – text-based console browser, but it couldn’t catch up with the speed of web development), terminal window can become your sincere and beloved friend – always accessible, always fast, always there to execute your dreams.