I was reading a book about woodworking, where it was stated that it is very important to keep your tools sharp. Nothing new really: it makes sense that your sharp cutting tools have to be sharp. What I did not really realize was how sharp is sharp – Apparently, a chisel should be sharp enough to shave the hair off the back of your arm.

I found several videos on Youtube that show different methods for sharpening your chisels (and plane!). Some use sharpening stones, others use sandpaper, but the technique is mostly the same. I was lucky to already have sandpaper of different grits, from 120 up to 1600 – so this was what I used.

I was not dedicated enough to the sharpening process, and did not get to the mirror-edge razor-sharp shave-your-hair grade – but my efforts did improve the usability of my chisels and plane significantly.

I continued the work on the headstock, chiseling and shaving it straight. Also seen in this picture is the beginning of the truss rod route. I have found it quite difficult to route a 5mm wide route with a 6mm chisel, so I will get a new chisel before I continue with the route.

It has been quite long since I first considered building my own guitar. It has also been long since I first wanted to get into woodworking/sculpting. I’ve finally taken it beyond the aspiration phase to actual execution. I will be documenting the process in a series of posts, of which this is the first.

I began this journey by reading a lot about guitar building online, browsing different forums and reading construction logs. I also spent much time looking through guitar-making related products in shops like StewMac, Luthiers Mercantile International, Warmoth etc.

The next step, that took about a year an a half, was deciding to go for it. I bought Melvyn Hiscock’s Make Your Own Electric Guitar, which I think is very well written. It is full of transcribed personal experience, that will save you time and errors, and guide you through the entire build.

Beginning to gather supplies, I started to design and choose what my guitar will be like. At first I considered making it an SG clone. I really like the SG and was avid about getting one after I first tried it. I then decided that given the effort put into building my own guitar, I’d rather try a more interesting custom design. And thus, the very fun part of sketching out guitars in pencil has began.

Eventually I came up with 3 designs that I liked enough to refine and illustrate:

and the chosen finalist:

I decided to go with Mahagony for both the neck and the body, Rosewood fretboard, Gibson scale length (not accurate in the sketches) and a two humbuckers setup.

My next decision was not use power tools, unless I will absolutely have to. The are few reasons for choosing so. First, I do not own a router, a sander or any other of the woodworking associated power tools, and I don’t know anyone who does and can lend me his. Second, I’m going to be building the guitar in a room in an apartment – meaning I have to go low on noise and mess. I hope that it will end up as a wise choice, and I don’t mind the extra time and effort that manual tools require.

Once I had everything at hand, things became more interesting. I started by cutting an angled headstock out of the neck blank using a Japanese Ryoba saw. I followed the method outlined in this tutorial.

I then planed both the cut part and the rest of the neck. When I saw the effect of the plane on the sawn wood, I finally realized what planing is all about. I glued up the parts and clamped everything overnight:

I made my first building mistake in the way I clamped the parts. Applying perpendicular pressure on an angle filled with glue caused the parts to slid and the result was not as I have first planned:

The result however, was far from bad. First, I had enough room for mistakes, as the neck still has to be narrowed down and shaped. Minor inaccuracies in this early stage can be easily handled. Moreover, the slipped parts have created just the correct width for the headstock, meaning I will have less work when shaping it.

That’s as far as I have gotten. Next, I’m going to make more planning and measurements in order to get the scale length right, and then I will be working on routing the truss rod route and cutting the rough shape of the body.

It’s an alarm clock application for S60 phones (more specifically Nokia 5800) written in Python

The code is NOWHERE near what you’d expect of released code to be – this is NOT a release, rather a preview

This is my first piece of code written in S60 Python. The code is not pretty, not well designed, not nothing – it’s just a proof of concept; helping me get to know the S60 python modules, and wake up on time.

The main feature of this program, that I could not find a ready-made S60 application that already accomplishes this, is the use of a random tune for every alarm.
Don’t you hate it when you choose a song for an alarm clock, and find yourself hating the song ever after? Spazzing just a little bit every time you hear it?
By choosing a random song every morning, you get to hear many of your favorite songs, without slowly developing hate towards them.

The second feature, is “fade in”. The song is initially played in low volume, which is gradually turned up.

