Thought bucket

Better window splitting in Emacs

Alan — Wed, 01 May 2013 19:27:00 +0000

Emacs’ window-splitting functionality is an ergonomic way to view multiple files at once without having to deal with shuffling around floating windows or clicking between tabs. Anyone who does much with Emacs probably knows already that they can use C-x 2 or C-x 3 to split the window vertically or horizontally.

What always bothered me about this feature was that the newly-created window defaulted to the current buffer, which in layspeak means you had the same file or content open in both your new window and the old. The was almost (but not quite) never the behavior I wanted, since usually you split the window to have multiple buffers on screen at once. Typically, I would do this right after opening a new file or buffer to compare with whatever I already had open, so that I would have the old buffer in one window and the new buffer in another.

This is where having an extensible editor rocks; because in Emacs, if you get tired enough of a behavior, you start hacking elisp and fix it…

The fix is simply a matter of writing some custom elisp functions and overriding the default keybindings with the new functions, and adding it all to your .emacs file. Here’s the code:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Custom splitting functions ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
(defun vsplit-last-buffer ()
  (interactive)
  (split-window-vertically)
  (other-window 1 nil)
  (switch-to-next-buffer)
  )
(defun hsplit-last-buffer ()
  (interactive)
  (split-window-horizontally)
  (other-window 1 nil)
  (switch-to-next-buffer)
  )
 
