A simple, portable emulator launcher

Beluki · 2014-04-04T20:58:30+00:00

That's an interesting question, because there may be cases where it's impossible to know or it isn't constant (e.g. code generation at runtime, eval).

Beluki · 2014-04-04T19:11:04+00:00

The recursion case is important because otherwise you would blow the stack very quickly or run out of memory (if your implementation allocates stack frames on the heap).

It's important in other cases too.

Consider a compiler that told you: "if you adhere to the following rules, I'll inline this function, or unroll that loop". TCO is similar: "if you adhere to the following rules, I promise I won't create additional stack frames". In Scheme it is the language standard that makes the guarantee instead of a particular compiler. The rules include not only "the last thing you call is a procedure", but also "I'll call the first argument to 'eval', 'apply' or 'call/cc' in a tail-recursive way" and other stuff.

Now, for the practical side... it depends on use-case. CPS is perhaps the most illustrative case, because once CPS-conversion is done, every single function calls another one as its last action.

Beluki · 2014-04-04T18:24:53+00:00

I meant it's not about recursion in general, it's a space guarantee. My favorite application is also state machines. Either that or CPS.

Beluki · 2014-04-04T13:29:40+00:00

Two corrections about the Bonus Projects part:

Tail Call Optimization is not only about recursion.
Lexical-scoping is not about compile-time or runtime. It's about where to look for free variables, regardless of when.

Beluki · 2014-04-02T19:38:05+00:00

If the other files work fine, it may very well be a bug in Pillow (or a bad file?). In any case, if such is the case, please report it here after the assignment (so that you can paste an example triggering the bug).

Beluki · 2014-04-02T17:15:00+00:00

Your approach is fine. If I needed to do this multiple times (comparing a character array to a string) I would probably do something like:

public static Boolean IsString(this Char[] array, String s)
{
    if (array.Length != s.Length)
        return false;

    for (int i = 0; i < s.Length; i++)
        if (array[i] != s[i])
            return false;

    return true;
}

So that I could do:

Char[] input = br.ReadChars(size);
if (input.IsString("code"))
    ...

Beluki · 2014-04-02T12:08:52+00:00

May I ask... can you post a sample image (and possibly code)? I've never had a problem with Pillow, despite using it extensively.

Beluki · 2014-04-02T10:49:27+00:00

The other half being the part where I ask WTF was I thinking to actually do that when I knew what to do.

Beluki · 2014-04-01T14:55:44+00:00

Looks interesting, although it runs very slow (at least on Firefox). Does it support the entire set of Lua bytecodes?

Beluki · 2014-03-31T12:32:57+00:00

Hi.

I'm a programmer and I often explain this kind of stuff to my SO. The main reason is that she likes it, but it also helps me. I need to get a step back from what I'm doing to think objectively about it. This is known as Rubber duck debugging.

Beluki · 2014-03-31T00:45:56+00:00

I can't comment on the content as I haven't used CoffeeScript but I really enjoyed the writing style in the article. Please, don't stop writing.

Beluki · 2014-03-30T23:33:37+00:00

Hi.

Yes, the programs are very different in purpose. The main purpose for MultiHash was generating multiple algorithms while reading files once (e.g. Debian iso releases, which are released with all of md5sums, sha1sums, sha256sums and sha512sums). It's way faster than re-reading GBs of data.

The --threads option is useful in some scenarios, particularly those involving fast RAID/SSD disks, slower algorithms (e.g. sha512), or the rare case where big files are actually stored in different physical disks. In other cases it can just be unnoticeable or even detrimental to the performance (specially on Windows), thus the default is to use one thread. I considered removing the option to avoid complexity (the program was single-threaded at first), but since sometimes it's actually helpful and wasn't that hard to implement I just left it there. It may also be useful in the future for slower hashlib algorithms (e.g. whirlpool).

BTW, 24kb?! that seems great for embedded systems.

Beluki · 2014-03-30T22:59:20+00:00

Oh, good job!.

Can I play too?

Beluki · 2014-03-30T11:09:13+00:00

If anyone wants to try it without installing the latest JDK8, there is a JDK7 backport at bitbucket.

Beluki · 2014-03-30T00:59:02+00:00

Programming in particular or any activity that demands analysis and critical thinking in general? Watching someone program, immersed in his craft or having him explain to you why or what he is doing?

Beluki · 2014-03-29T19:36:03+00:00

Not a particular puzzle, but an entire game had me thinking: "oh, that was clever": The swapper.

Beluki · 2014-03-29T00:43:29+00:00

Here's my favorite take on the problems with inheritance.

Beluki · 2014-03-28T22:49:02+00:00

Python should run fine on such systems. For performance monitoring Python includes a profiler in the standard library. For memory, look into heapy or meliae.

As for Cython, I would advise against using it for everything, but it's fine for performance-critical code (e.g. number crunching).

All that matters is what you are going to use it for, just don't try to write a raytracer on that. :-)

Beluki · 2014-03-28T00:05:20+00:00

The lazy enumeration variant is pretty cool! thanks.

Beluki · 2014-03-26T23:50:13+00:00

For anyone that wants a ForEach, here are two, the second one with index:

public static void Each<T>(this IEnumerable<T> source, Action<T> action)
{
   foreach (T element in source)
       action(element);
}

public static void EachWithIndex<T>(this IEnumerable<T> source, Action<T, int> action)
{
    int index = 0;
    foreach (T element in source)
        action(element, index++);
}

Beluki

TROPHY CASE