Don’t rely on this code to wake you up for important meetings, it is probably full of bugs. It can’t save your last alarm properly (even though it tries to), but it will save your songs path.
It is also semi-automatic, meaning you’ll have to set the alarm every night, it won’t do so automatically (yet!).
It won’t survive phone shutdown either.
It seems like python can’t overcome these obstacles easily, but I’ll try to improve it in the future. If I tried to code it with the bare Symbian API, it wouldn’t have reached the somewhat functional state it is in today…

I only post it here because I have started using it almost daily, and that both lowered my motivation to work for a more complete solution, and urged me to post the code somewhere, as other people may find it useful.
It can also serve as a demo for S60 Python API use.

I have only tested it on Nokia 5800 which is S60 5th edition, with python 1.9.4.
Other configurations may cause nuclear fusion.

Feel free to do whatever you want with the code.

The Code

As a side note, during development I have used pys60-compat which is a wxPython based implementation of portions of the S60 python framework – meaning it let’s you run python code written for s60 in a testing environment on your desktop.
It is somewhat outdated, and I have added some extensions of my own, which I may release in the future.

A friend had told me about Sandcastle and I looked it up. Sandcastle is a project by Microsoft, that is intended to create MSDN-style documentation from .NET assemblies…

I had managed to achieve my goal quite easily using Sandcastle, and I thought about sharing my experience to serve other people as a guide. This is just a quick write-up of what I did – I did not read Sandcastle’s documentation and I believe that I don’t know how to operate it to its full potential.

1. The first step is to download and install Sandcastle.
2. Next, if you haven’t done it already, you have to tell Visual Studio to build XML documentation files. This parses all your comments ( in the C# format ///<summary> etc…) and creates an XML file that we will feed into Sandcastle. To enable XML documentation, you have to go to Proect->(Project Name) Properties… and tick the relevant checkbox in the Build menu:
3. We will now launch the Sandcastle GUI application, located in C:\Program Files\Sandcastle\Examples\generic ( replace C:\Program Files with wherever you had installed Sandcastle).
4. Add your assemblies (exe/dll) and XML comments file to the relevant list boxes and choose the desired output format. Enter you project name under “Name”.
5. Hit “Build”. The build process can take a while, and it may seem like the program is frozen, but it’s not.
6. Your documentation files should now be ready in  C:\Program Files\Sandcastle\Examples\Your Project Name
7. If you chose CHM as an output format, you will now have to compile the CHM file. To do this you need to download and install Microsoft HTML Help Workshop
8. After installing HTML Help Workshop, you will have to run hhc.exe (from the directory where you installed it). hhc takes an hhp (HTML Help Project) file as an argument. Sandcastle has created this hhp file for you, and it should be in your Sandcastle project directory. Just run “hhc yourproject.hhp” and this will produce a CHM file in the project’s directory.

That’s it. You should now have your compiled CHM help file with nice MSDN-style documentation.

As I mentioned earlier, I don’t really know Sandcastle and will be happy to get some tips in the comments section if you have any.

I have also decided to put it under a new domain of its own – wikislate.com

There’s a bunch of new features (because the old script was so basic…) that focus on ease of use.

Wikislate is a tool for translating nouns, and was designed for translation of technical terms. It uses Wikipedia as its data-source and automates a process that I was doing manually for a while, and is described in elzr’s blog and in my introduction of the old version.

Enjoy =)

a tale about how I hacked a mint keyboard backlight when I was supposed to study.

My dad brought me the Microsoft/Razer Reclusa keyboard earlier today. I did not ask for it, but I did like the idea of upgrading my ~10 years old keyboard.

It turned out to be a nice keyboard. I wouldn’t say it’s really a “gamer” keyboard ( unlike the wolfclaw etc ), but it’s got a nice feel to it, and that’s what matters to me.

While trying it out, I found the backlight to be quite annoying in daylight, even a bit straining the eye. I quickly installed the keyboard’s software and looked around for a way to turn it off. Failing to find one, I googled around, and the results indicated that the backlight cannot be turned off.

The keyboard is brand new, so it was a bit hard for me to decide, but I knew what had to be done. I had to pry it open and install a backlight switch!

I later decided it would be much more elegant to hook a transistor to the Scroll Lock LED to do the switching, rather than having an external mechanical switch. I knew it was generally possibly, but was not sure about the wiring.

This review was very helpful when taking the keyboard apart. I found it after I had already unscrewed all the bottom screwes except the hidden one, so it had saved me from possibly breaking the bottom plate. It had also served in guiding me to the LEDs.

