Slashdot Mirror

Heck, I know folks who've lost entire well-known (hobbyist) web-portals some years back due to provider server failures. It was a harsh lesson for those involved. So much for the provider's backup policies. The real solution is to have multiple copies of the data, ideally in different formats. For example, when I was in grad school the University had (for the time) a huge email installation, basically full email hosting for the entire institution. The server and storage spec was excellent -- a big SAN-like dual storage array that could handle failures at multiple levels, including one entire half of the storage system. Turns out they got hit by a nasty filesystem corruption bug, which nuked the whole array. Oops. Their bacon was saved because they also had regular verified tape backups (IIRC, it took many, many weeks to fully restore archived mail to the cluster).

These problems really have little to do with the computing models involved. There's a misperception that the "cloud" provides some sort of data robustness beyond what mere mortals can accomplish, but the reality is that valuable data just needs more copies. Perhaps their backup strategies are layered and awesome, but you never really know where the weak links are. One remote service provider really only ever counts as one copy. And so it's useful to consider a service like GitHub. The fundamental model of the service is to encourage folks to share and copy their data around, because that's a prime goal of the supporting software: git. If a git-based service goes down, there should be many copies of the repository data, and the various users will regroup, republish, and move on. No single user has to be overly conscious of maintaining lots of backups, because copying is the basic working model.

There's a lesson there for those of us working in software: design for subversive backup, where critical data is backed up/synced/secured as a normal part of day-to-day workflow. Make sure that failure in any one point doesn't induce the others to similarly fail or become corrupt. Think through and verify the recovery schemes. Imagine that it's your data going down the tubes...

This is a response to these other postings.

Somebody asked this question on reddit
http://www.reddit.com/r/programming/comments/9s3ww/would_you_hire_a_programmer_that_does_not_write/

A while ago my company interviewed someone who, in the course of some standard question, said that after the 5 o'clock whistle blows, they avoid computers totally. They don't have any hobbies involving their PC and often don't turn it on unless they are expecting an important email or need to look up directions. I followed up to ask how they got into programming and they said they took the right courses in college and now has had a few jobs doing it.

Would you hire a software engineer who isn't a hobbyist programmer? What if they avoid computers totally at home? Does it matter if a candidate has strictly a professional interest in software and just pretends it doesn't exist outside the office?

And was answered with this:

http://github.com/raganwald/homoiconic/blob/master/2009-10-08/no_hire.md
No, I Wouldn't Hire a Programmer That Has No Interest in Programming Outside of Business Hours

Here's another way to frame this question: Would I even interview a programmer who only works their programming job from 9-5? If not, why not?

The answer is remarkably simple. No, I would not interview them, for the simple reason that I don't know who they are and they don't know who I am. When I am hiring, my first and best source of prospective colleagues is my network. Industry people I know. Where do I get to know people? Conferences. Open source. Blogging. Twitter. I don't advertise my job openings on monster.com. So how did this person come to sit in front of me to tell me he(?) pretends software doesn't exist outside of the office?

I think you have to align your values with your complete hiring process, not just with your interview questions. If you value people who are passionate about their craft, you have to use a different means of selecting prospects than if you value having warm bodies sitting in chairs. If you want a warm body with a certain minimal competence in a chair, you use monster.com and recruiters to find people. if you value community and craft, you use your network and your community.

Done this way, questions like the above tend to take care of themselves.

I just bought a terabyte drive for $100 to back up the other terabyte drive I bought several months ago for $160. Now everything is backed up in multiple. And I can access it without getting online. And I don't have to worry about my cloud storage company going out of business and taking all my data with it.

And if your house burns down, you're screwed.

I want a way to get cheap, fully-automated, redundant, off-site backups.

I want it badly enough, that I'm building a solution myself, based on the allmydata.org Tahoe distributed file system.

Backups over the typical home user cable modem or ADSL line are guaranteed to be very time-consuming. As a partial solution, my system will do incremental rsync-style deltas (the infrastructure is in place now, but I want to build more confidence in the non-differential backups before turning on diffs), but even with that, large volumes of data just plain take a long time to move. My backup has been running for three weeks and it has about two months to go.

