I totally hadn’t forgot about the fact that I even had a blog.

Akyu~

Except for the ordinary slavery going on at school I’m working on a bunch of projects

Hecate

A rewrite of Lolikins’ rewrite (which I never finished), sort of.
Made in Python instead of PHP which gives a couple of quite nice advantages such as:

• SSL support again
• Clean code (PHP looks dirty for some reason, probably all those $)
• Module reloading without the use of unsupported extensions

Oh and I have someone helping me out actively this time (which means it’ll probably be finished too).

Akyu

As usual there’s some changes I did to the quote database such as infi-scroll (you know, the thing that makes the page continue loading while you scroll on twitter and such) which… doesn’t work quite as I want it to just yet but oh well.

Lastly

There’s a project I’ll announce when it’s ready (some of you may already know but keep it to yourselves).

Happy birthday Southrop!

Some facts about Southrop:

He

• is a staff member over at BakaBT
• runs Chaos, an anime fansub group (among other things)

Well, that’s all. Head over to Chaos|Theory and congratulate him already!

The quote database I work on (Akyu) have been updated to 0.2 recently (24th August).
This changed some things:

• Voting buttons now actually tells you they are, i.e voting buttons
• No text error messages, all error messages are displayed when you hover over the button you just clicked
• Some minor changes to the layouts of some pages (for example the search page)

pIRC

A smaller bug fix a couple of days ago. The event handler couldn’t handle some constants as triggers.
Away has been added to the irc wrapper as well.

Going to try to get some sort of Admin module into it next time I have a longer weekend than I have now.

Voile

My little image gallery I work on every now and then.
It currently only generates cached thumbnails for what I upload and lists them on the index page; nothing fancy.

Feel free to take a look

One last thing…

Rawr, I'm going to poke you with my antenna

Mandatory Touhou

Oh Tenshi, you masochist

Tenshi, that is all. (Anyone thought of Angel Beats! Tenshi? No? Good.)

Either way, recently I realized how nice Tenshi’s theme is. You should check it out (a simple search for “Catastrophe in Bhava-agra ~ Wonderful Heaven” on YouTube will give you plenty results or her final spell theme for that matter “Bhava-agra As Seen Through a Child’s Mind”).

Also, Git.

I switched most of my projects over from SVN to Git, which is quite a lot better IMO. Not to mention it’s quite a bit faster and works without an internet connection (which is a plus if you’re on the bus or similar).

I’m yet to experiment with the more hidden features of Git though but I’ll get to that soon enough. So far so good though, Git is good.

Anyways

I have a rewrite of both the quote database and Lolikins going on (Lolikins is being moved over to the new IRC Lib), the QDB is being rewritten to be easier to manage.

The Quote Database’s appearance probably won’t change at all considering I’m the lazy person I am.
Lolikins won’t have anything major changed except she replies to a few more CTCP commands (kind of got exchange rates planned for her though, but that’s up to Mirgond to help me figure out some good exchange rates).

And finally

That’s all. I just thought I’d write something again to not let this blog die out.

tl;dr I’m bored.

As you might know (at least if you checked out the Projects tab) I’m working on an irclib, so I thought I’d give you a bit of a preview on how the actual ircbot looks from the command-line.

Sadly it seems like the coloring and stuff will be Linux only since it requires an extra (3rd-party, not Microsoft) executable for Windows.

So, this is how it looks

An extensible IRC-bot made in PHP using as few PECL modules as possible.

The goal of pIRC is to have a fast lightweight bot that’s extensible.

And this is the current feature set:

- Event Handler

• Supports both arrays and single arguments, if none are given upon registering the function will be passed the standard Message object.
• Built-in flood protection

- Modules

• All modules can be loaded, unloaded and reloaded during run-time
• It checks the syntax before loading to prevent accidental crashing
• Probably less leaky than the rename class method that others seems to use

Anyways,

I did some updates to the QDB to make it a bit faster along with fixing up a new theme for my #bakabt stats.