This page served as a guideline for creating the switch. At first I tried the second diagram, using an NPN transistor ( I never use a PNP before, even though I had a few ). I hooked the Base lead of the NPN transistor to the + end of the LED, and the Emitter and Collector as shown in the diagram. When I connected the keyboard, I immediatly realised that I did a mistake.

The LEDs in the keyboard ( and if I’m not mistaken, generally in electrical circuits ) are toggled by their ground pin, the +V is always positive. I then realised I had to use a PNP transistor as shown in the first switch diagram.

It is important to note that if you don’t push the transistor to its saturated state ( if I understand correctly ) , the output will be lower that it should. I skipped the extra resistor because I can barely solder and I was too lazy to calculate or measure ( lost my multimeter ) the required values. I really don’t care about how bright the backlight shines anyway…

My soldering skills are horrible, and most of the time I relied on sheer luck. Here are some action shots:

Now I can turn the backlight on and off whenever I want!

PLEASE NOTE that the information above can and will cause damage to you and your surrounding. you have a high chance of breaking your keyboard and/or PC, and setting your house on fire. I am not responsible if you’re stupid enough to try it with as little background knowledge as I have.

However, if you do make this mod to your keyboard, please let me know!

The next step is to create a Gmail notifier that will flash the keyboard whenever new mail arrives =)

I am working on a C# project for uni, and while fighting some pesky bugs, I decided I should get more organized and have a small “unit testing” framework built for it.

I had a need for random generated Unicode strings, and quick googling turned up no results. Instead of doing some broaded searching, I decided I could learn more by writing my own code:

class RandomUnicodeString
    {
        private Random _r;
 
        public RandomUnicodeString()
        {
            _r = new Random();
        }
 
        public string GetString(int length)
        {
            byte[] str = new byte[length * 2];
 
            for (int i = 0; i < length * 2 ; i+=2)
            {
                int chr = _r.Next(0xD7FF);
                str[i+1] = (byte)((chr & 0xFF00) >> 8);
                str[i] = (byte)(chr & 0xFF);
            }
 
            return Encoding.Unicode.GetString(str);
        }
    }

At first I had the string generation in the constructor, but it caused repeated strings, as I was using it in a loop, and newly created Random objects were using the same seed. More on this can be found in Guy’s blog.

If you want to limit the string to be of a specific language, there’s a reference of unicode mapping on Wikipedia, just change _r.Next to use those limits.

There’s probably a better way for converting bytes to unicode chars, and this may not work on a little/big endian machine, but I don’t know enough about C# to tell for sure.

If you got here from google and this solved your coding problem, please post a comment ! =)

Here are some examples:

What drew me into researching this topic, and writing this post, is not the visual presentation (which can sometimes include stunning effects), but rather the great music that accompanies many keygens.

It seems like keygen music dates back to Cracktros ( Wikipedia ) which were audio-visual intro, added to cracked software by release groups. This, in time, have spawned the Demoscene( Wikipedia ) whose members are focused on pushing the envelope of real-time computer generated “demos” ( = audio-visual presentations ) , many times within a tight code size limit. There are really impressive demos out there, and it seems like an area I’d like to explore more in the future.

Back to keygens. So, as a relic of those Cracktros, modern keygens feature great tunes, many reminiscent of old game console. There’s actually a website dedicated to ripping and archiving keygen music – KEYGENMUSiC. I have decided to find out how those tunes are created and embedded in the EXEs.

My research has brought me to MadTracker a modern music composition (or rather “Tracking”) tool, based on an older DOS application called FastTracker(Wikipedia). It seems like the most common format for Tracker music is XM, so I decided to use that format too. This format contains both samples (of the instruments you use for your track) and note information (how to sequence those samples). There’s also support for some effects, but I didn’t get to those.

Here’s my very first XM track, composed in MadTracker using the bundled samples – first

The next step was embedding it in a small application. For this purpose, I had found the uFMOD library, which is a tiny library for playing XM and other formats. uFMOD comes bundled with many helpful code samples for different programming languages. I chose to use C.

Rather then try to explain how to use uFMOD, I refer you to those samples, as you can learn off them to a greater extent than my knowledge. I will, however, provide you with a minimal example of uFMOD usage, with first.xm embedded in it.

The method that I had chosen for embedding the track was as a resource ( defined in a .rc file ). uFMOD comes with an utility called Eff, which can create an rc formatted hex dump of your XM file, when passed /Ds as an argument.

Here’s my sample, with a Visual Studio 2005 Express solution – minimal

