Another Blog

Mostly about computers, generally Linux-related

Wow… xmonad does it again!

I’ve been happily using xmonad for a while now. It’s a tiling window manager written in Haskell. To me it’s a huge boost in productivity and it has helped me rediscover the fun of using a computer. Although I’ve initially tried it simply because it was written in Haskell (I was a happy wmii user then) , I now dread every single moment of using a different window manager.

Above all, xmonad is incredibly flexible. This comes from the huge extension library it has. It can tile windows in a myriad of ways, and even float them in unexpected manners. It has per-workspace configuration, so I can have 9 or more workspaces, each with different layout algorithms. I greatly appreciate a program which has allowed me thus far to go through 4 “patterns of usage”. To be more specific, I’ve gone through:

  • The “tall” default configuration. This keeps my “main” (master) window occupying 70% of the screen, and the other windows stacked to the right of the screen. The proportion occupied by the master is adjustable (see screenshot) and so is the number of masters. This is a lot more flexible than it sounds — I can have 4 equal xterms in a few keystrokes, by setting the number of masters to two and the split point at the half of the screen.
  • Three columns. I have tried this briefly for my widescreen laptop, before realising I rarely need to view 3 different source files at once. I’ve also realised I’m greedy with my non-xterm windows, so I prefer Firefox or Evolution to grab the entire width of my screen, which is what brought me to the next iteration.
  • Tabbed windows. I’ve whole-heartedly returned to my first tiling experience (with Ion3) and used Tall and Tabbed exclusively up till, well, today. The general pattern was to stuff a lot of related windows into a single tabbed workspace if I only needed to see one of them at a time. This worked wonders, but I’ve long wanted an extension to it, cue a few hours spent reading and tweaking today. I’m not delusional — I don’t consider my work so important and difficult that I needed to change the perfectly fine configuration I had; changing it was just a lot of fun. If I realise I’ve made a mistake, I’ll just use darcs to change back to my old config.
  • Tall-Tabbed Combo. Today I’ve added a new layout mode to my configuration, partly inspired by David Roundy’s sample. It splits the screen in two, similarly to Tall, and each half of the screen contains tabbed windows. This enables me, for example, to keep half a screen containing a few documents which I can cycle through, and the other half containing code which I clumsily write. I can easily move windows from one half to the other, bar a few hours of getting use to the commands. Of course, “half” is a generic term, since I can resize the two chunks to any proportion. This uses the excellent Layout.Combo and Layout.WindowNavigation extensions, in addition to Layout.Tabbed, Layout.NoBorders, and Layout.PerWorkspace, which I had previously been using.

So, to sum up another probably tl;dr post, xmonad rocks because:

  • I’m immensely productive with it.
  • It’s fun to both configure an use.
  • It’s alive. When I first started using xmonad (which was, mind you, not at its very beginning), many of the extensions I use or have used in the past didn’t even exist.

If you feel like giving it a try, be aware that you need some knowledge of Haskell if you want a custom configuration, but I’m more than happy to help with what limited knowledge I have. A much better place to go if you have a little background is #xmonad on FreeNode.


December 22, 2008 Posted by | functional programming, haskell, linux, school | 2 Comments

A coward, that’s what I am!

Yes, it’s true… and here’s why. A while ago I saw NixOS on Reddit and I’ve been eager to try it ever since. Various things got in the way and I’ve just discovered that I’m a goddamn coward.

But first: a little about NixOS, from someone who hasn’t used it much, only read a little about it: NixOS is a Linux distribution centered on the Nix package manager. It’s closer to functional programming in a way which I (hope I) largely understand, but with which I will not bore you. The novelty is that packages are specified in a complete and unique manner (Firefox with FTP support is different from Firefox without FTP support), so that you’ll never run into a problem such as emerge failing because, even though you have program X, it’s not compiled with feature Y.

Furthermore, if you screw up your configuration (and who doesn’t), NixOS “remembers” your previous configs and shows them in Grub. You can boot into a previous kernel or a previous configuration alltogether. And a nice thing (which I am completely new to, hence I will just mention it) is that Nix (the package manager) can handle both source and binaries transparently. If it’s the way I understand it, the difference between mozilla-firefox and mozilla-firefox-bin won’t be the name, but whether you use a binary “channel” or not.

Finally, along with trying NixOS (which, by God, I will. I will get myself out of this numbness), I want to go x64. Numerous people (OK, two, but two I trust, not just strangers :) ) have suggested that there is a visible speed difference. I have not tried this before for fear of incompatible software.