Sadly not much more to report, except the fact that I have math test on Wednesday so I wont get anything done on anything this week anyway :3

Also, if you have any suggestions to the QDB or similar, feel free, suggestions are always welcome.

This post is pretty much a post to remind myself to work on this crap when I get the time to >_>
also, todo: Add more stuff to this update post.

Lambda Expressions were introduced in the 3.0 version of the Common Language Specification.  Lambdas are essentially a refinement of anonymous methods.  They allow you to define a block of code which operates on one or more input variables and returns a single result.  Let’s break down a simple lambda example, from the MSDN page on Lambda Expressions:

delegate int del(int i);
static void Main(string[] args)
{
    del myDelegate = x => x * x;
    int j = myDelegate(5); //j = 25
}

In this example, a delegate type is defined, del.  Then an instance of the delegate is created using a lambda expression.  Finally, the delegate is executed, and the return value is assigned to the integer variable j.  Let’s ignore everything but the lambda expression itself: x => x * x.

The first character of the expression actually defines a variable named x, which only exists inside the lambda expression.  In the MSDN example, when the lambda is actually executed, x will be assigned the input value of 5.

The => character sequence tells C# that your lambda expression operates on the variable x.  To oversimplify, everything to the left of => is an input variable declaration, and everything on the right is an expression which determines the return value.  In our examples, there will only ever be one input variable.

The x * x character sequence is the actual expression, the bit of code that gets executed.  So we could rewrite down the code above to this:

int x = 5;
int j = x * x;

…and achieve the same result.

Filtering Cars with Lambda Expressions

Returning to our anonymous methods example, we found that the FindAll method of the List<> generic class can take a delegate. The delegate is used to filter which items in the list are returned.

With Anonymous Methods

static void Main(string[] args)
{
    // Create a list of cars meeting criteria by calling the FindAll()
    // method of the List returned by CreateCars().
    List cars = CreateCars().FindAll(delegate(Car candidate)
    {
        // Return whether the car matches our criteria.  FindAll()
        // expects our anonymous method to return a boolean, and
        // the compiler makes sure this is the case.
        return
            candidate.Manufacturer == "Toyota" ||
            candidate.Manufacturer == "Nissan" &&
            candidate.Turbocharged == false;
    });
 
    foreach(Car car in cars)
    {
        Console.WriteLine(car.ToString());
    }
}

Instead, let’s replace that anonymous method block with a lambda expression.

With Lambda Expressions

static void Main(string[] args)
{
    List cars = CreateCars().FindAll(car =>
        car.Manufacturer == "Toyota" ||
        car.Manufacturer == "Nissan" &&
        car.Turbocharged == false );
 
    car.Turbocharged = true; // Invalid code, "car" does not exist.
}

In this case, our lambda expression creates the variable car, and then does the same set of conditional tests as the old example. Note that the car variable only exists in the scope of the lambda expression, just like in the anonymous method. For that reason, the second to last line of code would be a compiler error.

So What’s the Difference?

For the purposes of our example, not a whole lot:

• The input variable and return types are inferred. C# is able to figure out what type car is by looking at where the lambda is used.   The type is actually defined in the CreateCars() method of our earlier example. C# looks at the return type of List<Car> and infers (or deduces) that a lambda expression operating on the FindAll method of that List<Car> would operate on a single input variable of type Car. Note that in the old anonymous methods example, C# was only able to infer the return type.
• The lambda expression does not need curly braces, since it is a basic expression.
• The lambda expression does not use the ugly delegate() syntax, thanks to the type inference.

Of course lambda expressions are a bit more complicated than I let on; they can declare multiple input variables, and they can also contain normal procedural code statements (such as calling a method — and that does require using curly braces).

Go to his blog and congratulate him, if he posts a post about his birthday that is :3

:3

Now go congratulate him.

On another note I’m working a bit on the QDB and on Lolikins, again.
You can expect an update on one of them like… next month or something, blame school for making my projects appear stalled ;_;

Cirno is the strongest!

That is all for now.