All that buzz about RT is going nowhere.

Maybe, I’ve learned it wrong. But I’ve never heard of RT when I was absorbed in an imperative world. RT is a common term in functional programming. I’ve read the term and it’s “definition” just after a couple of Haskell’s tutorials.

To me, it’s simple as that: RT is the ability to switch sentences that refer to the same thing without changing the result.

In Haskell, you can do that freely. Even inside IO monad! If you do anything wrong, the compiler won’t let you continue. In Java, you can do that too, but you need to be aware of all the environment and sequencing in order to preserve the result.

Sequencing in the IO monad is enforced by the types, an IO String will not fit as a valid argument for a function that needs a String, so you will not be able to inline an IO String value, you are enforced to use the bind operator.

At the time of his writing, Strachey was heavily involved with the team developing the language CPL.

The most rigorous use of L-values and R-values was (is) BCPL (Martin Richards) — which some claims stands for “Basically Christopher’s Programming Language”. BCPL inspired C, and the rest is history.

Regarding IO and side effects, CPL, and BCPL were conventional for their day (and followed ALGOL 60) in leaving IO as being ‘implementation dependent’. These were all in the von Neumann/Turing/procedural model of computing. They all used destructive assignment.

BCPL supports assignment to L-values. In particular, the R-values of functions/procedures are just static cells holding pointers to the code body. Function application is just entering that code point using the current stack frame. So you can put an arbitrary expression to yield the code point:

(x > y -> SIN, COS) (z)                        // ... -> ... , ... is conditional expression, apply to z

Or put function calls on the LHS of assignments:

Array (x, y) := z                              // array update (note that arrays are not native)

Or change a function to point to a different code point:

TRIG := (x > y -> SIN, COS)                    // excellent way to perplex any reader
                                               // but can achieve something like anonymous funs

Strachey died tragically young. Oh, that he could have continued, and collaborated with the wealth of PL research going on at the time.

AntC

Monadic expressions (of Haskell) are a RT way of encoding an imperative language that isn’t necessarily RT. The potential side effects lie in the semantics of the encoded language (which isn’t Haskell, although you could consider it a part of Haskell). Similarily, the underlying implementation of a monad might or might not rely on unsafe/non-RT constructions.

From that point of view, Haskell with the IO monad is RT, but the execution of Haskell with IO is not RT.

In a similar manner, you might claim that C is RT and the side effects lie on a different level. But as a programmer, you don’t have separate access to the RT level so its existence is theoretical. In C, you just can’t replace the expression random() + random() with 2 * random() but in (non-unsafe) Haskell you can. In the end, you can twist the terms in various ways but you shouldn’t hide the clear differences between C and Haskell.

Interestingly, I’ve found it changes the way I write C much more than the way I write Haskell. The appeal for Haskell is in being able to interoperate with other runtimes, i think: if you just wanted intra-process coordination, you already have cheap threads and MVar/TVar/STM etc.

http://github.com/ninjablocks/zmqhs (at least until Xavier pulls my changes in)

I’m not sure why, but the Haskell client dies after receiving just a few messages (they are properly filtered though).

Someone should write a blog post where they successfully debug a problem like this. That would be a pretty interesting display of real world Haskell and its development tools.

Dear Mr Kranz,

Thank you so much for your valuable feedback on my most recent blog entry. I do understand why you use a spam protection service such as mailmetrash.com, since you must receive an absolute deluge of thank-you emails for your tireless effort in improving the writing on the internet.

I do hope you are considering joining the grammar police. If you are in need of a reference for your application then I’ll be happy to help out in any way I can.

Yours sincerely, /M

import XMonad
import XMonad.Config.Gnome

main = xmonad gnomeConfig

(this requires the xmonad-contrib package on Arch Linux). Now GNOME panel shows up just fine, along with a list of workspaces. I guess it shouldn’t be too hard from here.

$ cat /usr/share/applications/xmonad.desktop
[Desktop Entry]
Type=Application
Encoding=UTF-8
Name=Xmonad
Exec=xmonad
NoDisplay=true
X-GNOME-WMName=Xmonad
X-GNOME-Autostart-Phase=WindowManager
X-GNOME-Provides=windowmanager
X-GNOME-Autostart-Notify=false

sudo apt-get install notification-daemon

/usr/share/gnome-session/sessions/xmonad.session [GNOME Session] Name=Xmonad session RequiredComponents=gnome-panel;gnome-settings-daemon; RequiredProviders=windowmanager DefaultProvider-windowmanager=xmonad

I tried using Gnome 3, but it’s a little clunky for my computer and xmonad makes using workspaces a zillion times more efficient.

failed to load session "xmonad"

“failed to load xmonad session”

same problem.

Thank you.

“failed to load xmonad session”

How to solve this problem?

Best Regars

Solution: gio.

>>> import gio
>>> gfile = gio.File(filename)
>>> gapp = gfile.query_default_handler()

That gives you the default app. The correct way to use it afterwards may be to use

>>> gapp.launch_uris([gfile.get_uri()])

but I’m not sure if you can make that blocking or not.

I have, however incorporated it into an old python script that has run-mailcap and then xdg-open as fallbacks. It’s a bit ugly, but solid: https://gist.github.com/979990

Had the same problem. Thanks for sharing the fix!

Is the add dir method what one should normally use to initialize a key on a system? i.e. If your application is being used for the first time, is this the method that should create the gconf key?

Also, the notify add method didn’t work for me. Isn’t it supposed to call the callback whenever the key is changed?

I would like my Haskell program to exitFailure when the program is interrupted, so I changed the handler function to this:

import System.Exit (exitFailure)

…

handler :: MVar Int -> IO () handler mi = do i <- takeMVar mi putStrLn “In handler” exitFailure

But when I run this code, the program doesn’t actually exit. It just prints out a notice that main.hs raised exitWith (Failure 1).

If you can figure it out, there would be much rejoicing!

xmlCharDeref :: XMLString -> String

In any case it’s hardly worth doing for the particular case where I had use for this function.

newtype XMLString = XMLString String

xmlCharDeref :: String -> XMLString

Now there’s no way you can accidentally encode twice.