I hope you enjoyed this quick intro. It really is very simple to create and embed keygen music. If you happen to compose any tracks, please post them in the comments section!

I may post a follow-up in the future about how to create the custom shaped forms seen in the above examples.

Here’s my latest project, it’s less than 24 hours old =)

I’ve always wanted a looper effect, like the boss loopstation, mainly because the online demos were so neat. Being a bass player, I though it would help me practice with drum loops, but it’s just not worth the money unless you’re going to use it live. I ended up playing drum samples on my PC and playing along on the bass.

more (and video) after the break

About 2 weeks ago, a friend asked me about creating a digital recording circuit, for a project (which will be posted here when completed, going to stay a secret for now). Some online searching brought us to a keychain digital recorder product. After comparing some models, we found one that had 60 seconds of recording time, and we got 2 of it off ebay. I then came up with the idea to use this little recorder as a guitar looping effect, and wondered how it will handle it.

Yesterday, we met and started to disassemble and test this unit. We hooked it up to the Arduino, powered it from the 3.3V supply, and tested the “button press emulation”. We later went to a friend for a BBQ. When I came back home, I decided to continue experimentation. I had desoldered the microphone and speaker from the unit, and soldered some more hook-up wire. I had some problems with getting the circuit to function properly, I think I had a short circuit somewhere. I went to sleep without getting it to work.

This morning, I had a day off work, and decided to continue this little project. I soldered some more wire to replace problematic alligator clips positioning, and everything worked again. I connected my guitar to where the mic was, changed the Arduino code a little, and fired it up. You can see it in action on the following video:

And here’s the simple arduino code:

int recPin = 4;
int playPin = 2;
 
void setup()
{
    //prepare pins for output
    pinMode(recPin,OUTPUT);
    digitalWrite(recPin,HIGH);
    pinMode(playPin,OUTPUT);
    digitalWrite(playPin,HIGH);
}
 
void loop()
{
    //wait and then record a 5 second loop
    delay(5000);
    digitalWrite(recPin,LOW); //"hold down" rec button
    delay(5000);
    digitalWrite(recPin,HIGH); //release it
    delay(30); // to pass debouncing
    while(1) {
        digitalWrite(playPin,LOW);
        delay(30);
        digitalWrite(playPin,HIGH);
        delay(4970);
 
        digitalWrite(playPin,LOW); //emulate a second click, this will stop playing the sample, and will be ready to play
        //again in the next loop iteration
        delay(30);
        digitalWrite(playPin,HIGH);
        delay(30);
    }
}

When I continue working on it, I will need to build some sort of preamp for the output signal. I will also recreate the Arduino program on a PIC 12F675 (or whatever the model number is) of which I have quite a few. There’s also need for better timing, and a pushbutton to start/stop loop recording (and adjust the length of the loop accordingly).

I hope to get it to a usable state, and have some creative fun with it. Now it’s time to get back to my homework in algebraic structures.

Behold, a one-click way to convert your videos to a format playable by your iPod!

[sic]
Well, here’s my latest project. I’ve started it to provide my sister with a simple way to convert her videos, so that she could finally watch them on her shiny 6G iPod.
The result is this simple ffmpeg frontend, built to run on Windows, with the goal of ease of use.

At this point it is rather limited, and I’m not sure if I will ever work on it again.
I’ve actually continued working on it after the uploaded build, but I have come to a dead-end with the Win32 API.
I chose to work with the bare API because I did not want to do it in C#, and, well, as far as I know, there are no many other options.

Why not C#? Even though the .NET Framework is widely available, I thought it was too much for a couple of buttons that launch an exeternal application.
I did not want to use MFC, because I’m unfamilar with it, and last time I used it it felt over-complex and messy. It also requires additional Dlls, or huge executable.

So Win32 API it was. I fired up Emacs (my new tool of the trade) and started coding.
As long as my code was a mess (i.e. C style coding, global vars etc ), everything was smooth and fun. I then wanted to add a system tray notification icon, and thought it would be
a good idea to create it inside a class, for use in later projects. This is where things started to break. I spent some hours researching methods to connect my window procedure to
members of my class. The solution involved an assembly hack. While interesting, I wanted nothing of it.

During my research, I came across WTL, which sounds just like what I was looking for. If/When I continue this project and/or develop another Windows application, it’s going to be in WTL.
Though I did find the lack of documentation annoying.

As a side note, I have to find out what utorrent used.

That’s it for now, hope someone will find it useful.