Previously I was never afraid to potentially trash my whole computer and try a new distro, or even a new OS. Now I’ve been finding excuses for months. Among the most popular ones, which I invoke to myself daily:

  • I don’t have the time. Well, right now I’m not going to school, only taking the occasional exam. Even though exams have been far from simple (darn electronics), I should have made time to install NixOS.
  • I’ve installed it in VMWare, so I can play with it whenever I want. That is so damn far from the truth. The VM is just rotting away somewhere and the whole fun of being stranded without X or network access has been taken away from me.
  • I’m lurking their list and everything there is way beyond me. That may be true, but how the hell else would I find out more if I don’t use it?
  • They don’t have an out-of-the-box solution for PPPoE. I can help them test one, but no, I’m too much of a coward.
  • NixOS uses a very non-standard way to configure (basically, there’s a single configuration file, all the /etc/* things are built from it) and I’m afraid I’ll lose the little skill I have. But on the other hand, being able to handle myself in Linux isn’t about knowing where various config files are, it’s about being able to find information (usually on the Internet).
  • NixOS doesn’t have a lot of packages. Between compiling manually and (eventually) writing my own Nix expressions, this is a very stupid excuse.
  • I’ll ruin my homework-writing environment. This is no longer true, since I won’t have any more homework until October (OK, so I’ll be doing an internship with Freescale in the summer [very, very excited about that], but hopefully I won’t “bring my work home with me”).
  • I’ll miss Gentoo. This is also marginally true, but there’s nothing stopping me from contributing code to make NixOS tools better (I’m not saying they’re bad, I’ve only used them a few times).
  • I want to read the papers on the site first. This one is actually valid, because there are many things I still don’t get about the distro. But, again, reading a PDF can also be done in NixOS.

Now, NixOS has XMonad and other tools I use daily (I haven’t checked MPD, but that’s not really a life-or-death issue), so moving will be smooth — if only I can give myself the initial kick in the nuts.

I was going to rant about school, but I’ll probably do this in a different post — one post, one topic.

June 26, 2008 Posted by | linux, personal | , | 1 Comment

Wow. I Made a Difference

I haven’t posted much of anything lately — I meant to log some of my homework efforts, but I’m not much of a writer. However, there is something that impressed me very much last week. Instead of trying to disguise the whole matter so as not to give away true identities, I’ll just spit everything as it is. Note that it is not a means to apologize for my previous words and both viewpoints are entirely true, though at a different moment in time.

The semester is about to end, and Algorithm Design had been on an ascending slope. The lecturer (I hope I’m right in the translation) had asked for feedback three times and had actually read it. Of course, there hadn’t been earth-shattering changes, but what he could change from one week to another, he did when someone suggested. After the final lecture, he called me by name and asked me to stay a moment; the whole name thing was surprising, but what happened afterwards was even more amazing. It appears he had read my blog and the (short, but far from positive) review I’d given his class and thanked me for the impulse he found in it.

I was speechless. Not because of fear, as one would easily have implied from my constipated face, but because I actually made a difference. Someone had actually changed something in that school and I had the small merit of having said things out in the open (although I quite frankly never expected any of my professors to read my random ramblings). It is an awesome encouragment, and it came at the right time — I was beginning to think that students couldn’t change anything, at least not without resolving to extreme solutions (strike or whatever). This proves that change can happen in an amiable manner, from the inside, without any sort or rupture between the groups or individuals involved.

I’m still chewing on what happened, and I will study hard for the Algorithm Design exam. I shouldn’t expect someone else to take their job (i.e. teaching) seriously, if I don’t take mine (i.e. studying).

June 2, 2008 Posted by | school | 1 Comment

Fourth Semester

And so we reach the end of this three-post sequence, the real reason that kept me away from this blog. Don’t get me wrong, I’m not complaining; I don’t really like to keep a log of my life and I really love what we’re doing in school so far. Without further ado, I’ll list my thoughts on every subject I have, with the warning that my translation of names will probably not be accurate and that the list is in (almost) random order.

Communication Protocols

An introduction to network models and protocols, without going too deep into the field of networks (which I will study next semester). A young team, slides prepared beforehand, but a slight lack of skill from the teacher (Florin Pop). Thumbs up for trying, though, and also for this: he finished his lecture 15 minutes earlier and asked us to stay that 15 minutes and have a chat. This didn’t happen to the entire year — a group will stay longer each week (note: this might be hard to understand if you’re not familiar with Romanian superior education organization).

At the lab we were introduced to Jasper, a protocol simulator written in Java. The idea is wonderful and the result is great, but it’s horribly written, especially because it’s Java. I realise OOP was well chosen for the task, but I have a personal spike against Java.

We have a homework, spanning two weeks, where we must implement RUPD (Reliable UDP) in Jasper. Myself and another classmate have already expressed concerns about putting the packet header (which we must implement) in a String (hence Unicode). What’s more, last time checked, the course portal did not have a forum associated with this homework, so we’re pretty stuck. The homework was almost 48 hours late to appear, which is disturbing, even though the deadline was extended.

Virtual Intruments

I honestly hope I translated this right. It’s a “filler” course, not specifically linked to Computer Science, but still better than History of Philosophy (yes, I studied that). It has so far dealt with standard setups for extracting information from a physical process, but will hopefully come to actually using virtual instruments.

The course is pretty boring, but has the merit that it fills certain holes in the Systems Theory course. The lab looks exciting; although “hard” by our standards (i.e. not programming per se), it introduces us to actually working with an outside device that is not another computer.

Digital Electronics

A continuation of the “Analogic Electronics Elements” from previous semester, with the same two gentlemen for the lecture and seminar, and a different lab assistant (the same one as in Virtual Intruments). I honestly hoped this would be more interesting than the past semester, it started off amazingly interesting, but died out after the first two hours. Still clinging to things which should primarily concern electronics engineers IMO, still a shitload of theoretical nonsense shoved down our throats, still making fun of us with every opportunity. Hopefully it will all be worth it and in the end we’ll actually have a mental image when we say CMOS or TTL.

The lab, however, is particularly new, in that we are actually doing something. We learnt what the four boxes on every desk do, how to operate them, and this week we even got to work them. Of course, Lucian actually got all the work done, while me and Roxi were in utter amazement at how fast and accurate he was. We did make a few funny mistakes, but nothing really crucial.

To top things off, we got a homework for this class. I frankly don’t understand why they did that, because we will ultimately copy them from each other, even though we have separate numerical values for each student.

Numerical Computers

An amazingly interesting course at first sight, going closer to the hardware, yet keeping a computer engineer’s view to it. We’re learning Verilog HDL, but everything is a bit to high level for me: using a huge IDE (Xilinx ISE) and learning how to click through it thus far. I got a simple homework, building a simple FSM that has to work on the FPGAs in the lab.

For testing purposes, we’ve been introduced to a virtual interface to the FPGAs built by older students. Myself and a few classmates agreed that it could have been much more impressive, but it’s still a wonderful effort. Too bad they’re not giving us accounts to the damn thing yet, although they promised to almost a week ago.

Algorithm Design

A continuation of previous semester Algorithm Analysis, for which I will be a lab assistant, Algorithm Design is a very badly held class. The lecturer just brings papers which he reads, occasionally writing silly and inexpressive drawings on the blackboard. He doesn’t even write the lecture notes himself. Moreover, we have the option of just listening to him, because he gives us the photocopied notes in advance.

We have a young (read: a year older than us) lab assistant. Not very sure of herself, but she’s definitely trying. Too bad the problems we’ve had to solve the past 2 labs have been insanely difficult (highschool algorithm olympics, and, hell, that’s hard). There’s also a semester-long project, a program which will play chess. They could not have picked an uglier game, or one that’s so easy to find readily-written programs for. Still, I’m happy with the group I’m in and it will probably be fun regardless of the badly chosen homework.

Programming Paradigms

I intentionately left this last. It’s about “exotic”, as our professor calls them, languages and paradigms. We will study (to some degree) Scheme, Haskell, CLIPS, and Prolog. But beyond the contents of the course, I have the utmost respect for the professor, mister Cristian Giumale. He truly has a gift for making us understand. Listening to him is sheer pleasure. As a comparison, I use some of the best professors I have met thus far; they come with slides, hold an interactive, energetic course, insist that you not take notes since slides are publicly available, and encourage you to address them by their given name; a true hope for higher education in these times. Then, there is mister Giumale. He comes with nothing but a set of keys (God knows why), speaks at a slow pace, and gives the impression of a shy person. But then he catches your attention and soon you’re all ears to what he says. Not using any sort of helping material for apparently hard constructions in lambda calculus is truly amazing, although I realise that to him things appear mundane. The two types of professors are definitely not in competition, but shold both be equally appreciated; they belong to different eras, equal in talent and potential, with the sole difference that one has already proven itself.

The lab is held by someone whose name has a keen resonance to me, Mugurel, whom I know by name from algorithmics highschool olympics. He’s apparently quite bored and uninterested in what he is doing, but will engage conversations on the subject and prove he’s just a bit chronically tired. We’ve been promised a project, preferably in Scheme, but I’ve been (informally) given the permission to write it in Haskell, as long as it has a graphic interface (for which I can use GTK2Hs or wxHaskell). It is my new great ambition to become a lab asistant for Programming Paradigms next year, and hearing that there is a desperate shortage of personnel in the faculty brings a new hope to me.

March 15, 2008 Posted by | school | 1 Comment

PPPoE, the Router, Wireless Internet, and TTL

Most dorms from the complex I live in have switched to PPPoE; better means of monitoring us I heard, but I won’t bring it up seriously. Of course, the network administrator in my dorm refused to switch, for fear he’d lose (perceived?) control. Quality started to drop, culminating with up to a second ping reply and a quarter lost packets. People screamed everywhere, and I myself was not happy — cormyr had just arrived and there I was without a source of up-to-date packages. Just so you can picture it, the Gentoo mirror I am using is (to my knowledge) literally less than a kilometer away, in the Rectorat building of University ‘Politehnica’ of Bucharest, a place I can see from my window. From there, I downloaded with less than 30 kilobytes per second.

Away from this near uprise, a few dorms distance, I was helping Roxi install Gentoo. She had switched to PPPoE, which caused a total of nearly 4 hours of tinkering with the connection. The live CD contained a script whch helped, but when the install was complete, we were stranded; luckily, she dual booted to XP, so we could search for solutions, download packages, and use a memory stick to transfer to Gentoo. Finally having got things working, I admit I never would have thought of the remedy by myself: the PPPoE interface had to manually be set to MTU 1492. We also had great trouble setting the routes, but that was really something we could handle.

Meanwhile, finally giving in to the increasingly furious dorm-mates, our admin finally made the switch to PPPoE. “Hah, I’ve been through this already”, I thought, but boy, was I wrong. To top things off, that exact same day I got a wireless router, so me and my roommates can use our laptops around our room. Two problems, one of which was completely new, the other only mildly and largely unsuccessfully previously tackled.

First, I sloppily got my connection working. Sloppily, because for the next few days I constantly forgot to set my routes right, which always caused great confusion. After that, I realsied I probably didn’t need that, because I wanted to connect tot the Internet through my new router. Which thankfully knew PPPoE. But again, things were far from over.

Packets get to us with TTL=1; it’s a pointless measure in my view, but it seems to be common practice in the complex where I live. The D-Link DI-524 (with which I am utterly dissatisfied) has an option called “Do not change TTL value”, but it apparently doesn’t work. It connected fine via PPPoE, I pinged Google via its HTTP interface, but this is where things ended. The solution (a cludge, if you ask me) was to connect to router to my desktop (newguy) and use that as a router that sets TTL via iptables. So I have newguy acting as a router for a wireless router. At least I have wireless, but only while newguy is on.

Bottom line is that, between paranoid admins and cheap, non-OpenWRT-supported hardware, we have another glorious bundle of wires and newguy has another glorious bunch of scripts which I only marginally understand.

March 15, 2008 Posted by | linux | Leave a comment

Rise of Cormyr (Not Without Its Problems)

I long kept silent, but not because life has been uneventful. A few separate posts will describe the past events, because I don’t like long reads.

I bought a laptop, a Dell Inspiron 1520, whose exact specs I am too lazy to post. It’s a Core 2 Duo at 2.2 GHz, 2 GiB of RAM and 120 GB hard drive. It’s quite similar to my desktop machine in this respect. Choosing a name was a bit difficult, and I eventually came up with Cormyr, just because I like how that sounds. Explaining to people why I called it that and what it originally is has led to many weird looks, but that I expected. What I did not expect is everything else.

I installed Windows XP on cormyr, which worked wonders. Half a day of installing drivers and everything was… well… Windows. After a largely uneventful Gentoo install, I realised that Windows had pretty much locked itself out of the bootloader: it had created a very strange partitioning scheme (on a nearly pristine drive at that time, so no whining about fdisk having done it). Cue reinstall, with Gentoo being the first OS I installed, along with a hopefully sane partition scheme. It was then that I also decided to drop the Dell Media Direct partition, which wasn’t working properly.

Gentoo was again fun, with ACPI tricks from both the official website and the Gentoo Wiki, and a short Haskell program I wrote to feed sensors and battery data into dzen2, for use with xmonad. The widescreen is really a pleasure when coding, along with xmonad’s ThreeCol layout. But horrors — between my being a newbie and incomplete support for my wireless card, I couldn’t get wireless to work (more on that in the next post). I tried without any success for almost a week, then decided to install XP beside Gentoo; surprise, the machine won’t boot off the XP CD.

With great angst I reached for Vista, which not only works pretty fine for a Windows (but is completely retarded UI-wise), but also saw almost all my hardware properly. This time around, driver installation took less than an hour and I could finally have my wireless. I am typing this on Cormyr, while in bed.

Bottom line, if anyone is looking for an opinion on Dell, I say go for it! Most of the problems I had were software related. The build is strong, both on the outside and intimately. Though a bit on the heavy side, the looks are to my liking: not exotic, but finely cut. The keyboard is absolutely awesome, and I’ve even learnt how to use a touchpad; I rarely connect the mouse.

A special praise to the 9-cell battery: although I first thought the thing sticking out the back of my laptop was hideous, it’s truly a blessing. After two hours of light Java coding this morning, statistics under Gentoo (a minimal build, I admit), showed 67% of the battery. The same stats go as high as 7 hours with a full battery, and compiling TeTeX and dependencies left the battery a whopping 80% full.

Bottom line, I’m happy with cormyr, a bit frustrated with Linux for not having drivers for my wireless card, but Vista usually means wireless, which means SSH into a Linux shell if need be.

Note: I realise this is not a comprehensive review, nor is it intended to be.

March 14, 2008 Posted by | linux, personal, vista | Leave a comment

World of USO — The Chronicles. Volume 1

World of USO ended this week, and all culminated today, with a well-organised ceremony for awarding the prizes. The attendance was poor (the organisers and the contest winners), but I couldn’t have felt more at home; the geek per square meter concentration was through the roof. After a brief bit of roleplaying and short speeches from the original proponents (both currently involved in teaching USO — Usage of Operating Systems), most of the dev-team went for a drink; celebration was short but fun. Of course, those of us who felt they had nothing better to do stayed on a bit longer.

A bit of extra info on World of USO: It is the first major success of Rosedu, a browser game which involved competing with others in answering questions about the USO class. It also featured a Quest mode, which was more about ingenious solutions and googling skills. Three special quests were also launched, the last of which was quite brain-twisting — only two people solved it.

Read the gritty details (in Romanian) on the blogs of Alex and Mihai or check the pictures at the album.

January 20, 2008 Posted by | rosedu | | Leave a comment

A Different Kind of Obscurity

Learning Haskell is probably the hardest thing I’ve tried regarding computers. It requires giving up all previous conceptions about programming and adopting a different, more pragmatic and heavily mathematical approach. I’m currently struggling with basic monads and haven’t even touched on monad transformers, arrows, and who knows what more Haskell has in store for me.

You may be wondering why I find Haskell interesting, despite its initial difficulty to understand (and despite a serious lack of time on my part). The main reason is that, after I have written or otherwise fully understood a code snippet, I frequently find myself seemlessly pausing to admire its elegance and simplicity. I value simplicity above all, and clearly distinguish it from easiness. Haskell is simple in that it is governed by simple and few rules, but it is by no means easy to learn or master. I often find myself asking silly, if not outright stupid, questions on #haskell or #xmonad (both are hosted on the Freenode network). The people there are, however, kind enough not to complain about it.

The `obscurity’ in the tile comes from the difference in Haskell’s syntax, compared to what I have used so far (and continue to use and study). C, C#, Java, Python. I’ve been hyped up about all of these at one time so far, and I still consider C and Python to be useful and not broken. Haskell, however, is different in both philosophy and, inherently, syntax. Programs end up being unusually terse, but pack a lot of meaning in every line of code. I estimate that I can understand about 10% of all the Haskell code, based on what I have seen, but that 10% (maybe even less) I understand into such depths that I can easily explain them to another person, if they have the appropriate prior knowledge. Or at least so I hope.

As to writing programs myself, I’ve stuck to simple ones, emphasizing on understanding the various language features. It’s quite common that a program that I would normally write in an hour in C takes up to one or two days in Haskell (allowing time for daily routine and documentation), but ends up being a lot shorter, clearer and more meaningful than the C version. As such, the obscurity I have mentioned is beneficial — people communicate more efficiently when their language is more precisely defined and they think more efficiently when they needn’t consider underlying details (the last part is valid for all high-level programming languages). Which is not to say Haskell won’t let you touch those details, though.

I also have a code snippet to show off; it is probably inefficient and could easily have been written more elegantly by one with more experience, but I am happy that I made it work. Any suggestions or commentary will be very appreciated. But before the code, the problem (it is taken from my Algorithm Analysis course):

Given an undirected graph G = (V, E) and an integer k \le card(V), find all the complete subgraphs of G that have exactly k elements.

The problem was proved to be NP-Complete, and we solved it using C during a class. Now, the interesting part in implementing it in Haskell was using the Writer monad, something I had never done before. The representation of the graph is by all means faulty (vertices are numbered 1 through nrNodes, there may be pairs containing numbers outside that range, etc.), but the algorithm works for correct input, which is clearly the key element. The terseness and expressiveness of the code still amaze me, although I must reiterate: it’s probably faulty and ugly in the eyes of an expert. The lack of I/O is compensated by excellent interactive support (I use ghci). So, without further ado, the code, in all its (perceived) glory:

import Control.Monad.Writer

data Graph = Graph { nrNodes :: Int, edges :: [(Int, Int)] } deriving Show

isConnected :: Graph -> Int -> Int -> Bool
isConnected g a b = or [(a,b) `elem` (edges g), (b,a) `elem` (edges g), a == b]

isComplete :: Graph -> [Int] -> Bool
isComplete g vs = let
    isConnectedToAll x = all (isConnected g x) vs
  in and (map isConnectedToAll vs)

generateCompleteSubgraphs :: Graph -> Int -> [[Int]]
generateCompleteSubgraphs g k = map reverse $ execWriter $ f 1 []
    f n set
      | n == k+1  = if isComplete g set then tell [set] else return ()
      | otherwise = mapM_ (\x -> f (n+1) (x:set)) (filter (not . (`elem` set)) validChoices)
        where validChoices = if n == 1 then [1..(nrNodes g)] else
                if head set == nrNodes g then [] else [1 + (head set) .. (nrNodes g)]

PS: If anyone knows of a better way to include Haskell source code in WordPress, please let me know.

December 14, 2007 Posted by | functional programming, haskell, programming | , | 3 Comments

Up to Speed

Things have been busy lately and I haven’t really been in the mood to blog. A quick recap of what I can remember:

  • wrote a small part of World of USO (in Romanian, not open to the public). This was awesome — using C and flex to parse some data and then update a MySQL table. World of USO is educational software integrated with Moodle, but it’s really very closely linked to the “Usage of Operating Systems” course I had last year (approximate translation).
  • got my driver’s license. Hate every single moment while driving. Luckily I don’t own or need a car.
  • school started. Electronics is a pain, but otherwise things are all interesting. Assembly, Java, algorithm analysis, systems theory and electronics pretty much sums it up. Philosophy is the odd one and it’s nothing like it should be.
  • helped Răzvan with organising ACM 2007 Easter Europe contest. Things were insane — interesting people and new challenges.
  • trying to learn Haskell. It’s above all other programming languages I’ve seen. Simple, but far from easy.
  • starting Hammerfall (working title, partly Romanian, might not be online at the time of this writing). It’s an attempt for a graphic engine based on OpenGL; after finishing it, we pan a game. Things are now very uncertain — we don’t even know what language we will use.
  • almost forgot: cspay is fully working; a lot of work from Lucian got us spitting out xls files. Sure, it probably still has bugs, but things are pretty much on track with cspay.
  • Rosedu is getting things moving — freshmen joining, new project ideas, a facelift for the website, new forums, Planet Rosedu. The latter is an awesome idea. Be warned that most of the content on Rosedu is in Romanian and we intend to keep it that — only the software will (hopefully) be in English. Rosedu is education-, FLOSS-, and Romania-oriented. The latter speaks for itself.

November 10, 2007 Posted by | rosedu | | Leave a comment

Silly Blog Thingy

So I got tagged by Andu. I’m supposed to write 5 songs which will never leave my playlist. Quite hard, but here gues (I’m not going to link YouTube videos — got better things to do):

  • Judas Priest — Lochness
  • Judas Priest — Painkiller
  • Black Sabbath — Fairies Wear Boots
  • Black Sabbath — Iron Man
  • Ozzy Osbourne — Crazy Train

I’m supposed to spread the disease, so here it goes: Roxi, AleCS, and Mihai.

November 10, 2007 Posted by | music, silly | Leave a comment