(global-set-key (kbd "C-x 2") 'vsplit-last-buffer)
(global-set-key (kbd "C-x 3") 'hsplit-last-buffer)

What each of these functions does is perform the regular vertical/horizontal split, then switches to the newly-created window and performs “switch-to-next-buffer”. “Next buffer” is the buffer you’d get if you did a “switch-buffer” (C-x b) and just accepted the default. Obviously, Emacs can’t (yet) read your mind and open the buffer you want every time, but “next-buffer” is most likely to be the buffer you want (at least, much more likely than the current buffer, which you already have open in another window).

Copy this code into ~/.emacs, evaluate the buffer (or just the functions), and you’re ready to roll.

I’m going to try this change for a while and see if it sticks, I’ll keep this post updated with changes.

WCGBrowser update: http_proxy and more

Alan — Wed, 17 Apr 2013 21:44:00 +0000

For users of WCGBrowser…

In the last few days I’ve added a few features:

Firstly, proxy server settings. Several people requested this, though none wanted to sponsor development (I only asked $100 US). Turns out I needed it for something I was doing myself, so happy birthday everyone, you get this for free. Proxy settings can be set from the CLI, config file, or environment variables (common on many Linuxes).
Secondly, stylesheets. Not that there’s much to style on WCGBrowser (the navigation bar, mostly), but you can now do it with QSS style sheets. A (really tasteless) example stylesheet is included.

Latest code can of course be downloaded from the wcgbrowser github page, or just do a “git pull” if you cloned it from there in the first place.

Enjoy!

Porteus

Alan — Thu, 28 Mar 2013 03:40:00 +0000

As I’ve chronicled in “Replacing Windows 98…” and previous posts, I’m always interested in new tools that promise to imbue my mountain of mouldering beige boxen with a glorious desktop experience usable by the modern user. A commenter on that post suggested trying out Porteus, so I’ve been playing with it some this evening. While I haven’t time to work up a serious review, I thought I’d share my impressions of Porteus as a distro for rescuing older computers.

The scenario

Hardware

My “beater rig” that I use for testing is an 800MHz Celeron Coppermine system with 256 MB of RAM, which a gracious coworker gave me for free several months ago. Believe it or not, this system originally shipped with Windows XP Home (RTM), and was still running it when I received it. It currently runs Vector Linux 7.0 lite with a custom 3.7 kernel and Awesome WM.

Software

I downloaded Porteus 2.0, 32bit XFCE edition. The “Standard” 32 bit edition uses Razor-qt, which seemed to me from past testing to be a bit heavier than XFCE, so I went for the safer choice.

Porteus

Brief overview

Porteus is a Slackware derivative, based on Slack version 14. It’s not merely a respin, however, as it boasts some custom configuration tools and its own package format. Porteus is also designed specifically for live media booting, with a design similar to TinyCore Linux where the core OS boots from compressed files and changes (including package installations) are stored in a separate directory or file. A boot menu option allows you to do a “fresh boot” (ignoring the recorded changes), making it always easy to keep a running system even if you muck it up completely.

Apps and desktop

The Porteus XFCE desktop is pretty conventional; it defaults to a panel-on-the-top layout but is otherwise pretty conventional. The default look is simple yet attractive with some nice touches over the conventional XFCE desktop look. XFCE is at version 4.10, which is nice considering that even now many distros ship 4.8.

The application selection is pretty typical of a lightweight Linux desktop:

Firefox (v.18) browser
Pidgin instant messenger
Abiword for documents
Gnumeric spreadsheet
Gnome Mplayer and Audacious for multimedia playback
XFCE applications (Mousepad, thunar, Orage, etc) for most of the rest

Curiously, both XFCE4-terminal and LXTerminal were installed, and LXTerminal was default. The Porteus toolset includes a settings tool, a system information tool, and the Porteus package manager.

Noteworthy features

Porteus package manager

The Porteus package manager is just doggone cool. It’s actually six package managers tied up in one click-friendly front-end, allowing you to install packages not just from the Porteus repos, but also slackware packages, slackbuilds, Salix packages, RPMs, and Debian packages. Unfortunately my Internet connection on the test machine was down (not Porteus’s fault), so I couldn’t test this feature.

PXE server boot option

There’s an option to boot Porteus as a PXE terminal server, so that other systems on the same network could use it to also boot Porteus. I can’t say that any practical application of this features comes to mind (“QUICK! We have only minutes to turn all these hard-drive-less computers into a computer lab! What will we do???”), but I love PXE booting and I just think it’s cool. I think back in the day Knoppix had this feature too.

Run from RAM

Another boot-time feature allows you to copy the Porteus core to RAM. It requires 320 Mb of RAM for the 32-bit edition, which makes it a no-go for my hardware, or probably for anyone with less than a gigabyte who expects to actually do anything after the system is booted. Still, for making a RAM-endowed system run fast, seems quite useful.

Performance on my hardware

Porteus did OK running from my hardware; I ran it as a live system, which is what it’s designed for. Compared to Vector Linux lite, it’s a bit more sluggish, but that’s probably due to XFCE more than anything else. With IceWM or Awesome installed, performance would probably be comparable to VLL. Overall I’d subjectively put it as heavier than Slitaz, Puppy, and TinyCore, but definitely lighter than any Ubuntu respin.

The only recommended/supported install method for Porteus is a “frugal install”, which effectively makes it a live session running from the hard drive – in other words, the core files remain compressed and monolithic on disk, and changes are only written to a separate location. I’m slightly curious to know how this performs over the long-haul as the system changes more and more.

Conclusions

Is Porteus the long-sought hope for Pentium II relics? No, I think we can rule that application out. For those who want to have a portable install with persistence, it seems like a heavier, yet less squalid, alternative to TinyCore or Puppy.

For those wanting to resurrect old machines, Porteus seems best suited to an 8 to 10 year old machine, maybe that Pentium IV or Athlon XP with 512 to 1024 MB of RAM. There’s a lot of competition in that space (including most mainstream distributions if you pick the right desktop environment), and it wouldn’t be my go-to distro if I had such a piece of hardware to work with.

But in either scenario, the package manager looks to be the real killer feature of this distro; I’d like to spend some time testing it out and seeing what mixing various packages does to the stability, but if it does what it claims, it may just replace Vector on my Coppermine box.

Building a Linux system for a Child, part 4: a wishlist

Alan — Mon, 18 Mar 2013 21:42:00 +0000

The previous articles in this series helped you set up a Linux-based system for a child, and explored some of the great educational and kid-friendly software available. I’ve based this on almost eight years of experience in setting up GNU/Linux on computers for my own kids, and for their friends. So, based on that experience, what things do I wish the Free software community could come up with to make Linux a better experience for kids (and their parents!)?

Better Parental Controls

I discussed this to death in previous articles; so, not to put too sharp a point on it, but we (parents) could really use some better and friendlier controls in Linux. My ideal “parental control” tool would have at least:

A front end for Dansguardian, with per-user transparent proxying.
Something like timekpr, to restrict login times and the amount of time a user can be logged on.
A way to restrict who can run which programs
A way to restrict certain programs from accessing the network
No dependencies on a specific distro or desktop

I know enough about the guts of some of these things to know that this is a tall order (if it weren’t I’d have coded it myself); but here’s hoping that some commercial Linux vendor or big community project will see a need for these tools.

Multimedia and better artwork

Anyone remember Myst? I don’t know about you, but for me playing Myst for the first time was the moment I realized computer games could be art. If games from the 90′s could have immersive artwork, music, and cutscenes, I don’t see why modern open source games can’t do these things as well. In fact, I know they can because I can think of a few that /already do/² Unfortunately none of them are educational games, or even kid-friendly. We seem to have no difficulty making multimedia-rich combat games full of carnage, so why do kids games seem to get stuck with artwork from OpenClipart.org or some ham-fisted programmer art hastily drawn in GIMP? And why do you make a game aimed at pre-literate-pre-schoolers that requires them to READ INSTRUCTIONS?

I think sometimes that part of what we should be doing as FLOSS programmers is not programming actual games, but rather frameworks to make it easy for people with skills in art, music, design, and story to create games. The programming in most commercial child-oriented & educational games is rarely ground-breaking or complex; it’s a delivery mechanism for the artwork.

More literature, history, and humanities

When it comes to children’s games on Linux, arithmetic is pretty well covered. Computer science, programming, astronomy, and logic exercises are also decently well covered. Granted, there’s always room for a novel approach to these topics, but if you want to contribute something truly new and compelling to the world of FLOSS educational software, take a look at the humanities. Can you find some creative way to teach history, literature, art, language, world cultures, and other non-STEM subjects using software³?

More special needs software

Helping kids with autism and similar disorders is near and dear to my heart since, well, I have a child with autism. There is an alarmingly huge number of children with autism and ASDs, and the number is growing. There’s a lot of expensive, proprietary software out there designed to help people with autism, as well as a lot of software on proprietary platforms like iOS. Linux and FLOSS falls short here, unfortunately.

Some ideas for applications would include:

visual scheduling tools
social interaction simulations
facial expression/body language modeling
ABA tools
Language development games
Story sequencing activities
“Life skills” development activities

Obviously this could be a whole topic unto itself, but it’s well worth investigating if you’re looking for a good idea for a coding project.

What about you?

I’d love to hear your thoughts on how Linux has done for your kids, and what you think can be improved upon. Leave a comment and let me know!

Footnotes:

¹ case in point: SupertTuxKart. Version 0.8 introduced “story mode”, which simply added a cutscene at the beginning, and changed the way feature-unlocking and track selection worked to enhance the storyline aspect of it. Actual gameplay wasn’t really changed, and most of the tracks were identical. Nevertheless, the story mode actually inspired my kids to play it all over again just to finish out the story. Now imagine this sort of thing with an educational program…

² Have you played Warzone 2100 lately??

³ Granted, doing this requires a certain amount of knowledge about these subjects, which is probably not a given among people who love programming enough to do it recreationally.

Five reasons why I choose PostgreSQL

Alan — Fri, 01 Mar 2013 05:59:00 +0000

I’ve worked with most of the major SQL databases over the last several years, including Oracle, MS SQLserver, MySQL, and PostgreSQL, both as an admin and (more often) as a developer. They’ve all got their ups and downs (some more of one than the other…), but when it comes to choosing a database for my own projects, my choice these days is nearly always PostgreSQL. This amazing, powerful server is unfortunately one of the hidden gems of the relational database world, so I thought I’d share a few reasons why it’s my personal favorite.

Elegant SQL syntax

There’s just something about SQL itself that seems very throwback; maybe it’s just the convention of typing commands in caps, its odd rules about quotes and character escaping, or just the sometimes-convoluted approaches to problem solving its declarative syntax forces you to take. Every time I start typing “SELECT …” I feel a little like I’m trying to hack the MCP or talk WOPR out of launching nukes. Especially if I’m forced to use some byzantine implementation of SQL like, say, Oracle.

So any little bit of syntactic sugar that streamlines the process and makes creating SQL queries a bit more elegant is greatly appreciated. PostgreSQL’s dialect of SQL is full of little bits of niceness here. PostgreSQL’s typecasting syntax is a great example; instead of having to type some verbose nonsense like:


SELECT CAST (mycolumn AS VARCHAR(30)), 
    CAST (myothercolumn AS DATE) FROM mytable;

…or, worse, some ridiculously specific function like “TO CHAR()”, PostgreSQL allows you to typecast like so:


SELECT mycolumn::VARCHAR(30), myothercolumn::DATE FROM mytable;

Another example of nice PostgreSQL syntax: dollar-sign quoted strings.

In most SQL databases, string literals can only be delimited with single quotes. This is a bit of an annoyance, given that the single quote also happens to be the apostrophe – a rather popular bit of punctuation in the English language. Dollar quoting lets you use double dollar signs ($$) (with an optional tag in between the dollar signs) to delimit a string. This is awesome if you need to quote a long piece of text (e.g. a crosstab query) and don’t want to worry about escaping all the single quotes; to my knowledge, PostgreSQL is one of the only databases to offer an alternate string delimiter.

Or, take the way PostgreSQL does case-insensitive string comparisons. If you want this in SQL Server, the correct way is to specify a case-insensitive collation for the query; if you want it in Oracle or MySQL, you’d do something like:


SELECT * FROM sometable WHERE UPPER(somefield) LIKE UPPER('searchterm');

In PostgreSQL, you get the “ILIKE” operator – exactly like “LIKE”, but case-insensitive, so the query becomes:


SELECT * FROM sometable WHERE somefield ILIKE 'searchterm';

Things like the “::” operator, dollar-sign quoting, or ILIKE don’t seem that big of a deal; but when you get into writing 3-page SQL queries with complex conditions, cross-tabs, and other such things, these little niceties add up to a far cleaner piece of code.

Many useful data types

Most databases give you various types of character, number, date, and binary data types. PostgreSQL gives you this, plus several interesting and cool data types that you may not have considered before:

Enumerated types (for an arbitrary list of fixed values)
Network address types (IP, CIDR, MAC)
Geometric/Spatial types (points, lines, polygons, etc.)
XML and JSON types
BOOLEAN (yes, some very expensive and over-hyped databases still don’t have these…)

Sure, some of these things can be represented with more conventional data types, but having them already built in gives you a standard representation, data type enforcement, and a battery of supporting functions and operators¹.

And unlike some other databases, these data types are well supported and sanely implemented. Take the ENUM type for example; while MySQL also has the ENUM type, it’s implementation is awkward: simply getting a list of possible ENUM values from the database (which you’d want for, say, populating a drop-down list in the application) requires querying the information_schema for a column description and using a regex on the results². PostgreSQL, on the other hand, has a built-in function to do this.

Arrays

One of the best data types that PostgreSQL adds to the mix is the array type, which lets you have arrays of any other type of data in a single field. Now, you might think having an array inside a database column is redundant, if not flat out dangerous; but I can assure you that, used sparingly, arrays in a SQL database are pretty amazingly useful.

Consider a situation where you want to flatten a couple of tables with a many-to-one relationship; for instance, you have an HR application where you want to flatten the “Departments” and “Employees” tables to a table containing the department name in one column and a list of employees in the other. In most databases, about all you can do is either (a) create a table with the department in one column and one employee per row in the next, then aggregate the employees in your application code, or (b) aggregate the employees to a string delimited by commas or somesuch. In PostgreSQL, you could aggregate the employees to a VARCHAR array; if you’re using a decent driver (like Python’s PsycoPG driver), the array will come into your application as a native array/list/vector/etc. Very convenient.

Arrays are also useful when you may need multiple values in a field, but it doesn’t quite justify yet another table join.

PostgreSQL features a pretty robust set of operators and functions for testing, comparing, manipulating, and converting arrays. It does take a bit of mental gymnastics now and then to figure out how to get an array into the format you need to accomplish various things, but used correctly and sparingly they’re an awesome tool.

Stored procedures: pick your language

All the database engines I’ve been talking about have some form of “stored procedure”, or the ability to create custom functions stored in the database itself. This is quite useful if, for example, you’ve got a complex database schema and want to abstract some common read or write operations that are otherwise a real pain to do in raw SQL, or to create custom data-manipulation functions that are specific to your data.

In MySQL, your only option for writing these is plain old SQL, which means a stored procedure is more of a “named query”. It’s useful, but not all that powerful.

Oracle gives you its own PL/SQL, an extension of SQL that adds procedural logic constructs like flow control and variables. If you can imagine the unholy union of SQL and COBOL, you’ve got a good picture of PL/SQL. Ugly and archaic though it may appear, PL/SQL does make a lot of procedures possible that mere SQL cannot accomplish. SQL Server’s TSQL dialect contains similar procedural constructs that are available when creating user functions or stored procedures³.

What PostgreSQL does here is a little unique. Instead of restricting you to a single procedural language when defining stored procedures, it offers support for a variety of popular languages; out-of-the-box it supports Python, Perl, Tcl, and PL/pgSQL⁴, but there are optional modules for Java, R, PHP, Ruby, Scheme, and Unix shell. This means that you can construct your procedural logic in a syntax that you’re comfortable with, or that best lends itself to your task.

Now, I’m not a huge fan of putting tons of application logic into the database; but there are times when it just fits, and being able to do it in the same language as the actual application is takes a bit of mental overhead out of the equation.

Excellent clients

If I had to pick a database GUI toolset that was the most powerful yet easy to use, I’d have to concede that to SQL Server Management Studio. After that, PostgreSQL’s PGAdmin tool is pretty awesome and fairly complete when it comes to configuring and interacting with your server(s). To be fair, PostgreSQL is just a simpler database system⁵, and doesn’t need a complex configuration tool a la SSMS; I can’t think of too many things PostgreSQL is capable of that you can’t do in PGAdmin⁶. As a bonus for developers like me who run a non-Windows OS on the desktop, PGAdmin is available for most major platforms.

If you prefer a web-based client, there’s also phppgadmin, which is not quite as powerful but lets you get the most common jobs done in a browser.

Of course, if you’re old-school like me and prefer to dig into the command-line now and then, PostgreSQL is a winner here. The psql command-line client has nice features like readline support, piping, and tab completion that make it very comfortable to anyone who uses modern unixy operating systems. Contrast this to Oracle’s sqlplus client, which likes to barf out weird code sequences whenever you hit the arrow or tab keys and has no facility to edit the previously typed line; or with sqlcmd, which only runs in the Windows cmd shell and thus inherits its many limitations.

The Perfect database?

Is PostgreSQL the perfect database? Probably not, and I’m not holding my breath for the .NET ISVs of the world to suddenly embrace it. But if you’re a developer whose always eyed it with uncertainty since it lacked the hype of MySQL, the marketing dollars of SQL Server, or the sheer veneration of Oracle, it’s time to get past that and check it out.

Footnotes:

¹ I just gotta say, it’s nice to be able to sort IP addresses properly, so that for example 192.168.2.0 comes before 192.168.100.0.

² http://stackoverflow.com/questions/4644220/mysql-select-enum-values

³ SQL Server distinguishes between “user functions” and “stored procedures”; the difference isn’t important here, they’re just different methods of storing custom code in the database.

⁴ this is PostgreSQL’s take on PL/SQL, which is pretty similar to Oracle’s and TSQL’s

⁵ For example, it doesn’t have its own job scheduling or email systems, probably because it’s typically run on unix-like systems that normally have a perfectly good job scheduler and MTA built into the OS.

⁶ most of what I can think of is of interest to DBAs more than devepers, and this post is speaking from a developer perspective.

Building a Linux system for a Child, part 3: Security concerns

Alan — Thu, 14 Feb 2013 04:30:00 +0000

By now you’ve got that old computer purring along like a panther with your new favorite distribution of Linux, loaded to the brim with educational software, ready to propel your child to the heights of intellectual stimulation. But before we launch this starship, let’s take a bit to make sure the safety equipment is in order and reign in some potential problems.

Parental Controls, filtering, etc

I’ve mentioned before that a lack of easy parental controls is one of the downsides of using Linux for a child. The frustrating thing here is that nearly all the basic groundwork for these things already exists in Linux, and has been there for years; but nobody has successfully pulled them together into a simple centralized interface for mainstream use. History is littered with projects that attempted to do this (gnome-nanny, timekpr, Ubuntu Christian-Edition’s parental controls), but were subsequently abandoned, obsoleted by developments in desktop environments, or never released to more than a single distro. Some of these things might still work for you depending on the distribution you use, but even if they don’t, there are some things you can do.

Web content filtering

Dansguardian, in concert with Squid, can make for a really top-notch content filtering system, and setting it up isn’t really that hard if you’re up to some reading and able to do the config-file thing. You can set this up on a separate box (this is what I do), or install it right on the child’s computer. This, plus a little iptables magic to force web traffic to the proxy, works well for keeping the web safe. A quick search for “dansguardian howto” should turn up some decent instructions for your distro of choice.
For the less intrepid, OpenDNS is a third-party DNS service that offers some filtering solutions at the DNS level¹. Check them out at http://www.opendns.com.
Some browser plugins, such as Procon Latte for Firefox, provide content filtering and whitelisting in the browser itself. The only downsides are that (a) it only works for the browser you install it on, and (b) it has to be configured per-account (for those of you with multiple kids).
The Linux Mint family of distributions features MintNanny, which is billed as a parental control, but is basically a web domain blacklisting utility. Unfortunately it can’t whitelist as of this writing, so it’s utility for sanitizing the Internet is a little limited. If you just need to block a few problematic websites, this might be adequate.

Time restrictions

The /etc/security directory on many distributions (Ubuntu, Debian, etc) allows for easy (well, compared to PAM) configuration of certain types of user-based restrictions. Probably /etc/security/time.conf is the most actually useful to parents, because it lets you limit when a given user can be logged in. The other files are probably too low-level to be of much use in restricting kids, but it’s worth a look to see what’s there.

Application restrictions

The simplest ways to restrict what applications a child can run are simply (a) don’t install them in the first place, or (b) use a desktop environment where you can explicitly configure what applications show up in the menu. Many programs intended for kiosk use, or just old-school environments that lack automated or graphical configuration features, are quite suitable in this application.
If your distribution ships AppArmor, you can use it to restrict whether or not a program can use the network or not. Writing AppArmor profiles is not the most entertaining thing in the world (though it beats working with SELinux), but well within the ken of most long-time Linux geeks. If you’re really clever, there’s probably a way to do this per-user using pam_apparmor rules; but this bit is beyond me.

Do we need Parental Controls?

Parental controls seem to be a contentious issue in some segments of the Linux community; whenever I’ve see the issue come up on community forums and the like, there is always a vocal group of people who seem to have a problem with anything that limits or restricts a user of the system, and they don’t see the need for such things to exist in Linux. Others just feel parental controls are ineffective and pointless.

As a parent, I don’t agree. “Parental Controls” are not about magically turning the computer, or the Internet, into a kid-friendly wonderland. They’re about having tools to enforce the rules, and a means of drawing some clear boundaries with the help of technology, if only to help my children from unwittingly stumbling into things they are better off avoiding, or keeping the “honest child honest”. And frankly, anyone who thinks you can effectively parent a child without limiting his freedom now and then is living in a fantasy world.

Network access outside the browser

Protecting kids from online harassment, predators, and inappropriate content is no small issue for parents in these sorry days, and simply filtering the web browser is not enough. Many games (open source or otherwise) can now be played on the Internet using public servers, and allow kids to download content and communicate with people all over the world. If you (or the parents of the child getting the computer) don’t feel the child is ready to deal with this interaction responsibly, it’s imperative to make sure that any “Net-enabled” games installed are suitably blocked or disabled from going online.

Here’s a short, and very incomplete, list of network-related problems I’ve run into or heard about:

Some games I’ve seen that let you connect to public online servers and chat with other players include minetest, netpanzer, frozen bubble, and hedgewars.
Ubuntu’s Unity desktop as of 12.10 returns search results from Amazon.com when you type into the dash search. The results are not filtered in any way, and examples have been reported of decidedly non-kid-friendly results popping up for pretty innocuous searches (or even system commands). This feature can be disabled or removed, and probably should be for a child’s computer.
KDE’s “get hot new stuff” functionality (now known as DXS, where you can get new widgets/wallpapers/themes directly inside the configuration tools) pulls content directly from freedesktop.org. Once in a rare while, someone posts something that is unfit for little eyes, and it isn’t really moderated as far as I can tell. It’s not clear to me whether this feature respects your proxy settings, or whether its content would be filtered in any case. You may have to look about for a fix, block freedesktop.org, or (tragically) just not use KDE.
Desktop Environments sometimes come with their own web browser, like Konqueror, reKonq, or Epiphany, which nobody really uses (kidding, devs!), and thus tends to get overlooked when setting up (e.g.) proxy settings. If you aren’t doing global proxy settings, enforcing proxy settings at the router, or forcing all web traffic to the proxy with iptables rules, then you need to take careful stock of the installed browsers and make sure they’re all appropriately secured.
IRC is a very popular way to do support on a lot of distributions, and most desktop distros (including some of the “for kids ones”) ship with an IRC client (XChat, Konversation, etc), and some popular instant-messenger programs (pidgin, e.g.) support IRC. Often these are pre-configured to point to a free IRC server like freenode, and don’t require an account or login.

Potentially offensive stuff

The free software community has deep roots in 80′s hacker culture, a counter-culture movement whose members are often iconoclastic, anti-establishment, and rather libertine. I’m not saying it’s a cesspool of indecency, but now and then things filter through that are probably not going to find favor with most parents.

Often this takes the form of inappropriate references in program names, profanity in games or documentation, or just images that may confuse those not familiar with the cultural background. For example, the utility for connecting to network services in XFCE is called “gigolo”, which I’m sure was a hilarious pun for the person who wrote it; but I’m not giving a neighbor child a desktop with a program called “gigolo”, no matter how innocent its functionality is. And then there’s “Chuckie”, the FreeBSD mascot, who is depicted as a red devil with horns and a pitchfork. He shows up in several child-oriented games (including GCompris and SuperTuxKart). Nothing malicious or “Satanic” is intended by his presence (just a shoutout to FreeBSD, really), but for parents who aren’t familiar with FreeBSD or what this character represents, a devil with a pitchfork randomly showing up in a children’s game is a bit of an eyebrow-raiser².

If you’re setting up a system for someone else’s child, check the things you install for “eyebrow raisers”. These may be different depending on your culture, the parents/guardians involved, and the child(ren)’s unique sensitivities, but you can’t just trust everything you find in a software repo to be kid-friendly (or at least, friendly to every kid).

Root access?

Now here’s a question to ponder; do you give your child root (or sudo) access? If this is not your child we’re talking about, that’s probably a decision you should discuss with the child’s parent or guardian. In doing so, one has to consider the ramifications of this decision:

The child can potentially mess up the system with careless tinkering
The child can pretty much defeat any sort of restrictions placed on the machine (filtering, time limits, etc), assuming (s)he’s intelligent enough
The child can install any software in the repositories, some of which may be inappropriate for kids
The child can view (and edit… and delete) all other files on the system (if it’s a shared system)

I’ve been comfortable with my older children having root, but I’ve reserved the right to take it from them if I find it’s been abused. Of course, if the computer is not being shared and not connected to the internet, there’s probably not much the child will end up doing with root access, so it’s kind of moot.

Conclusion

I’ve given you a bit to ponder here, and probably haven’t touched on everything you need to consider when it comes to keeping kids safe on the computer; but I hope you get some of the state of mind you have to take when assessing possible issues in your system’s configuration and applications. When you give a child a computer, you give them a powerful tool; it’s naive to think that power can only be used positively and safely. Whatever you do to configure the computer for safety, make sure you configure the child for safety as well. Set rules, and enforce them. Communicate with your child about his computer use, and guide him into healthy choices.

In the next article, I’ll talk about some wishes I have for the future of Free computing for kids.

Footnotes:

¹ “DNS” is the service that translates domain names (like alandmoore.com) into IP addresses. If there isn’t an IP for a site, you can’t go there. DNS-level filtering means that OpenDNS has a huge database of “bad” sites, for which it can (optionally) return no IP. This approach has some limitations, of course, but it’s better than nothing for keeping kids away from dodgy websites.

² Dear non-parents, please take a moment appreciate what we parents are dealing with these days, and why we often reject some really cool things for what may seem to you like silly, arbitrary, illogical reasons.

When I was a kid, the TV had five channels on a sunny day; the video games had 8-bit (or less) graphics; movies were watched in the theater with my parents; and the “information superhighway” was the road you took to the public library. It was a time when using the word “sex” in a pop song caused a scandal, Hollywood still made (and promoted) “G” movies, sitcoms were about happy middle-class families, and nobody on TV ever got brutally murdered before 9 p.m. – not even in cop shows (and even then, you didn’t actually see it).

Our kids are bombarded by media from all directions everywhere they turn. Never mind what TV and pop music have become, the Internet alone brings movies, pictures, songs, games, and words from all kinds of people all over the world and puts them all a few clicks away. Unfortunately much of it is made by people who just don’t grasp what is appropriate to put in front of children, or by well-intentioned people whose cultural values are simply at odds with our own. There is no way we can thoroughly and objectively evaluate the sheer volume of readily-available media before they consume it. I can’t read every comment on every wiki, watch every cut-scene in every game, or test every hyperlink on every website they want to visit. About all we can do is make the best evaluation possible based on a quick once-over and occasional observation, and err on the side of caution.

It’s not always a question of finding grossly offensive things worthy of feet-stamping and congressman-calling, but often just small “red flags” that indicate a potential problem with what the authors of this content consider acceptable for children. Yes, we may jump to conclusions and get it wrong now and then; we may wrongly reject something really cool over a dumb misunderstanding. Frankly, though, our children have no shortage of safe, healthy, and productive ways to entertain themselves and expand their worlds; so unless it’s something that has enough “awesome factor” to warrant careful examination, there’s no reason to waste time with things that contain more than a couple of “eyebrow-raisers”.

From PHP to Python: things I wish I’d known

Alan — Sat, 02 Feb 2013 21:00:00 +0000

The story so far…

Back around 2005 I took my first leap into the world of writing useful programs armed only with my laptop, a Pentium II running Debian, and a fat book on PHP5. Though I’d taken a few classes on C++ and tinkered with BASIC on a few different platforms over the years, I’d never managed to produce anything that actually did anything practical (or, did it very well, at any rate); with PHP, though, it didn’t take long to spread my coding wings and take to the air as a novice web developer.

Before long, my skills proved useful in some critical situations at work, and my place as a web developer was cemented. My PHP code became more mature as I learned hard lessons of experience and combined them with the programming theory and computer science I was avidly consuming on the web.

Around the same time, I got interested in Python when I saw a coworker using it to build powerful desktop applications quickly and effortlessly; I wanted to round out my programming skills with a “desktop stack” as quick and simple as PHP, and Python turned out to be a good choice.

So for a few years now I’ve written mainly in these two languages, PHP for the web and Python for the desktop. As my applications have grown bigger and more complex, I began to develop a growing discontentment with PHP on a number of levels. So when people started talking about doing web development in Python, I had to see if I could make the switch.

What “they” say

Programmers who like to be vocal about things on the Internet often like to be vocal about PHP; it seems every so often someone will write an epic diatribe on what’s wrong with PHP and why everyone should avoid it. They will tell you to instead use Java, or Ruby, or Python, or whatever – just not PHP. And while I can’t bring myself to completely denounce PHP, when I’ve been waist-deep in a hacked-up PHP codebase for a while, words like “elegant”, “expressive” and “truly object oriented” stir something in me that PHP’s clumsy and inconsistent attempts at bettering itself just don’t answer.

Yet when I finally vaulted the fence in search of the greener grass, I found, predictably, that paradise has a few bald spots of its own. More importantly, though, I found that there is a significant paradigm shift that a PHP developer has to make before embracing other languages. Since nobody ever really talked about this shift, I decided to write this article to help others with the journey.

What is PHP anyway?

If your web development story, like mine, begins with PHP, you probably have a similarly skewed idea of what developing a web application is really all about. Correcting that perspective starts with understanding what PHP really is.

A templating system

At its heart, PHP is a templating system – a templating system, mind you, that’s been bitten by a radioactive web spider and mutated into a massive, object-oriented language – but still fundamentally a templating system. What I mean by this is best explained by describing what happens when a PHP document is accessed in a browser:

The web server (Apache, e.g.) receives a request for a PHP document.
The web server runs PHP, passing in the requested file and some details about the request
PHP processes the requested file, dumping in any “required” or “included” files, and evaluating the “” bits wherever they occur.
PHP returns the evaluated document (now pure HTML/XML/CSS/etc) to the web server, which sends it to the browser.

This is why you can stick HTML directly in a PHP file (outside the tags), and it will work just fine: a PHP file fundamentally is an HTML file (even if there’s no raw HTML in it), just one that is marked for some pre-processing¹ before it’s served.

A framework

PHP is also a kind of minimal framework. It does a few nice things for you (such as parsing HTTP requests into nice arrays like $_GET and $_POST), and exposes a huge library of optional functionality like database connectivity and image processing.

It’s important to recognize this, because you need to understand that PHP by itself (apart from any third-party add-ons or abstraction layers) has solved a lot of problems for the web developer out-of-the-box. They way it solves these problems is sometimes good, and sometimes not; but in either case, it’s rarely the only way to solve them. It’s easy to take for granted that the way PHP has done something is the only, or canonical, way. Get used to the idea that it is not.

Bad, but no so bad

As I’ve said, people will bash PHP incessantly, and you can be sure they will continue to. If you can read all the way through “PHP: a fractal of bad design“² and still feel completely good and happy about coding in PHP – well, you’ve got resolve anyway. PHP clearly has problems, ranging from niggling warts to major structural issues.

But in the end, what really matters is you, your software, and the people who use your software. PHP’s alleged shortcomings are meaningless academic drivel until they start to impact these things; and I’d guess that in a lot of cases, they don’t. Not everyone is trying to build the next big Web 3.0 killer-app-in-a-browser; some people just want to automate some things on a personal website, or build a basic CRUD system for a set of data they use at work. Don’t get caught up in the PHP hate and throw away a perfectly good tool that has solved these problems in a decently usable way out-of-the-box.

What is Python, and how do you build a web application with it?

Python is a general-purpose programming language. It has a huge set of libraries to make it useful for a wide variety of tasks, but fundamentally it’s a programming language that wasn’t designed for any specific use.

It’s also an absolutely awesome language to work with.

It’s not, however, a web framework (not even a minimal one) or a templating system; so if you intend to use it for web development on a level similar to PHP, you’ll need to add these things to Python.

I mention this because in the PHP world, there are also frameworks and templating systems – Zend Framework or CakePHP for example. Personally, I used CodeIgniter for two or three major (for me) projects, and found it very helpful… at first. After maintaining the code (and keeping CI upgraded) for a couple of years, I got disenchanted with the framework thing. I found that most of what I really wanted from a framework could be answered with a couple hundred lines of convenience functions and some careful class structure planning. So to me, “framework” initially conjured up a big bloated can of overkill.

If you feel the same way, understand that in the Python world you will need to use a framework – at least a minimal one – because (you’ll recall) you were already using a minimal framework called PHP.

The same goes for a templating system. I originally thought, “meh, why bother with a templating system?”; but really, unless you like having big non-syntax-highlighted blobs of HTML in your logic code (you shouldn’t like this!), you will want a templating system.

So, understanding this, let’s look at some frameworks and templating systems.

Python Web Frameworks

Venturing into the world of Python frameworks will immediately have you staring down the keen double-edged blade of choice. There are dozens of them, ranging from minimal and low-level to massively abstracted software suites with more gadgets than Batman’s utility belt. I have only worked with a few, so I’m going to stick with what I know here, in roughly the order that I tried them.

mod_python and python server pages

Before I really “got” python web development, I of course went to it with the mindset of a PHP developer; this sent me straight into the arms of mod_python and python server pages (PSP). This setup allows you to do with Python pretty much what you do with PHP: you write a python script, and Apache executes it in-place whenever it gets a GET or POST request for the script. The script in question can either be pure python, or an html file with PSP embedded (PSP is basically a templating system; to use it, you just drop in tags (delimited by <% %>) much like you do with PHP).

At first this seems pretty cool; but after a while, you realize that you haven’t really improved the structure or security of your application over PHP, and you’ve traded away all the really nice web-oriented conveniences of PHP just to get a language with slightly (OK vastly) better syntax. It seems kind of a wash, and in the end I never saw much incentive to switch based on mod_python.

Apparently, the Python & Apache communities concur, because as of 2010 the mod_python project was abandoned. No great loss, as far as I can tell.

Django

If you say “Python Web Framework?” in a room full of people, chances are they’ll just look at you funny; but if anyone actually does respond, they’ll probably say “Django”. Some consider it to be the one-and-only Python web framework worth talking about, and the banner under which all such development should rally.

Django is what you’d call a full framework; it’s got pretty much everything built-in and ready to roll: templating, database abstraction/ORM, sessions & security, and even its own web server.

Despite the features and popularity, Django didn’t really get traction with me for a few reasons:

First, because it’s not really my style to use tools that are “everything you could ever possibly need right out of the box”; I tend to prefer more minimal, modular tools that I can build on easily.

Second, because it’s one of those frameworks that has you start out a project by running a special “init” command which flomps out a tree full of generated code, into the midst of which you’re to write your application. I could be wrong, but in my previous experiences, this sort of thing means painful upgrades down the road as you surgically inject code updates into your app.

Finally, (and I could be wrong here), it seemed to me that Django wanted to be in charge of the database layout and code, and wouldn’t work well with an existing database. Since I am very often tasked with writing alternate front-ends or reporting tools for existing (and often read-only) databases, this doesn’t work for me.

I decided to give up on Django after a few days of tinkering, and went back to PHP.

CherryPy

After Django, I was attracted to CherryPy on a couple of counts. First, it doesn’t generate a big tree of boilerplate code – it’s just a library that you import. More importantly, it isn’t attached to a particular templating system or database layer, so you can use whatever you want (or nothing at all). I was still in the “I don’t need no stinkin’ template system” mindset when I tried it, and the project I wanted to do didn’t talk to a database at all; so this minimal framework was ideal for me.

I managed to produce a nice utility which we still use at my work, but my experience was somewhat mixed. Chalk it up to my inexperience with Python web development, but I had basically two problems with my CherryPy project:

There were at least two or three ways to do certain things, like setting configuration options, and the documentation would mix and match them. The same method didn’t always work for me, either; this made my code feel inconsistent.
Many things in the program require some automagical combination of function and variable names, such as session authentication. I had a lot of trouble getting these to work properly, and the debugging messages were not helpful.

Maybe with more time and experience, and longer study of the documentation, I could get along with CherryPy; but at the time, I had work to do and PHP was ready to roll up its sleeves.

Flask

Lately I’ve discovered Flask. Like CherryPy, it’s also a simple library that just has to be imported, and allows you to use whichever templating system or database layer you like (though it seems well-integrated with jinja2). So far I get along pretty well with Flask; it feels a little more straightforward than CherryPy, without a lot of the automagical things based on function or variable names. I’ve had some problems with the way it parses complex form data (doesn’t like nested arrays, apparently³). It’s also helped me realize my need for a templating language, and I learned pretty much all I needed to learn about Jinja2 in roughly ten minutes.

Granted, I don’t have any Flask-based code in production at this point⁴, so I may still be on the hype curve. I’m working on my second Flask-based app right now, and still pretty pleased.

Python Templating systems

I don’t have a ton to say about templating systems, because I’ve only used Jinja2 so far; but I will say this for the benefit of PHP developers like me who think they don’t need a templating system: do yourself a favor and use a templating system. Remember that PHP is a templating system, so it isn’t as if you haven’t already been using one (you probably just didn’t realize it). Don’t do what I did in my CherryPy project and just put your HTML in strings and use printf()-style substitution. Yeah, it works, but it’s ugly, you don’t get proper syntax highlighting, and it mixes presentation with logic.

Don’t stress about which one to use, either. They’re all pretty much the same, just different syntax. I picked Jinja2 because it’s well integrated with Flask and purported to be fast. But really, there’s no wrong answer here; it takes about 30 minutes tops to figure out a new templating system.

One nice aspect I found with Jinja2 (and others probably have similar features) was the ability for templates to inherit from other templates. So I can create a basic template for all pages with some named blocks, then have specific other templates inherit that template and only add to the specific blocks they need to change. This is a nice change from the way I usually did it in PHP, where I’d have functions or class methods to produce various parts of the page (header, navigation, content, etc).

Some general notions you need to get familiar with

So you’ve got your framework and templating system picked out, but there are now some concepts you’ll want to get used to and some bad habits you’ll want to break in order to produce a Python web application.

The web page is not STDOUT

In PHP, if you want to put something on the web page, you just echo it. Since we’re just pre-processing a document in-place, anything PHP spits out ends up on the resulting page. This isn’t the best style of PHP coding, but now and then it’s how you solve a coding problem, and admittedly a lot of us PHP coders debug this way (using echo or var_dump() at any arbitrary points in the code to see what’s going on).

Python frameworks like Flask and CherryPy don’t operate this way; instead, you write functions that return a chunk of HTML, which the framework packages into an HTTP response. So unlike PHP, if you just “print” something, it won’t end up on the resulting web page. Instead, it ends up wherever STDOUT has been directed⁵

This wasn’t so much of an adjustment for me, because this is generally how I wrote PHP applications anyway: as a set of functions that returned chunks of HTML. For some PHP coders, who may be accustomed to just echoing data as they get it, this is a very foreign approach.

Routing

Earlier I described how a web server goes about handling a request to a PHP file; basically, if I browse to http://example.com/lib/docs/help, the web server would look for /lib/docs/help/index.(something). If that “something” happens to be “php”⁶, then PHP gets the file, does its thing, and we’re all happy. If there isn’t an appropriate index file there, you get a 404 or maybe 403 error. Bottom line, if you want to make the URL available with PHP, then (short of doing some magic in the web server configuration, e.g. mod_rewrite), you need to create a PHP file at that URL.

With modern Python frameworks, it’s not like this. Making a particular URL on the server return a page of HTML doesn’t require that actual files exist at the path; rather, the framework has a system to map URLs to functions or classes in your program. This is generally called “routing”.

So, in the example above, making that URL work on a Python-framework site would not require you to create any files under /lib/docs/help, or even create those directories under the webroot. It just requires that your code maps the path ‘/lib/docs/help’ to a function or class that returns a valid response (a chunk of HTML, or an HTTP response object, e.g.).

Some PHP frameworks or applications let you do something like routing (a.k.a. “pretty/simplified/clean URLS”), usually by using mod_rewrite to hide a request for some actual php file.

HTTP

Before I got into doing web applications with Python, I confess that I didn’t really understand HTTP all that well. If you only work with PHP, you probably know that information can be sent to the server as a “GET” or “POST”, and you know the difference in terms of how it looks in the URL bar. It turns out there’s a good bit more to HTTP than just GET and POST, and if you’re working with a Python framework there’s a lot of benefit in understanding it all.

It’s not that Python frameworks don’t abstract HTTP; it’s that they abstract it differently than PHP does – and frankly, I think they abstract it in a cleaner and more natural way. For instance, while PHP makes the contents of an HTTP request available to your script through a series of global arrays (e.g. $_GET, $_SERVER, etc) or function calls (e.g. getallheaders()), Python frameworks tend to give you some kind of request object that encapsulates the entire HTTP request.

If you consider the fact that your Python framework and application are handling many of the things that PHP just let the web server handle, it makes sense that you’re going to be living a little closer to HTTP; don’t let this scare you though. The more I’ve learned the more I start to think that HTTP itself is actually simpler than the mess that PHP abstracts it into.

MVC

If you’ve used one of the more well-known PHP frameworks (like CodeIgniter, e.g.) you’ve probably come across the term “MVC”⁷. MVC is a software design strategy that cleanly divides your application into three parts:

The Model, which is your data model and handles all read/write operations to the database or data store
The View, which is the interface the end user actually sees and interacts with
The Controller, which manages interactions between the View and the Model

If you haven’t used a framework, or disciplined yourself to using the MVC pattern already⁸, you’re in for a shock. Python frameworks, so far as I have seen, all pretty much enforce the idea of MVC on one level or another. This is ultimately a good thing for your code, and without patterns like this it gets difficult to scale to a real application; but it’s a real learning curve if your usual MO is to sandwich database queries and business logic between large chunks of HTML ad-hoc.

Planning and design

OK, the “real programmer” crowd out there may sneer a bit at this point, but if you’re going to move off PHP you need to prepare to do a little more planning when you create a web app. If PHP excels at anything, it’s in allowing you to just sort of hop in and code by the seat of your pants and build something huge without a lot of advanced planning, sticking code wherever it seems to fit to get the job done.

The python frameworks I’ve encountered enforce a bit more rigidity than this. Unlike PHP, you aren’t just tromping through a script from top to bottom, so you can’t just define things willy-nilly and expect them to be in scope when you need them. Similarly, your templating language is merely a templating language, not a full-blown programming language; so you can’t just stick a bunch of function calls and variable assignments in your template because it feels good.

In addition, frameworks like Flask use a lot of design patterns and abstract constructs whose application isn’t immediately obvious to people who don’t get deep into software design theory. Properly applying these constructs takes some contemplation about what your application is doing on a more abstract level.

This is ultimately good for you, because it forces you to design a better and cleaner application than you might have done in another language. It absolutely requires a different mindset and approach, though.

Downsides to Python

In addition to the need to navigate the paradigm shifts I mentioned, there are some downsides and pitfalls to using Python for web development, and I think it’s fair to mention them.

Deployment

Deploying your PHP application is as simple as dumping your .php files into a folder under the webroot⁹. Deploying a Python web application is a little more involved, and there are multiple ways of doing it each with its own pros and cons to weigh.

And of course, your web host may not support Python, Flask, or any of the other Python libraries you need to run your application; I can almost guarantee that the company who hosts this website doesn’t. If you were thinking of writing a CMS in CherryPy for people to use on their $1.99/mo shared web host, you’re wasting your time.

Database access

If you’re into high-level abstractions that take all the icky SQL out of your code and replace it with objects and method calls, Python has you covered well with ORM layers like SQLAlchemy. If you’re like me, and you actually prefer to write your own SQL, the situation is a little different.

PHP has a nice database abstraction layer called PDO, and if you aren’t using it, you need to quit typing “mysql_” and start using PDO. PDO is a single library with consistent classes, methods, and properties no matter what database driver you’re using.

Python, on the other hand, has the DB-API, which is a specification for writing database libraries for Python. Instead of one library with drivers for different databases, Python gives you product-specific libraries that (mostly) adhere to the DB-API. In theory, this should be as nice as PDO, but in practice it’s more chaotic. Some libraries extend DB-API with extra functions, and within the spec there is flexibility in how certain things are implemented (e.g., parameter style for parameterized queries). I found this problematic when (for example) I ported a Flask application written for psycopg2 (a popular PostgreSQL library) to cx_Oracle (the one and only Oracle DB-API library) and had to adjust a lot of code¹⁰ due to differences in interpretation of the spec.

Of course, someone out there is screaming at me now to use ORM, but I’m just not there yet.

Application focus

Frameworks like Flask or CherryPy seem to assume that you are actually writing an application, not just an arbitrary collection of unrelated web content. This is great if you actually are writing an application, but not everyone is. Sometimes you’re just creating a page that needs to do a little computational work before it displays, or a form that needs some simple processing on submission.

If you have a website like, say alandmoore.com, which contains several subsections of marginally-related content, much of which is legacy and doesn’t need to be touched, using PHP is pretty frictionless. If I want to add a new page which has nothing to do with the rest of the site, but which needs to do some special processing before it displays (like, say, scanning a directory of MP3 files and displaying ID3 information), this is as simple as writing a new .php file and dropping it into a directory.

If my website were handled by a Python application, this would get trickier. I’d either have to write and deploy a new WSGI application (which seems a lot of work and overhead for a single page), or I’d have to add a new function to my existing application (complicating and potentially destabilizing my whole site).

Python 2/3

The current curse of the Python universe is this whole Python 2 to Python 3 transition that’s been going on for the last few years. In the web development space, there are many popular libraries and frameworks that don’t yet support Python 3; Notably Flask, Python Imaging Library, and Django¹¹, though hopefully this will change soon.

What this means for new Python coders is that you need to keep coding in Python 2, but you need to do so in a way that will be easily portable to Python 3 in the future. Which basically means you need to learn both versions. Eek. If you’re not already invested in Python, this can be a deterrent.

Do you need to switch?

I’m not going to be one of those bloggers who insists that you need to switch away from PHP to Python or anything else. PHP isn’t going away any time soon, and for a lot of applications it’s perfectly adequate and easy to ideate. I will say, however, that taking the time and effort to embrace a language like Python and the disciplines of the more popular frameworks is beneficial to any web programmer.

What really motivated me to get into Python was when I started using AJAX more and more, and found my applications moving from a set of dynamic web pages to Javascript applications that occasionally talked to a web service to read & write data. In other words, when my server-side code was more about exposing a large range of read/write database operations to AJAX calls than generating full pages of formatted HTML, the Python frameworks did this with a lot less fuss and a lot less data-shuffling.

I’d suggest sticking with PHP in the following scenarios:

Your pages are mostly HTML with just a little bit of dynamic content here and there
Your work needs to be deployed on cheap shared web-hosting
You don’t think of what you’re writing as an “application”, just “web pages”

If you’re doing serious web development work, and you have control over the production server, then I think it’s well worth the effort to use Python for your next big project. I will most likely continue to do a lot of work with PHP for legacy projects at work and for clients; but as much as possible, I’ll be moving to Python from here on out.

Footnotes:

¹ Note the official PHP backronym is “PHP Hypertext Preprocessor.

² I mention this rant a few times because it’s made waves in the web development community over the last year or so, and makes a lot of good points. For the record, I don’t agree with everything in it (some points seem a little contrived or unfair), but a lot of the criticism is spot on (like the inconsistencies in naming and parameter ordering) and convinced me to try harder at branching out. I think any PHP developer should read that rant with an open mind.

³ To be fair, I fixed this issue with about 10 lines of python.

⁴ This isn’t Flask’s fault, I have a reporting application ported from PHP mostly done, but held up by one of our vertical app vendors.

⁵ Which, when you’re using the built-in development server, is usually to the terminal from which you ran the application. Which is pretty wizard, really.

⁶ or any other extension which the web server is configured to interpret as PHP

⁷ Model View Controller

⁸ Read: “If your code is haphazardly littered with calls to mysql_query()…”

⁹ Assuming PHP is already set up and configured, which is pretty trivial in these days of cheap web hosts and easy Linux distributions.

¹⁰ I mean Python code; it’d be natural and expected to have to adjust SQL code between products, of course.

¹¹ Python 3 support is currently experimental

Building a Linux system for a Child, part2: Distros and software

Alan — Thu, 31 Jan 2013 22:42:00 +0000

The last article in this series described some of the more general realities of running Linux on a child’s computer. Now that I’ve (surely) convinced you to go ahead an put GNU/Linux on your child’s computer, it’s time to get down to nuts and bolts: which distribution, and what software?

Ready-made distributions for kids

There are a few distributions out there which attempt to deliver a child-friendly desktop right out of the box. These might be useful to you if you’re not very experienced with Linux, but even if you are, they can be a good introduction to what’s available for kids.

DouDouLinux

This Debian derivative from France is aimed at very young children. The interface is colorful and simple, and they’ve done some clever things to make the login menu act like an application menu, so that the child can just boot the PC and click (for example) “tuxpaint” and be in tuxpaint without all that tedious logging in and starting a desktop environment.

There’s also the option for them to log in to a desktop environment – specifically LXDE with LXLauncher running (so it’s kind of like the original eeePC interface, with tabs and big icons for stuff). The fact that it’s LXDE means it can run well on your old computer, and I had good luck installing DouDouLinux on a k6-2 laptop with 256 Mb of RAM (we use that particular unit to teach patience…).

If you plan to let the kids surf the web, DouDouLinux comes with content filtering already configured and enabled right out of the box. As far as I know, it’s the only distribution that does this, and for this reason alone is pretty sweet.

The program selection and graphics pretty much target younger grade-school children; your preteen will probably not appreciate all the teddy-bears and kitty-cats and whatnot.

Qimo

Qimo (sometimes called Qimo4Kids)is an Ubuntu respin with an XFCE desktop. It looks really nice, includes all the usual software suspects, and (since it’s XFCE) works reasonably well on older systems. Unfortunately the project hasn’t been updated in nearly 3 years, and there aren’t any signs of life at the website as of this writing. If you’ve got the bandwidth and media to spare, though, booting to a Qimo live CD might give you some good ideas, if nothing else….

SkoleLinux

SkoleLinux is basically the Debian-edu project’s Debian respin; it’s designed for deployment in schools using Linux Terminal Services, but you can still use it to set up a standalone desktop. It comes pre-loaded with a good selection of educational titles (mostly STEM-heavy stuff aimed at classroom use) on a simple KDE desktop.

SkoleLinux’s default configuration isn’t visually exciting or inspiring, but it’s a nice way to discover some programs you might not otherwise find. It’s pure Debian, so you can easily reconfigure it (lighter desktop environment, e.g.) after installation.

Edubuntu

Edubuntu is basically Ubuntu’s take on SkoleLinux; like SL, it’s designed for network deployment at schools, but can also be used on a single standalone desktop. It features Ubuntu’s Unity desktop along with just about every educational program available in the repositories, so it might be a good shortcut to try if you were just going to install Ubuntu in the first place.

The Unity desktop makes it a poor choice for older computers though, so if your computer is actually older than the child, you might be better off with one of the other options.

Are ready made distributions worth it?

Projects aiming to create the perfect desktop for kids come and go; no doubt there will be more to come. From my perspective, they’re mostly just different ways to deliver the same set of programs and maybe some kid-friendly artwork. DouDou has a few twists to offer, but I found that my kids outgrew it quickly and just wanted a desktop environment.

If you’re committed to doing this Linux thing, I’d recommend getting your hands dirty with a general-purpose distribution and just configuring it to your child’s needs, because more than likely none of these distros are going to be exactly what you need right out-of-the-box anyway. If you choose Debian, Ubuntu, or a derivative of either, all the SkoleLinux/Edubuntu packages are already available to you anyway, and you won’t be locked into a specific desktop environment or burdened with software that isn’t age-appropriate for your child.

General purpose distributions

Since I’m recommending going with a general-purpose distribution, you may well ask, “Which one?”. If you have a favorite Linux distribution already, skip this section¹. If you’re new to GNU/Linux and aren’t sure which distribution to choose for your child’s computer, here’s a quick-n-dirty assessment of distributions I’ve used.

I prefer anything derived from Debian. This includes Ubuntu (any flavor), Linux Mint, Mepis, and many many more. Mostly this is because a huge amount of software can be installed very easily in Debian-based distributions.
Ubuntu and its spin-offs are nice if you’re new and want some easy installation and configuration tools. If you object to the commercial stuff or desktop environment of Ubuntu, try Kubuntu for a newer computer or Xubuntu for an older computer. If both of those are too slow, try Lubuntu.
Stick to the LTS (long term support) releases of K/X/L/Ubuntu. They get security & bugfix support for 3-5 years. Currently this is 12.04, and the next will be 14.04. Otherwise you’ll have to deal with a catastrophically massive upgrade every six months.
If you’re less interested in hand-holding and want slightly better performance, try Debian. Software in Debian’s stable release is usually a few releases behind Ubuntu, but very solid and bug-free. New stable releases only come about every 2-3 years. Stick with stable unless you’re willing to deal with random breakage now and then.
If you like Debian stable but want a little friendlier install & configuration, and some of the applications to be more up-to-date, there are several derivatives that do this sort of thing. My favorite for a long time was Mepis, which comes pre-configured with a nice KDE desktop like Kubuntu; if you’re not into KDE, you might prefer SolusOS or one of the Linux Mint Debian editions too.
If you really hate the idea of using Debian (or derivatives), want a huge selection of software in bleeding-edge versions, and aren’t afraid to do a sizeable amount of learning to set up and maintain the system, go with Arch Linux. But don’t say I didn’t warn you…

These aren’t the only choices, but their the ones I’ve personally worked with and can attest positively to. I’m sure if you ask your nearest Linux geek, you’ll get some strong opinions one way or another.

Software for kids

Few things are more tedious to read, or prone to becoming stale, than an exhaustive list of software; so rather than listing every child-oriented package available for Linux, I’ve picked a few standouts – that my kids have actually used and enjoyed – to recommend. These are mostly educational (I could write a book on the non-educational things we’ve played over the years), but some are just really quality games or apps that have been our favorites.

Recommended for young children (pre-k through 2nd grade)

GCompris: a massive collection of small, educational activities for kids that covers a wide variety of subject matter, from core things like numbers and letters to obscurities like how a lock and dam works or how to pilot a submarine. Most of my kids have found at least a handful of GCompris activities enjoyable and educational, if only for a few years around first grade. After that they kind of lost interest.
Tuxpaint: this is a really fun paint program with tons of cool stuff like stamps and special effects. Every one of my kids has enjoyed tuxpaint at some point, and even my oldest occasionally tinkers around in it. Heck, even I get caught up in it now and then…
Childsplay: a smaller and less-polished attempt at the GCompris idea, childsplay nevertheless has a few activities that some of my kids really liked for a long time. The animal/letter flashcards are useful on a variety of levels.
Tux-typing/Tux-math: These two games used to be very different, but kind of merged together at some point so that they are basically the same games except that in one you type and in the other you do arithmetic. My kids didn’t play these a huge amount², but these games are really well done, and might be a little more fun for drilling typing or math than some more sterile options.
Supertux: Not exactly an educational pick, but this one has been number one on the charts with my kids for years. The killer feature for my kids was never the game itself, though, but the level editor. This and other games with level editors have been instrumental in helping my kids see that computers are creative tools and not just consumption devices.
Ktuberling: This started out as a “Potato-head” program where you could drop facial features on a picture of a potato, but over the years has morphed into a 2-d playground application where you can build robots, make a pizza, or design a butterfly, among other things. My younger ones enjoy playing with this and telling stories as they build a picture.

Recommended for slightly older children (2nd – 6th grade)

FreeCol: This is a turn-based strategy game set in the Colonial age, and while it’s not strict to history it’s had some educational value in giving my kids a feel for the period and an interest in learning more about the 16th thru 18th centuries.
Phun: this is a cool little “playground” for 2-d physics simulation. You can create objects, springs, wheels, gears, water, and other simulations and combine them together to build simple machines. Our favorite use of Phun is building 2-dimensional seige engines to knock down block walls.
Celestia: if you have a child going through an “Outer Space is awesome” phase, Celestia is paradise. It’s a 3D simulation of the known universe that uses (whenever possible) authentic image overlays to be as realistic as possible. So you can fly off to Jupiter and watch its moons go round and round, or explore a comet at close proximity.
SuperTuxKart: This game isn’t at all educational, but dad-gumball it’s fun. Just had to give a shoutout.
Ri-Li: This is a “realtime puzzle” sort of game where you have to guide a toy train around a track so that it picks up cars and doesn’t crash (kind of a spin on classic snake games, I guess). Good for cognitive development, I suppose, and great for boys who are going through the “train phase”.
Fish Fillets: This is an old logic game, in which you have to move objects around the screen and arrange them in a certain way so that your two fish characters can escape. I put it in this category because my kids started enjoying it as early as 2nd grade, but many of the actual puzzles are pretty challenging even for very intelligent adults. You’ll probably have to help your kids with these, but they’re a good way to teach logic and logical sequencing.

Recommended for older children (6th grade and up)

Scratch: This is awesome software for kids interested in computers; scratch is a graphical, drag-and-drop programming environment for kids³. I downloaded it intending to use it as a tool to teach programming basics, but after turning my son loose on it for a day or two I found him writing his own simple games and doing stop-motion animation with his legos all on his own. My two oldest still really enjoy working in Scratch, and it helped them both immensely when we studied Python.
Minetest: You can think of minetest as a block-based 3D “sandbox” game… or more realistically as a free knockoff of MineCraft. Keep an eye on your kids with this one, though, because (just like MineCraft) it’s insanely addictive.
OpenTTD: My oldest loves this game; it’s a simulation game about building up a transportation business. Teaches lots of good ideas about business, economics, urban planning, civil engineering, etc.
KSudoku: There are many sudoku applications out there for Linux, but our favorite is KSudoku. It’s visually compelling and has some very thoughtful features.
Laby: This is a game for your programmer child; You have to write short programs to move an ant through a maze of spider webs. Unfortunately this game is currently very short, but it might puzzle your little professor for a few days.
StopMotion: This is a cool program for making stop-motion videos, and very easy to use. Stopmotion + cheap webcam + Lego collection + too much free time can easily yield some awesome and hilarious stuff.
LMMS: My kids aren’t nearly as interested in music as you might think, given that I’m an ex-recording artist/composer/producer; but they’ve been wondering about how to make music for some of their Scratch projects and stop-motion films. LMMS is a nice, simple package for composing electronic music with software synthesizers and samples; it takes a little bit of basic orientation to get going, but it’s much more accessible than tools like Ardour, Rosegarden, or the like.
KDE edu: The KDE project has some nice educational tools, mostly useful for older kids and adults. They aren’t necessarily cool programs your kid will launch into every day, but more like resources for helping with schoolwork (particularly if you homeschool like we do). For example, Kalzium (an interactive periodic table) was really useful when we did chemistry; “kbruch” is nice for teaching fractions, and “kgeography” is awesome for showing you how little you know about world geography.

Other software to consider

Google Earth: I wish we’d had Google Earth when I was a kid. I still find it amazing we have such a thing available to us; my kids don’t appreciate it as much as I wish they did, but we can still while away an hour or two finding cool or familiar places on Google Earth.
Text editor: If kids can type, sometimes they just want to type stuff. Make sure there’s a good, simple text editor like leafpad, gEdit, or Kwrite available on the system. Yeah, you can give them a word processor too, but sometimes it’s nice to just focus on the text. For younger kids, preset the font to be nice and big. If you want something a little more free-form, that also allows drawing on the page, check out Xournal.
DOSbox: There is a lot of freeware, shareware, and abandonware out there in the wild for DOS; and while it doesn’t boast the latest graphics and multimedia goodies, I can attest that much of it still has educational or entertainment value for kids. There are other classic emulators out there to, for various systems from Sega, Nintendo, and Sony; but I mention DOSbox in particular because there are programs for DOS with educational value (surely you’ve got a copy of Oregon Trail kicking around somewhere?).
Bibletime: We are a Christian family, and Bible study is an important part of our lives; there are a few Bible programs out there for Linux, but I highly recommend Bibletime. It has some KDE dependencies, so if you just must have a GTK program try Xiphos; but if you care more about functionality and usability try Bibletime.
PlayOnLinux: This is a graphical front-end to Wine that makes it dead-easy to install supported software on Linux. If you happen to have some old discs of kid-friendly games for long-gone versions of Windows, and you’re going to have a go at making them work in Wine, try PlayOnLinux first. It might just save you a lot of work.

Which Desktop Environment?

With the smorgasbord of desktop environments now available on Linux, it’s worth asking: which one is best for kids? Well, we haven’t used them all at my house, but of the ones we’ve tried, here are my thoughts:

KDE: Since we started out with MEPIS years ago, KDE 3 was our favorite desktop environment for the longest time. KDE 4 lost us for a bit in the early days, but now that it’s stable and performant we’re back on it. The “search and launch” desktop, with a bit of setup, makes a very nice desktop for kids, and there are lots of fun themes and plasma widgets you can install to make the desktop special and cool. Biggest problems we’ve had with KDE were some content issues with the “Get Hot New Stuff” functionality⁴, and that the kids would destroy the desktop beyond functionality by loading it with lots of pointless widgets (another set of Xeyes? Sure why not, I’ve only got 10!) and removing important ones (like the launcher menu). Once we got past this, KDE 4 is great.
Unity: When we got our latest set of computers for the kids, I showed my oldest the four major flavors of Ubuntu and let him pick the desktop he wanted. He chose default Ubuntu with Unity. They all do pretty well with it, though for the younger ones there’s a real discoverability problem. They often don’t know a program they want is installed, or how to find it. Once we’ve pinned their favorite programs to the dash, they’re ok; but Unity’s focus on keyboard control is not so good for little ones.
XFCE: Always a solid choice for kids, especially on slower systems. It doesn’t do terribly fancy themes⁵, but it’s still packed with features and has flexible layout options. This is my go-to DE when setting up computers for people outside the family, since it’s really hard to mess it up beyond repair.
LXDE: We used this when the kids were stuck with really slow systems for a while; works great, very simple to use, and very fast. You can use LXLauncher with it too so that it has a full-screen menu – very kid-friendly if you tweak it some. LXDE seems to lack a little when it comes to organizing programs automatically on the menu, meaning that the bulk of your programs tend to end up on one big huge submenu under “Other”. This can be a detriment to discoverability for kids.

Don’t ask me why, but we never got into Gnome or its spin-offs (not counting Unity); GNOME 3, with its focus on stark simplicity, may be a good choice for kids, and Enlightenment 17 looks rather compelling. Of course, if you’re so inclined, you can cobble together a kid-friendly desktop from parts⁶.

The bottom line is that it’s hard to go too wrong with a desktop environment. If you’re really unsure, I’d say go with XFCE as the “safe option”.

Conclusion

As you can see, you have a lot of options when it comes to setting up a Linux environment for your kids; hopefully by now you have some ideas about how to proceed. In the next article, I’ll talk about some important safety considerations, tackle the “parental controls” mess, and I’ll offer a few “wishlist” items of my own.

Footnotes:

¹ No, really; skip it. You’re almost inevitably going to disagree with something I say here and and make a bunch of useless fanboy comments.

² Math is math, no matter how many cool lasers, explosions, meteorites, and other stuff you surround it with. Kids smart enough to do it can see through it eventually.

³ Incidentally, check out this really great talk by one of the creators of Scratch about teaching kids to code: http://www.ted.com/talks/mitch\_resnick\_let\_s\_teach\_kids\_to\_code.html

⁴ More about this in the next article.

⁵ So, for example, the awesome TRON-inspired theme we created in KDE isn’t doable in XFCE.

⁶ I made a very simple “desktop environment” for my little ones using OpenBox, Tint2, and my own KiLauncher project.

Building a Linux system for a Child, part 1: What and Why

Alan — Mon, 07 Jan 2013 22:42:00 +0000

One of the common suggested uses for old computers is to install GNU/Linux on it and give it to your kids. I have five children, ranging in age from pre-teen to infant, and all but the youngest (naturally) regularly enjoy the use of computers running some variant of GNU/Linux. We’ve been using it at home since about 2005, and over the last eight years I’ve gained a reasonable amount of experience setting up Linux on computers for my children or their friends. This series of articles will cover some of my insights on setting up a Linux computer for kids.

Why do you give a child a computer?

Ever since I was a child back in the 80′s, there has been this notion that giving a child access to a computer is an unquestionable good which all-but-guarantees his success in later life. Organizations public and private have worked hard to place computer technology into the hands of children here and abroad, and unfortunately they seem to have done a good job of it.

Yes, unfortunately; because today’s children spend as much as nine hours a day in front of screens; and for the most part, they aren’t reading scholarly articles, composing master works, or exploring the world of science and technology. They’re more likely fraggin’ virtual bad guys, socializing on facebook, or probing into the seedier corners of human nature.

Not that I’m against kids having computers; far from it. But I think it behooves a responsible parent to consider how best to direct a child’s use of the computer so that its possession will be a net positive. A computer can be many things to a child:

A general education tool, for researching and learning about non-computery things like science, history, geography, literature, etc.
A computer education tool, for learning about computer technology itself.
A multimedia device, for enjoying music and movies (educational or otherwise).
A communications device, for email, chat, social networking, video chat, etc.
A creative tool, to aid in authoring music, video, pictures, text, etc.
An entertainment device, for games and recreational web surfing.

Taking your child’s age, interests, abilities, and other circumstances into consideration, you’ll want to decide which of these uses you consider more important, and which (if any) you consider inappropriate or unnecessary. With this information in hand, we can steer the child’s computing experience in such a way that it just might end up being something like the great thing we all thought it could be once upon a time.

My personal goals for my kids with computers are:

to teach them about computer technology, including computer science and programming
to learn to use a computer in other creative and productive pursuits
to enhance their general education when possible
within limits, to unwind and have some fun

Your goals may differ, and you’ll have to keep that into account as you consider how to set up your child’s computer.

Using Linux for a child’s computer

The computer you’re giving to your child very likely had some kind of operating system on it, and very likely that OS was (at least initially) some version of Microsoft Windows. Before we talk about putting a Linux distribution on it, I think it’s worth counting the cost. You will be surrendering some potentially positive things, and subjecting yourself to potential difficulties in exchanging Windows for GNU/Linux, so it’s worth considering if this move really meets your goals. Let’s start by clearing the air and getting the negative out of the way:

What you give up by using Linux

First, there’s the software. There’s no shortage of high-quality software for children on Windows, much of it featuring popular TV and movie characters, ready to help your child learn and play. These games are rarely compatible with Linux¹. Apart from games, your kids might need to run Microsoft Office or some proprietary educational software for school. Basically, there’s just no guarantee that any random product you want (or need) to purchase and install for your kids is going to work.

The incompatibility extends to the Internet as well. You’d think in 2013 we would be done with the whole “you need Windows to use this website” nonsense, what with everyone toting about Android/iOS tablets; but sadly there are still a few holdouts entrenched in the proprietary browser plugin mentality who might leave your kids staring at a “missing plugin” error instead of a cool new online game or favorite video. Silverlight, Unity web player, Shockwave (sadly, people still use this), and even ActiveX (people still use this too) can mean no-go for some online games and activities.

Another shortcoming on many of the current popular Linux distributions, as I’ll discuss later, is the lack of simple parental controls (as such). This isn’t to say we can’t accomplish many of the things that parental controls are meant to accomplish, but it’s not as straightforward as you’d wish.

Finally, on a less concrete note, we’re taking from the child the chance to see and experience the operating system that the vast majority of people use to do business and personal computing. They will be missing out on a shared cultural experience, and will be unfamiliar with tools that many people might take for granted².

What we gain

So now that I’ve almost talked you out of it, let’s look at what makes it worthwhile to give a child a computer running GNU/Linux:

Saving Money

You will save money running Linux. Not at first, naturally; if you already own a Windows license for this computer, you aren’t immediately out of pocket for anything. But in the long run, we’ve found over the last eight years that the cost of home computing has been much lower for us, for a few reasons:

We never need to buy things like anti-virus or anti-malware
The things we need are usually readily available for free in the software repositories.
Many things that we might have bought (games, e.g.), we didn’t buy because it wasn’t compatible. We were fine without these things.
We could extend the life of our hardware while still running the latest releases of the operating system

One could argue, of course, that freeware and open-source software (much of the same open-source software) exists for Windows as well, and if we were going to restrict ourselves to that we could as well do it on Windows. That may be, but I think it’s a lot different when you have to proactively go out and find, vet, test, and maintain this software; on Linux, you open the package manager and install what’s recommended.

No Malware

Kids have a knack for finding malware; I’ve been paid to reload Windows on enough teenager-operated laptops to know it. In my experience, no amount of anti-this or anti-that software will completely mitigate the threat – on Windows. Running Linux, your child’s system will simply not get malware³.

This is awesome, not only because malware is a pain to remove (sometimes requiring reloading the OS), but also because some of it can put some pretty nasty stuff up on the screen. You do not want this happening on your computer, and you certainly don’t want it on the computer you set up for your niece, younger brother, or the neighbor’s kids.

A custom experience

When it comes to customizing a system – whether for looks, performance, special needs, or just for the heck of it – nothing beats Linux. Yeah, I know, there are hacks and tweaks and third-party shells for Windows; but if you’ve spent much time with Linux you know that it offers deep customization in spades. There is no “officially blessed” distribution, desktop, or configuration; so all the various options are equal citizens on this platform.

This is really a great benefit when you have to work with old hardware, when your kids have special needs, when you want to build a system for specific limited purposes, or for locking down the system for only a few select tasks. Even if you don’t feel like tinkering with config files, the current crop of Linux distributions ship with any of a dozen different desktop environments configured for a variety of tastes and needs.

A broader experience

I’ll never forget a situation years back where I walked into an office to see a panic-stricken woman staring at the screen of a Mac, frantically asking, “How do I launch Internet Explorer on this thing?”. Well, at our house we change desktop environments like some people change hair styles, and everyone has his preferred browser. My kids understand that they don’t need “Internet Explorer”, or even “Firefox” to surf the web; they just need a “web browser”. They don’t panic if there isn’t a “start” button in the lower left corner; they just click around until they find something that looks like a menu (or command input).

This may not seem like a really compelling point, but I think there’s some real value in this over the long-run. When I was a kid, most “real-world computing” was done on green-screen Unix terminals or DOS PCs. Throughout my educational and early professional career, getting my work done required me to interact with multiple Unices, VAX VMS, multiple DOSes, MacOS (classic and OSX), and Windows (9.x & NT) – and that’s only before I went into IT.

There’s no telling what sort of as-of-yet-unimagined computing paradigms your child will be faced with in the decades to come. If you want them to be prepared, teaching them that a computer can look and act in a variety of ways is a good start.

Real insight into how computers work

When I learned Windows, I learned how Windows works. When I learned Linux, I learned how an operating system works. Yes, even in 2013, being an avid and regular Linux user may require you to dig into the guts of the system and learn about things like kernels, software libraries, GPUs, or how to write a script. Many see this as a weakness, but as a parent with an educational mindset, I see it as an opportunity.

Even when things are working fine, GNU/Linux is just a system that encourages exploration and discovery; there are no proprietary patented secrets locked away in encrypted binary files. The community encourages this too, and asking a few questions about how something works will usually get you several detailed responses.

Better performance

No, Ubuntu’s latest flagship release will not run faster than Windows XP SP1 on a ten-year-old computer. But there are distros that will, without a doubt; and unlike your old copy of XP Home first edition, they’re full-featured operating systems, fully-patched and fully-supported with modern apps readily available.

My wife currently runs the latest Kubuntu LTS on a Vista-era laptop; it’s smooth and quick, much more so than the now six-year-old OS that came with the device. My kids run Ubuntu and Kubuntu on stock Dell workstations (originally designed for XP SP3) without problems. In fact, none of the systems we use at home are less than five years old (some considerably older), and we typically have no problems running “heavyweight” desktop environments when we choose to. When a system can’t handle KDE or Unity, we switch it down to LXDE or XFCE and keep running.

I’ll let a system run an obsolete version of MacOS or Windows when I have to, but we never run outdated Linux. There’s never a need!

More consistency

You know how you go out and buy a new scanner, and it comes with bundled scanning software that’s totally different from the scanning software that came with your last scanner? Or the same scenario with your wireless card, printer, camera, optical drive, multimedia keyboard, or particle accelerator?

On Linux, there are built-in tools for this kind of thing that work with a wide range of supported peripherals. The upshot is that no matter how many times you go through hardware devices (we’re on like our 4th scanner in 10 years), you don’t have to learn new software. This is especially nice for kids.

Of course desktop environments change and evolve over time, but there is no shortage of conservative choices for those who want consistency first.

Simpler maintenance

If you’ve never touched Linux before, I’ll grant you the idea of doing maintenance on it can be daunting. But it’s really, really simple once you get the hang of it (i.e. once you get past the OMG IT’S NOTHING LIKE WINDOWS stage). Keep the packages updated, clear out the old kernels and package cache, and that’s about it⁴. No defragging, no antivirus/antimalware updates or scans, no calling the OS vendor to re-activate because the OS suddenly decides it’s not legal anymore⁵.

The package manager thing is really the killer feature here. I don’t have to go to all our half-a-dozen machines and figure out whose Java or Flash or browser is out-of-date and needs patching. I just run a package manager update and BAM! done. I can schedule it even. It won’t even nag you to reboot every ten minutes because the web browser was updated (yeah I’m looking at you Internet Explorer).

Ready to go?

At this point you’re either champing at the bit to start installing Linux on your child’s computer, or ready to run screaming the other way. If you’re in the first catagory, the next article in this series will look at some of the distributions and software available for kids, with some personal input from my own experiences.

Footnotes:

¹ Sometimes you can get them to work in WINE, but in general I find WINE too inconsistent to be a practical solution.

² Yes, there are many, many arguments one could make against this point, and I very likely personally agree with yours. But I list it because it’s a common objection whenever people talk about giving non-Windows computers to kids. In any case, if your goal as a parent is to teach your child about desktop computers as they’re normally used by most people, installing anything but Windows won’t help you achieve it.

³ Yes, I know that people say malware may come to Linux someday, or that Linux systems can be hacked. But to suggest that Linux distros are (or will be, in the foreseeable future) threatened with malware in the same way that Windows systems are is just not reality. You can argue about hypothetical situations all you want, but I personally don’t live in a hypothetical world.

⁴ If that sounds complicated, it comes down to a few clicks in a GUI application, or 3-4 commands in a terminal, whichever you prefer.

⁵ Yes, I’ve had to do this. Multiple times.

Replacing Windows 98, and other seemingly impossible tasks

Alan — Sat, 15 Dec 2012 05:42:00 +0000

Sometime during the last decade, I managed to get a reputation as the guy to whom you can donate your old, dusty computer when you don’t want it any more; and while I must confess that I don’t mind in the least (keep it coming folks – I do have a major weakness for free computer hardware, as well as a profound satisfaction in making “trash” useful again), it’s often a challenge to actually make use of a lot of it.

The idea, always in the back of my head, is to use a combination of spare parts, technical know-how, and a whole heap of open-source goodness to turn these doorstops into something useful for a family, child, non-profit, or other deserving individual who can’t afford a computer; simultaneously helping a person in need and keeping a functioning device out of the landfill. That’s the theory.

Making this reality is harder than it sounds; I’m admittedly better at working with tech than connecting with people, especially people who actually need a computer badly enough to use one of my Franken-modded antiques. So here I sit, with a small but growing collection of mostly pristine, fully-functioning computers that are just as capable of computing as they were when they sat next to the box of AOL CDROMS in CompUSA proudly displaying the pipes screensaver beneath signs assuring us they were “Y2K Ready”.

OLD. I mean OLD

I always get a little chuckle when I see someone on a Linux forum proudly talking about how he revitalized his ancient desktop – maybe a Pentium D with only 2 GB of RAM! – using Lubuntu or Xubuntu or somesuch. OK, so, good for them; I guess I’m showing my age, but it’s hard to think of a system less than 7 years old as “ancient”. To me, “ancient” means (at least) a beige box with a floppy drive and turbo button. Remember when the only thing “Giga” was the voltage required to power the flux capacitor?

But nostalgia aside, my real issue is that I’m awash in machines that were all designed for Windows 98; and if my experiences are indicative, the world is itself awash in these machines. They sit in basements, attics, spare bedrooms, and closets all over America, just waiting to be improperly disposed of. In case you weren’t alive or old enough to care 15 years ago when Windows 98 was all the rage, let me give you an idea of the average specs of a Windows 98 computer:

Processor: Pentium II or AMD K6-2, 350 MHz to 800 MHz
RAM: PC-100 or PC-133 SDRAM, 64 or 128 Mb on average. Maybe 256 if you’re lucky.
Hard Drive: 6 Gb to 20 Gb IDE drive, though 4 GB not unheard of.
Video Chip: 2, 4, or 8 Mb Video card made by someone like SiS, S3, Via, or Matrox who has long since found more profitable pursuits.
Drives: 3.5″ floppy and a CDROM (non-writer).

Those may seem like laughable specs to some of you kids out there, but I can assure you that great things were done on such machines (and certainly, on much older machines as well) once upon a time. On such machines I made music, discovered the Internet, published newsletters, wrote term papers, learned to code, and wasted untold chunks of life playing Age of Empires.

Windows 98

In 2003 when I started working in tech support, our network (even that late) was about 50% Windows 98 machines. I learned to hate Windows 98 very quickly. I could write books on what I found to hate about Windows 98, but in a nutshell it seemed to me that it had been designed to self-destruct about once every six months if used for anything more than playing solitaire or running Word. I was overjoyed when we finally instituted a policy of “Windows XP or we confiscate your network cable”.

This is probably a large part of the reason I feel compelled, when one of my newly-acquired “treasures” presents the Windows 98 boot-splash, to immediately DBAN the hard drive and install… anything else.

The problem lately has been coming up with an “anything else” whose overall superiority and fitness I can assert with genuine honesty. For all its many, many, many failings in a modern context, Windows 98 (I must admit) does a pretty admirable job of making a Pentium II with 64 Mb of RAM into a usable desktop. There’s no lack of applications out there for it, if you know where to find them. So I swallow my FLOSS-loving pride and start to wonder… maybe I’m doing a disservice to the potential inheritor of this device by removing it? Hrmmm… let’s think logically.

Good things about Windows 98:

People know how to use it. Well, old people, anyway.
It runs pretty well on these machines.
Lots of old-but-still-useful software out there for it.
It says “Windows” and that seems to make people happy. Or at least not scared.

Bad things about Windows 98:

Old, dead, unsupported OS. Kind of smells a little bad.
Once the target of malware authors everywhere, may still be at significant risk.
No security whatsoever. Like, NONE. Not even a little.
Comes with old, horrid versions of IE and Outlook Express that users might be tempted to use.
Can’t update it any more; Windows Update won’t talk to it any more, so you can’t even get it to the level of semi-bug-fixedness that it had in its heyday.
Requires a license key, which probably got lost with the install media or ripped off the chassis ten years ago.
It’s Microsoft. OK, sorry, fanboy moment, but Microsoft products (with the exception of Age of Empires sequels and spinoffs) just give me an icky feeling.
It’s the easy way out…

So I’ve grabbed one of my latest acquisitions – a Compaq Presario 5142 featuring a K6-2 processor, 64 Mb of RAM, and Windows 98 first edition – and I’m off to find a suitable alternative…

Save me, Tux!

Naturally, we start with Linux, and since every third distro in existence claims to be a “lightweight distro for older computers”, it would seem this is just too easy. The problem is that the vast majority of these distros are basically Debian, Ubuntu, or Arch Linux with a ~~feature-poor~~ lightweight window manager and Abiword. Not that these are all bad; they’ll make your new hardware fly like an iced cannonball, your last computer run almost-like-new, and your second-hand netbook tolerably usable. But on that double-digits-old beige box from the Clinton administration? Your average Ubuntu respin won’t even boot; even if they do, running modern Xorg on 64 Mb of RAM is miserable.

This is where we have to get into really light distros like Tinycore, Slitaz, and Puppy. I tried these three on the Compaq, and here are the results:

TinyCore (Coreplus 4.7) boots, and boots fast. It gives me a desktop, and it’s pretty snappy – even running from the CD. Unfortunately it ships with no actual software. This might not be a problem if the system had a network card, so maybe some sort of tinycore-based solution might be the ticket; in the meantime, it’s just nice to know it works.
Slitaz (v 4.0) has more features, but I couldn’t get X11 to start. Maybe I need the “loram” variety, but I was running out of blank CDs and the Compaq won’t boot from USB.
Puppy (Wary 5.3) actually booted and gave me a desktop; and unlike the others, it ships with a decent selection of local applications that could actually constitute a useful system out-of-the-box. Now, I’ve never been a Puppy Linux fan for two reasons: (1) I always thought the overall look and feel of the OS and included tools was just ugly, and (2) the whole log-in-as-root thing. However, compared to Windows 98, it seems not so bad in either respect. Unfortunately, I’d be lying if I said it performed better than Windows 98 on the Compaq. Even installed to the hard drive (full install), it was choppy and sluggish; and when I made the mistake of clicking the browser icon (possibly moot because, like I said, no Internet), the system just ground the hard drive for about 5 minutes before I finally gave up and pulled the plug.

Try some Haiku-fu?

Haiku OS, if you haven’t heard of it, is a project designed to recreate BeOS, an OS from the late 90′s that was designed from the ground-up for great multimedia support. Haiku is completely open-source, not in the least bit Linux, and totally designed to be a desktop OS (as opposed to a server, super-computer, phone, embedded device, toaster OS). It’s also pretty fast and lightweight on older systems.

Haiku isn’t really done yet; it lacks a lot of things, though it does have a fairly functional WebKit-based browser, a media player of sorts, an email client, and some games (mostly ported from Linux), so it’s not entirely useless. It’s also compatible with all those BeOS programs you bought back in the day when… oh, you weren’t one of those five people? Pity.

Development is a little slow right now, with alphas being released about once every 12-18 months; I predict it will hit a stable release just as desktop computers are being obsoleted by sentient robots and cybernetic implants. The alphas have been reasonably stable, at least…

I’d like to say I’ve revived the old K6-2 system using Haiku, but so far I can’t even get the disc to boot. I end up with a lot of disc activity, but nothing to show except a set of color bars in the upper left corner of the screen. In fact, this is what I get on pretty much any system of that vintage with Haiku. To be fair, Haiku is still in Alpha, and probably (hopefully?) targets newer and better hardware; but in any case, it doesn’t seem to be an option here.

Hola, Amiga!

On the topic of open-source remakes of long-gone desktop operating systems, there is always the possibility of AROS working on these boxes. AROS is a remake of the Amiga operating system, and with a bit of m68k cpu emulation it can run all your classic Amiga software. Icaros is probably the leading distribution of this OS, and I’ve checked it out in the past.

Although the Amiga was a good generation or three before Windows 98 came along, and its pricing made it something of a niche product, access to the Amiga software catalog is still a compelling enough asset. The AROS community has also ported over a number of FOSS projects and produced a few original apps of its own. So AROS could be quite a contender if the performance is comparable.

On the Compaq, the Icaros boot CD started off in a promising way, and brought me to what looked like a desktop at least as quickly as Windows 98 did from hard disk. Unfortunately, what “looked like a desktop” was actually frozen up and not functional, so I couldn’t even get as far as installing it. Perhaps I’ll have to try on some different hardware…

Syllable

Syllable OS is another FLOSS OS aimed squarely at desktop usage; it takes inspiration from Amiga and BeOS, but is not a recreation of either. It’s a totally new OS with its roots in AtheOS. Its minimum hardware specs are a lowly Pentium I with 32 MB of RAM (!), so it’s clearly a candidate for replacing Windows 98!

Syllable has a live CD, which is (annoyingly) both separate from and a version behind the actual installer CD. I chose the live CD for testing on my K6-2 system; this may have been a mistake, as – while I could boot very quickly to a Syllable desktop – attempting to run just about anything resulted in an unresponsive system.

Syllable may well bear further scrutiny; there’s some promising working being done on it, such as a recent port of Enlightenment Desktop Environment. What leaves me uninspired at the moment is an almost complete lack of actual software for the system. There’s a (WebKit) web browser, of course; and a text editor, some games ported from Linux, and a few random utilities. That’s about it as far as I can tell. Nothing that really screams “Wipe your Hard Drive now and install ME!!”

Uno DOS?

Contrary to popular belief, DOS is not dead! The FreeDOS project has kept it going, creating a 100% open-source DOS fully compatible with the MSDOS 6.x. The main distribution even ships with a load of software (much of it ported from *nix, like Emacs and Vim) as well as the OpenGEM desktop environment – a desktop famously shipped with the Atari ST, which is great [for understanding why Atari failed in the desktop computing market]. There are a few projects aiming to give FreeDOS a more attractive and modern GUI, such as LightDOS and DOSCore; but none of them appear to be distributing a stable product just yet.

Full DOS compatibility gives you the ability to run the virtual treasure trove of classic DOS games and… and… er… whatever else you can think of that might make resurrecting DOS worthwhile.

But just think – if we could give these machines a DOS kernel and a decently familiar desktop environment that didn’t look 8-bit, we’d almost have… oh nuts.. Windows 98. Except without the Windows compatibility part. But at least it’d be open source?

Odds and ends…

This is certainly not the end of the list of small desktop operating systems, so here’s a few more potential candidates that I haven’t gotten around to yet, or probably won’t get around to until there’s a major project update:

Minix, BSD, Darwin, and other unix-likes: Some of these systems promise to be faster and smaller than Linux, but so far they all involve a far more complex install and offer a subset of the desktop-oriented stuff for Linux. When I’m in the mood to learn yet another packaging-system-that-we-assure-you-is-better-than-APT, and when I see anything that indicates these systems might perform better that Linux on teenage hardware, I’ll get around to testing some of them.
Your favorite lightweight Linux: Yeah, there are more than three lightweight Linux distributions out there; I could spend a million years testing them all. If you can tell me that you genuinely revived a Windows 98 machine – not a Pentium 4 with 1 Gb of RAM, or even an Athlon with 512 Mb, but a real honest-to-Jakers Windows 98 machine – with distro XYZ, please let me know.
Menuet and KolibriOS: these two OS, one is a fork of the other, are both written in assembly and fit on a floppy. They’re brilliantly fast, surprisingly nice for their size, and utterly devoid of any useful applications that would make them worth running for more than the time it takes to admire how much can be done in 1.44 megabytes if only developers didn’t need silly nonsense like high-level languages.
Android for x86: Now this might be something, if it could work on such old hardware and run android apps. People could use that. I haven’t had a chance to test it, but it seems the downloadable ISOs are hardware-specific. Not sure I’m committed enough to compile the OS for K6-2.
ReactOS: This would be an interesting choice, if it were more stable and developed. ReactOS is aiming to be a fully Windows-compatible OS, so this would take care of the software catalog issue. Not sure if it promises performance on old hardware at this point, though.

What have we learned today, kids?

The goal of my quest was to find an operating system compelling enough to install over Windows 98 on old hardware, bringing the potential owner of the system both into the twenty-first century and the world of open source software. While working alternatives exist, nothing has yet raised its hand and twisted in its seat like a third-grader who needs a bathroom break to say “hey, install this!”. Even so, there are some valuable insights to be gained from this experience:

Desktops are easy. Applications are hard.: Building an OS that will boot to a desktop on old hardware is apparently quite doable for free software developers. Stocking said OS with genuinely useful applications is, on the other hand, a monumental work that typically takes many developers many years. Making these useful applications run on minimal hardware is even more monumental.
Hardware support is the bane of all alternative OS: It’s not just Linux, folks; any time you run [Not Windows] on a machine designed for Windows, hardware support becomes a problem.
There is nothing simple about web browsing: People talk about “simple web browsing” as though surfing the web is akin to editing ASCII text or doing arithmetic. Browsing the modern web, with all its CSS, HTML5, JavaScript, images, and multimedia content is not simple. Just launching a modern browser sends a Pentium II-era cpu into hysterics, never mind rendering an actual page. Computers may have been browsing the web for almost 20 years, but this isn’t 1995′s web. Fortunately, though…
Everyone has a WebKit browser: Basically, you’re not an OS if you don’t.
We used to be a lot more patient: I said Windows 98 ran admirably on this old hardware, but that’s only in comparison to other (more modern) things I’ve tried. Truthfully, it amazes me how slow it is to boot and launch large programs. It brought back vague recollections of recording some tracks years back at a friend’s studio running Cubase on a Pentium II with Windows 98; every so often the system would lock and we’d have to reboot, which meant coffee break time (I don’t mean “refill your mug and get back to work” coffee break; more like, “start brewing a pot of coffee, have a nice chat while it brewed, pour everyone a cup, make tea for the guy who didn’t drink coffee, let the guy who didn’t drink coffee or tea run to the quickie-mart for a coke, drink beverages while having a nice chat, take bathroom breaks, and then go back and find the computer was almost done booting” coffee break).
Computers actually are doing more for us: You know those people who say things like “Computers are a zillion times more powerful now but don’t run any faster or do any more than they used to”? Those people are wrong. It turns out that at some point between the time you were jammin’ Stone Temple Pilots in your Doc Martins and the time you were watching American Idol in your Snuggie, your computer started managing your collection of 20 megapixel photos and 320 kbps MP3 files, rendering media-rich web pages, and playing full-screen 1080p movies from Hulu. Somewhere along the way, you started expecting it to boot in under a minute and load programs in under two seconds. It turns out that “using a computer” has steadily been redefined as a task that requires some major computing horsepower, and those old systems – even running the OS they were designed for – can’t keep up.

Even with all these unfortunate realities, I still have to believe there is a way to make these systems useful to somebody. I still see some possibilities, at least for a machine with more than the average amount of RAM. The really truly exciting options still seem a little beyond the horizon, but perhaps someday, before their disks lock up and capacitors corrode, these machines may find a way to be useful again. Your ideas are welcome…

Thought bucket

Better window splitting in Emacs

WCGBrowser update: http_proxy and more

Porteus

The scenario

Hardware

Software

Porteus

Brief overview

Apps and desktop

Noteworthy features

Porteus package manager

PXE server boot option

Run from RAM

Performance on my hardware

Conclusions

Building a Linux system for a Child, part 4: a wishlist

Better Parental Controls

More stories

Multimedia and better artwork

More literature, history, and humanities

More special needs software

What about you?

Footnotes:

Five reasons why I choose PostgreSQL

Elegant SQL syntax

Many useful data types

Arrays

Stored procedures: pick your language

Excellent clients

The Perfect database?

Footnotes:

Building a Linux system for a Child, part 3: Security concerns

Parental Controls, filtering, etc

Web content filtering

Time restrictions

Application restrictions

Do we need Parental Controls?

Network access outside the browser

Potentially offensive stuff

Root access?

Conclusion

Footnotes:

From PHP to Python: things I wish I’d known

The story so far…

What “they” say

What is PHP anyway?

A templating system

A framework

Bad, but no so bad

What is Python, and how do you build a web application with it?

Python Web Frameworks

mod_python and python server pages

Django

CherryPy

Flask

Python Templating systems

Some general notions you need to get familiar with

The web page is not STDOUT

Routing

HTTP

MVC

Planning and design

Downsides to Python

Deployment

Database access

Application focus

Python 2/3

Do you need to switch?

Footnotes:

Building a Linux system for a Child, part2: Distros and software

Ready-made distributions for kids

DouDouLinux

Qimo

SkoleLinux

Edubuntu

Are ready made distributions worth it?

General purpose distributions

Software for kids

Recommended for young children (pre-k through 2nd grade)