What's the point? Well, this data is important enough that if I have to wait a while to restore it, I'm okay with that. And restore will be much faster. Because of the way the underlying distributed file system works, downloads are "swarming", coming from multiple machines at once, so even though all of the machines my data is backed up to also have slow upstream connections, the aggregate can fill a big chunk of my incoming pipe, which is 18 times faster than my upstream data rate. If I could fill the whole thing, then, a three-month backup should take just five days to restore. I haven't yet to see how long it really takes.

And I think there's a lot of value to it, especially if you use a distributed VCS, like git or mercurial.

In fact, I've even set up a github project that tracks the US Code. I have a small Python script that retrieves the entirety of the code from uscode.house.gov and extracts and organizes the titles. There's a cron job that runs this process daily and commits any changes to the local repository, then pushes them to github. So you can use the github project to track the changes that are delivered into the final version of the law.

CivX has scraped the wayback machine of uscode.house.gov and has changesets from all the way back to the dawn of time.

Hence the idea of using a version control system, to be able to read side-by-side the law before and after the bill.

This allows you to look at the diffs after they become law, not before, but it demonstrates the idea.

http://github.com/divegeek/uscode

nice to hear of universe between your ears, where it's 1999. outside of that, in real world use, Perl has plummeted in use in last five years, from third most widely used language to eleventh. the language has stagnated and any Perl creative effort being wasted on the undead Perl 6.

Nice to hear of the universe between your ears, where it's a fantasy island that you created yourself. Perl is the 5th most popular language on Github (and Ruby doesn't count because Engine Yard give Ruby guys free accounts). And Perl 5 and Perl 6 development are happening very separately, one of Rakudo's lead devs said a month or two ago that if they (personally) weren't working on Perl 6 they wouldn't be working on anything in the Perl community.

And I think there's a lot of value to it, especially if you use a distributed VCS, like git or mercurial.

In fact, I've even set up a github project that tracks the US Code. I have a small Python script that retrieves the entirety of the code from uscode.house.gov and extracts and organizes the titles. There's a cron job that runs this process daily and commits any changes to the local repository, then pushes them to github. So you can use the github project to track the changes that are delivered into the final version of the law.

Where this gets really interesting, though, is if you use the DVCS in the process of crafting the law, not just to store it and track changes. The README file at the top directory of my github project describes some ideas. I have some more ideas about how the whole thing could be integrated with a sort of legislative social networking site, like github or launchpad, but with some important differences, and much more user-friendly. Here's the content of the README:

This repository contains the complete United States Code. Its purpose is to publish the federal code in a way that makes it easy for interested individuals to access both its content and its changes over time.

Another purpose for this repository is to explore some ideas around how to better facilitate the legislative process. Legislation comes in the form of bills which are essentially patches to the existing legal code. Many different versions of a patch may float around to be debated, discussed, amended, etc., before a final version is applied to the "trunk". The process is extremely similar to how developers manage software changes, particularly in the open source world.

I think it would be very cool if something like github were used to manage the actual law, all in the open and fully visible to everyone. I imagine the official code as sort of a master repository. Each legislator could fork this repository and hack on his own copy. Legislators could pull from one another as they massage the language to get it right. The House and Senate would each have their own forks, as would the committees. The president, too would have a fork of the official repository.

The legislative process would then be fully visible to anyone who cares to look. Congressman Blowhard commits a change to his code and pushes it to the public fork. Congressman Slick looks at it, likes it, pulls, commits a change and tells Blowhard about his change, etc. Eventually, the bill makes it to committee, and the committee may have several branches indicating the status of bills as they progress through the committee. Eventually, if the bill is voted for presentation to the House, it is pulled into the committee's "trunk".

If the House votes to approve the bill, then it's pulled to the House's trunk, available to be pulled by the Senate. The Senate can make its own modifications, and perhaps the result must pass through a House/Senate reconciliation committee, before being pushed to the "Passed" branch (or fork), with a message to the president.

Anyway, that's the idea. It may seem kind of silly, but if you've ever actually tried to track the progress of a bill through the existing web interfaces, it's horribly difficult, and there's a lot of information about the bill's movement through the process that simply isn't available. I think using revision management tools just might make the whole process both easier and more transparent.

And that's what I want to play with.

I fully recognize that many legislators may not WANT the sort of transparency that the system would facilitate, but I think that there are a crop of young reformers every year who would embrace it, and in another decade the "facebook generation" will start entering the legislative halls in a big way. It would take a long time to get something like this incorporated into the process, but the result would be a great improvement to our republic.

For lols (and wtfs), take a look at http://github.com/domdorn/Jake/raw/master/generateDao.sh
It generates Java proxy code using Bash and Python :-) quick-and-dirty ... very dirty.

If your Safari doesn't have AdBlock, install it: http://burgersoftware.com/en/safariadblock
(32-bit for now...source available)

I also recommend ClickToFlash: http://rentzsch.github.com/clicktoflash/

it does is not help you in determining *what* should be done in parallel.

I'd disagree slightly on that point; agreed, the technology doesn't actually make certain code blocks suddenly go "me! me! me!" but it does significantly ease the burden on the developer in making those decisions. I can throw something into the parallelization engine with a couple lines of code to see what difference that makes.

The key example would be something like this one here, which Slashdot's filter doesn't like (it says please don't use so many junk characters, bah).

That's a nice and simple change to make, and is easy to drop into any code which previously required synchronous execution. I can just wrap the existing synchronous code in two calls to dispatch_async(), one to throw stuff onto the background thread, and another to throw the last step back onto the foreground thread. If it doesn't help the program I can remove it. If it does help, I can leave it in.

HR3200 considered by a software designer with no concept of how legislation works, aka: how to get my rant about HR3200 posted on Slashdot by superficially comparing it to software.

Sweet. I wanna do that, too. In fact, I tried. I wrote up a spoof trouble ticket for the U.S. government Trac site. It had comments from harryt84, bigdog, ggrinch; there were commit notes from hillaryrc; and it even included abusive ticket spam from rushl. Several of the comments were dated to match historical events. It was a satirical civic lesson written in the curt, pompous tone of an open bug tracker. It was beautiful. I tried to post it.

And. fucking. slashdot. would. not. accept. it. It complained that my lines were too short. When I finally worked through their lame heuristic[1] (which, incidentally, is either buggy or deceptive), I found that the comment formatting was unacceptable. Can't we have a <pre> tag? Anyway, what's the point of slashdot if you can't post cutesy trash?

So... to answer your comment: Yes, slashdot should be the forum for self-indulgent ranting about techno-political conceits, but, today, technical limitations hobbled the attempt of at least one slashdot whizkid to partake in the ritualized sophomoric political discourse.

GBCW, etc., etc.

1. A version of the spam heuristic is at github. Note the substr() call. Odd. Why did I notice this code? Wrong question. Right question: Will I ever get back the time that I spent researching the slashcode project.

</breakdown>

Isnt the Smoke library a good starting point for your effort?

I havent worked with either, however it sounds (http://www.kdedevelopers.org/node/427) quite interesting in its goals. I am speculating that Smoke was never seriously used for Python (instead it focussed on Ruby), because of the momentum behind PyQT.

However, given that it can interoperate with any scripting language (http://techbase.kde.org/Development/Languages/Smoke) - isn't it a good starting point ?

http://github.com/thephred/kdebindings/tree/35ba8e5eac62b1e7ab52ac439ea158963ece089b/smoke

More python apis would be great. If they followed PEP-8, even better.

Describing PyQt as "C++ without the segfaults" is only partially true, though. I've segfaulted the latest PyQt4 (by accident, of course), and it's not too hard to make it happen in different parts of the Qt4 api if you're not too careful.

See, for example:
http://github.com/davvid/git-cola/commit/944ca1252f2f5e6bbd17f8a6fc4718144138bd26

Undo that commit and you, too, can segfault PyQt4 4.5 ;-)

For the curious, there was a change in behavior between PyQt4 4.{3,4} and 4.5. Older versions coped with the original code without a problem. Fedora 11 users reported the problem; my debian install wasn't tickling the bug (probably cos my lib was too old?)

If pyside can help me do away with these workarounds then I'll be quite pleased.

Right now I'm even carrying around setup.py compatibility hacks for older versions of 'pyuic4' that shipped without a proper shebang line. Grr.

I'm sure porting to pyside's going to suck, but if I get a more stable lib then it's worth it. Until they've proven themselves, though, I'll have to deal with the hacks/workarounds[*].

The python guys came up with a py2to3 script for going from python2 to python3. If pyside can come up with a similar script for PyQt4 to pyside then they'll have an easier time winning over existing PyQt4 users.

BTW did anyone else wonder about the name? WTF is pyside? The FAQ doesn't even mention why it has that name.

[*] I know I'll be waiting a bit, though, since Mac and Win support aren't the top item on the pyside todo list a.t.m.

3) how is your browser going to access a Database like mysql with php, local on your machine? The pages would have to be cached and static or some other wizard way of doing it.

There's nothing that limits reversehttp to the browser. Any HTTP client library can use it. The demo implementation has clients not just for browser-hosted Javascript but also for Python and Java. Besides the clients included with the demo implementation, Paul Jones has written hookout, for Ruby programs, and Tatsuhiko Miyagawa has written AnyEvent-ReverseHTTP for exposing HTTP services via reversehttp from programs written in Perl.

Test drive your javascript development. Check out jasmine. Safari's inspector is no firefox/firebug, but it gets the job done.

Hi, I am working on an OpenCL implementation sponsored by google summer of code. It is nearly done supporting the CPU and the Cell processor. This news has come to as a blow to me. I have struggled so much with my open source project and now a big company is going to come and trample all over me. boo hoo. http://github.com/pcpratts/gcc_opencl/tree/master

Not sure about PHP, but when you make such comparisons between RoR and Perl solutions you should at least be aware of recent developments such as the Catalyst framework.

Not to mention things such as perl5i which tries to aggregate most of what is known as modern Perl.

Perl is an evolving language and Perl code from 8 years is very different from modern Perl code.

My conclusion so far: it's very unlikely not to be co2 responsible for most of the warming we've observed since the 70s, it's likely to get much worse, and there don't seem to be any viable alternative explanations.

There is also a KDE alternative, Kobby: http://greghaynes.github.com/kobby/ Both Kobby and Gobby can work together.

There are three kinds of data:

1. If you lose this data you will go to jail.

2. If you lose this data, your business will be impacted.

3. If you lose this data, you will have less options for entertainment.

True for business use, but for home users there's another category:

1.5. If you lose this data, you'll have lost irreplaceable records of important life events.

Much of my kids' lives is chronicled in bits stored on hard drives. Photos, video, school work (you might be surprised how interesting a 4th grade paper can be years later), etc. This data is significantly more important to me than business data, and there are many gigabytes.

My solution is peer-to-peer backup. Most everyone has extra disk space they're not using, and if they don't, well, a 1TB drive is $60 on newegg. So, I've set up a "storage grid" with my family members using the allmydata.org Tahoe network. Tahoe encrypts every file with 128-bit AES, splits each via Reed-Solomon encoding into six pieces, any three of which are sufficient to restore the file, and spreads those pieces around other machines, all of which are off-site.

Because Tahoe's backup facilities are a little primitive, I'm writing my own backup solution, called GridBackup, which separates file change detection and upload, because upload is inherently slow on typical ADSL/Cable Internet connections. GridBackup also compresses whatever can be compressed and uses rsync-style signatures and deltas to upload diffs for small file changes. Uploading is done in priority order, where the default priority algorithm favors user files over system files, small files over large files (on the theory that if you have to pick, it's better to back up many small files than a few large ones), and recently-modified files over long-unchanged files (on the theory that long-unchanged files are likely to stay unchanged for a while longer).

The 'primary' version is a bookmarklet (they built a Firefox plugin because the Firefox file save dialog won't accept a nice filename for the torrent). The core functionality is 250 lines (sort of, much of it is whitespace or other noise):

http://github.com/mnutt/hid.im/blob/ce9750f16c2e12f8f93e97ea7f73edb0e302b22e/public/javascripts/read_png.js

So I would think that the availability of tools will be pretty good if the concept catches on much.

There's a Zenoss/Puppet integration here: http://github.com/mamba/puppet-zenoss/tree/master

Good to see that I'm not the only one hearing that whining noise. It usually only occurs after I resume from suspend.

I agree with you about the declining quality of Lenovo's products but the SL series isn't too bad though if you consider the price point. For $1250AUD ($1006USD) I got the SL500 with Nvidia 9300 and C2D P8600 @2.4GHz. Which isn't too bad since it still has better build quality than most of the competition at that price range. It's a bit too thick and bulky and the battery life is bad compared to better Thinkpads.

One thing that anoys me is that Lenovo decided to use different firmware for the SL series. They used the IdeaPad firmware, which is lacking in Linux compatabiliy. The normal thinkpad_acpi module doesn't work with it, and the special keys don't work. Though luckily someone has made one for them. A nice how-to here for anyone who has any SLX00 laptop with Linux.

I don't regret buying it, way better than my old Acer 3680.

What system do you use to manage your home directories, and how have they worked for you for managing small files (e.g. dot configs) and large (gigabyte binaries of data) together?

I don't know that managing them *together* is all that useful. What I have been doing (and what I think is a more flexible way to manage stuff), is to divide the stuff in your home directory into independent 'projects' (e.g. financial documents, stuff for work, source code of my website, project X, project Y, my photo collection...) and manage each project separately in a way that lends itself well to the kind of file being stored. For a directory of small files that are frequently updated, Git is a great way to go. For synchronizing and backing up large collections of large files (like an MP3 or photo collection) you might try something like ContentCouch (disclaimer: I wrote this tool).

The main problem here is, yes, people do learn by doing the exact same problems. Sometimes it's boring, like a quicksort; sometimes it's cool, like Ruby Koans, but at the very least, no one learns to program without learning Hello World.

Yes, at a certain point, it'd be cool to be doing new things, and sharing, and collaborating. But there is a reason the existing problems should be done, and sharing source code is pretty much like sharing an essay -- not good.

I might come a bit late to the party, but I'd like to say that I developed a free alternative to Google Search Appliance :
http://github.com/EricDuminil/picolena/tree/master

It's a small Ruby on Rails app (~1kLOC), uses either Ferret or Sphinx and implements full text search for .pdf, .doc, .docx, .odt, .xls, .ods, .ppt, .pptx, .odp, .rtf, .html, and metadata from music, pictures and videos.
It also includes language recognition, files thumbnailing and cache à la google.

We use it in our research center to index ~100 000 documents from 50 users on a Samba share, and we get relevant results in ~0.1s
Users don't need to learn any convention, they find what they want fast, and can use it as easily as Google.

If you're interested, drop me an email from Github.

I do think it would be very cool if legislators adopted source code management tools to manage the legal code. I think it would work very well, and would make the whole process much more visible to everyone. Imagine github for the legal code!

Hmm... Maybe I should download my state laws and publish them via github. Hmm.

So, typing the above inspired me to go do it.

I put the Utah and United States codes in repositories on github. Further, I have a cron job that re-downloads the current statutes daily, commits any changes and pushes them to the github repos.

Now I can easily tell when the law changes, and what changed, and so can anyone else who cares to watch my repositories. I wish there were an easy way to go grab older versions of the laws, but at least I'll have a change history going forward. I'm going to be interested to see what it looks like in a few years.

I do think it would be very cool if legislators adopted source code management tools to manage the legal code. I think it would work very well, and would make the whole process much more visible to everyone. Imagine github for the legal code!

Hmm... Maybe I should download my state laws and publish them via github. Hmm.

So, typing the above inspired me to go do it.

I put the Utah and United States codes in repositories on github. Further, I have a cron job that re-downloads the current statutes daily, commits any changes and pushes them to the github repos.

Now I can easily tell when the law changes, and what changed, and so can anyone else who cares to watch my repositories. I wish there were an easy way to go grab older versions of the laws, but at least I'll have a change history going forward. I'm going to be interested to see what it looks like in a few years.

I've got a Heathkit H19 dumb terminal on my desk that's hooked up to my MacMini via serial-to-USB converter.

I don't do a lot of "work" with it but I wrote a Ruby script for it to talk to iTunes via AppleScript and grab the album art then pass that through ImageMagick to bump the contrast then convert it to ASCII text using jp2a.

You can see some pictures: http://www.flickr.com/photos/drewish/tags/h19/
Or checkout the Ruby script: http://github.com/drewish/textFlow/tree/master

If this was an official/accepted definition, I would completely agree. In fact, if there was a standards committee that offered what you've written above as a proposal, I would back said proposal, if only so we could finally agree on the proper use of the term "branch".
This is not the case, however. Check out github and the terminology they use. If you use that site/service to manage your project, there's effectively no difference between a "fork" and a "branch". This is why I said this was perceptional, because really, it's like you said:
'you might as well call it a "fork" every time you edit a file'
In practice, on a mechanical level, it's exactly the same. This is why different people use "fork" in whatever context they choose.
I agree with your definition, but not everyone does.

Also, there are quite a few reasons why a proper "fork", not a "branch", would be beneficial. You could be leading a project, and one of the developers could decide to try a different approach, to a drastic extent. They would fork the codebase and start developing separately, to the point where there would be no way to merge his code with the main project. This new "subproject" could become a subset of the primary project, designed to deal with specific tasks.

At this point, the new code could remain under the same "roof", or that developer could opt to lead that fork independently. The difference between those two options would be great, but in the end they're both "forks", even by your definition (a new project is created, or "spawned").

In the end we're arguing semantics. I could choose to use your terminology, but I would have to preface what I mean whenever I do, so that people understand that when I say "fork", I specifically mean something that could not be merged back into the main project.

have to say, I'm glad of this trend lately for open source projects to primarily publish their source through Git, and particularly through these very able Git hosting sites like gitorious and github. If you've worked with CVS and SVN open-source projects most of your career, the experience is simply incomparable.

However, if you've worked with mercurial before, the experience is comparable - but not really favorably for Git.

It seems Git is this shiny thing every trend chaser is picking it up right now, but it has the overall feel of not really being ready yet. I'm glad it's having some serious competition right now, so it won't be the "obvious" choice like svn was for the previous generation. It's a mixed blessing - I'd really want us to have one obvious DVCS choice, but on the other hand I don't want it to be git as it is right now. And Git doesn't seem to be getting better fast enough, since the current users are familiar with its quirks and don't really mind that much.

I have to say, I'm glad of this trend lately for open source projects to primarily publish their source through Git, and particularly through these very able Git hosting sites like gitorious and github. If you've worked with CVS and SVN open-source projects most of your career, the experience is simply incomparable. With the way Git works, and particularly with the implementations the hosting companies provide, it's very easy to fork a project, make the changes you want, and always have the power to commit to a remote repository that not only keeps track of all your commits but ALSO how all your commits relate back to the original forked project...

Instead of downloading someone's tarball and (maybe) emailing them a diff (or just posting your own duplicate of their source with your little changes), it's like you're making a shadow copy of a projects source, where you have all the control but no information is duplicated or lost.

I prefer ClickToFlash to many of the other flash blockers for safari:

http://github.com/rentzsch/clicktoflash/tree/master

Many safari plugins use InputManager hacks to patch safari. That can be dangerous, and I don't have the time to really check which ones are safe and which ones aren't.

In contrast, I believe that ClickToFlash is just another web plugin (the same as flash itself). It is used instead of the normal flash plugin. It displays a plain grey box. When clicked on, that grey box loads the normal flash plugin. The result is a flash blocker that works in safari using standard APIs.

Main site

Demo site

Gitit is a wiki that uses a git repository as a backend and exports to LaTeX. I haven't used it myself, and I expect you'll have to do a bit of hand-editing of the generated LaTeX to match whatever template you're using, but it might be worth looking into.

It's sad really that those joypads have been out for so long and don't work out of the box, when the PS2 and PS3 ones do.

The problem is that Xorg added automatic configuration while not implementing any proper way to override it from the Xorg side. So its not the joypads drivers faults, its Xorg that is the guilty one, it will happily grab all the devices it can find and turn them into a mouse (aka making them unusable), a little HAL config file however can easily fix that permanently.

This is either due to a lack of Linux input standards,

/dev/input/eventX works perfectly fine, the trouble is that dpad comes in a numerous different variants of events, some gamepad have it as first and second axis, in some other it comes much later and thus in not recognized by the games since they only check first and second. Other gamepads report the dpad as buttons, which again doesn't work when the game is looking for an axis. And of course there is SDL, which will report the dpad sometimes as Hat, so even if you have config options for buttons and axis it will not work. If you use some PS2-to-USB adapter things can even more funny, since then two gamepads might end up registering as a single device. And then there is of course the whole deadzone issue, which will screw up some games as well. It happens almost never that a game properly handles all of these cases. This however really isn't a Linux-only problem, gamepads are totally fucked up on Windows as well (to properly use the Xbox360 pad on Windows you have to throw the official driver away and use a homebrew one and the chatpad isn't even support at all). In the end I think the only short time fix is to have an input driver that is actually configurable enough to handle all those situations, which is why I wrote one, its however right know limited to Firestorm pad and Xbox360 gamepads.

it's a lack of an update to the emulators to make them work with the Xinput standards if it actually is a standard.

I don't know any game that actually uses Xinput, most use either the old /dev/input/jsX directly, the new /dev/input/eventX or just a wrapper library like SDL. And just to add a bit of naming confusion, there are actually two Xinput, one is the Xorg input system and the other one is Microsoft new input system mainly used for Xbox360 controller I think, both however are completly unrelated.

If you like C++ and the Qt API and you want to develop for the web (true web 2.0 AJAX apps), you should try Wt.

Wt clones the Qt API but using Boost instead of Qt. You can compile your web application to a FastCGI module (which you can deploy with Apache, lighttpd, IIS, etc) or to an executable which includes an embedded HTTP(S) web server.

Oh, and there are Ruby bindings, too (code)

Oh, and best of all: you can link to any C and C++ library (including Qt). No more messing with Ruby/Python/PHP/whatever bindings!

A Ruby rails open source project might be just the ticket for you. Good project management tool, although it should also work for help desk: http://github.com/ari/clockingit/tree/master You can sign up for a free account on the hosted solution here http://www.clockingit.com/

since Opera and Firefox with Noscript can run JavaScript at infinite speed. Until Safari has this capability, along with ad blocking, it is Full Of Fail.

Presumably by "this capability" you mean the ability to selectively block Java, JavaScript, and Flash; Safari 3 lets you disable Java and JavaScript in toto, and there's the ClickToFlash plugin (requires Leopard) to prevent Flash from running until you click.

Privoxy never worked reliably for me. I used to use it, but it would "lock up" almost daily, leaving my browser waiting forever on every single request. When I realized it was not a connection problem, but Privoxy, I would restart it, but it was still pretty annoying. More annoying than the ads, in fact, which is why I don't use it any more.

At least I have ClickToFlash now.

Flash is pretty ubiquitous. It comes on every Windows PC loaded with Internet Explorer, and it's an easy download for Macs and Linux machines.

It's bundled with Safari in Mac OS X.

Unfortunately, ClickToFlash isn't, so I had to install it in order to keep all the fucking Flash ads on various pages I keep open to read later from chewing up my CPU like crazy.

It appears slashcode has moved to http://github.com/scc/slash/tree/master

That might be right, because Freshmeat is mostly desktop applications and small utilities.

If you look at more recent projects, especially web-related projects (such as web frameworks) there is an increasing trend towards more permissive licenses. Looking at frameworks (from http://en.wikipedia.org/wiki/List_of_web_application_frameworks):

RubyOnRails: MIT
Django: MIT
CakePHP: MIT
Codeigniter: BSD
Zend Framework: BSD
Symfony: MIT
Turbogears: MIT & LGPL

jQuery: MIT & GPL
Dojo: Academic free
Prototype: MIT
Script.aculo.us: MIT
Y! UI: BSD

All the apache javaEE projects: Apache

Out of the top projects on GitHub, I could only count two that were GPL'd: http://github.com/popular/forked

So out of all of those frameworks, which together cover the vast majority of web applications and web services being built today, not a single one of them is GPL only.

So web projects are very much trending away from the GPL - and the reason why is what I discussed in this thread previously ie. allowing companies who build on top of these products more flexibility. The developers, by choosing a more permissive license, have elected more flexibility for users, and thus potentially more popularity, over a sharing restriction.

Go the full shebang and use my handy utility for observing, especially with bash -x mode: http://github.com/topromulan/12345/tree/master

Unless you are intensely involved in a project, browsing for the single file using some alternative interface is probably going to be easier. I.e.:

http://github.com/github/linux-2.6/tree/master/kernel/fork.c

That doesn't work if the repository doesn't have an alternative interface though (but for projects you are involved in, the download only needs to be the difference between the internal and external repositories, not the entire history).

[test!]

A good test suite == "best practice to avoid digging custom holes you can't climb out of"

I work at a Rails shop too and, when I/we need to do something highly custom, we create it as a gem (or a Rails plugin) and post it somewhere incase someone else finds it useful. None of the plugins/gems I've released have required any maintenance to speak of, unless I've wanted to add additional features.

Be sure to write tests for your customizations (gem/plugin)! This will make it really easy to discover if your plugin no longer works for the next version of Rails/ActiveRecord/whatever it is you're extending.

[open source!]

If your changes might help other developers (they're not very, very specific to your product), open source them as a gem and let people know how to use it.

Not only can others benefit from your changes, but they can commit back too! Put the gem up on github[1], as it's the current de facto standard home for such things.

[rack it up!]

If you really need crazy performance out of Rails, look into using Rack[2]. Rails 2.3 (currently Rails Edge, will be released this month) *finally* uses Rack. Something like Rails Metal[3] makes it easy to return directly from Rack, letting you *highly* optimize certain requests. This is like rewriting some of your Ruby as C extensions to speed it up - Rack is really easy to use.

Good luck!

[1]: http://github.com/
[2]: http://rack.rubyforge.org/
[3]: http://weblog.rubyonrails.org/2008/12/17/introducing-rails-metal

Having lambdas and eval is not enough to be a Lisp dialect

No, but it's enough to be quite a bit ahead of many other languages. For that matter...

Lisp is about S-exprs and code-as-data

Granted, it's not as clean, but most Javascript implementations include a toSource method on the function object. Is that enough to build what you want?

S-expressions.

Somehow, I like the JSON syntax better. But it's also a reasonable representation of a data structure, such that I would think it would be easy to store sexps that way.

side-effect free, lenient evaluation, no guaranteed evaluation order - all very important to enable advanced query optimizaters.

In other words: Performance. Got it.

You realize that CouchDB scales to an arbitrary number of nodes, right? And while the queries don't yet, they easily could, and will in the future?

Yes, when I know an app is going to be on a single machine only, I'll probably use something like sqlite for the raw speed and ease of deployment. But I'd much rather have something horizontally scalable than vertically scalable -- and as a nice side effect, I get a decent imperative language that's close to what I already know how to use. And if I really have a problem with JS, I can use whatever language I want.

I could, for instance, serialize sexps to JSON, and write an engine that deserializes them and passes them to LISP view functions.

Contrast this to SQL -- maybe faster on a single machine, but how do you make it really scale? How do you know what to index, when? How do you scale your queries to thousands of nodes?

There's a certain class of application for which SQL makes perfect sense. There's also a class of application for which SQL is a constant pain in the ass, and CouchDB makes perfect sense.

having first-class functions doesn't change that. Yes, you can go halfway there by using lambdas and such, but JS lambda notation is really way too verbose for that sort of thing

So write some sort of macro engine. In fact, someone is doing that -- check out jabl, from the author of haml.

Yes, it's ugly that you have to do that -- but then, I find LISP syntax ugly; unnecessarily verbose, and homogeneous enough that it's hard to tell, at a glance, what's going on.

I don't think Couch is ready -- the two features I really want to see are a nice Ruby interface for views, and support for stacking views. That said, I doubt I'll be using SQL for much even a year from now.

Not sure if anyone here has seen us yet .. but Titanium is an open source/open web alternative to AIR that just had it's first Preview Release (PR1) a week ago. We currently support OSX and Windows , and are hard at work refactoring and getting a Linux release into the fold for our PR2 release in January.

We're licensed under ASL and using lots of open source techs (WebKit, Chromium, Gears, libXML, to name a few).. come check us out!
http://github.com/marshall/titanium/tree/master
http://titaniumapp.com/

ive been web freelancing for around seven years, and in that time ive developed my own open-source billing tool, eboshi, written in rails. its no quickbooks, but it suits my needs and spits out pdfs. feel free to use it, give me feedback, or fork it and hack away!

There are already a few solutions for bug tracking in a git repository (here is one example that also includes a minimalist web interface), though from what I've seen nothing really compares to hosted solutions as of yet. It's great for simple projects, though, especially when you're just starting out and want to keep track of todo items and such.

A non-recursive Python version which uses Warnsdorf's heuristic:
http://github.com/pib/scripts/tree/master/knight.py

It's faster than the one in TFA as well, though it has no backtracking, so it won't find some solutions once you get bigger than 76x76, but at least it doesn't overflow the stack.

It also will tell you whether it found an open, closed, or incomplete path.