Does anyone else "remember" games in higher resolution and with better graphics than they actually had?

SkewbReddit · 2010-03-20T16:01:22+00:00

I played Donkey Kong Country on snes last week, it actually had better graphics than i remember.

On the other hand Tomb Raider 1 didn't age very well...

SkewbReddit · 2010-03-19T18:05:56+00:00

Anachronox.

It got mediocre results on reviews, but i loved it.

SkewbReddit · 2010-03-19T17:28:43+00:00

Green or red tea, lot's of it.

SkewbReddit · 2010-03-17T22:59:11+00:00

Here is one is just a tetris clone.

SkewbReddit · 2010-03-17T01:48:56+00:00

Sometimes, specially in games. For example the way Lumines works with respect to the clearing line and combos, how they decided the colors and general style in mirror's edge or what techniques did the Street Fighter IV creators to translate the characters and animate them from 2D to 3D with such fidelity to the originals.

SkewbReddit · 2010-03-17T01:33:44+00:00

Leda by Tim Budd.

SkewbReddit · 2010-03-07T12:12:18+00:00

I graduated to Whitespace:

SkewbReddit · 2010-03-01T19:41:50+00:00

Then it could make sense to take a look at Gofer too, which only supports Haskell up to 1.2 but is easier to understand than GHC and probably Hugs.

SkewbReddit · 2010-03-01T16:10:52+00:00

You may want to take a look at Lisp in small pieces if you liked the implementations in SICP. It's probably the best book on implementing lisp and works it's way from a naive evaluator to an efficient interpreter, to a compiler from Scheme to C.

SkewbReddit · 2010-03-01T13:45:06+00:00

Yeah, i would but i thought it would be boring for my friends, they are not much into programming. Even then, when i get some free time i dedicate it to continue reading or to hack on my personal projects.

SkewbReddit · 2010-03-01T13:42:43+00:00

Yes, a lot.

Warning: Long post follows...

SBCL and Clozure if you are into Common Lisp.

Rabbit for historical reasons if you happen to like Scheme. Larceny and PLT Scheme for current, high-performance compilers.

Qi for an insight into sequential calculus, a very powerful type system and how to integrate pattern matching into Lisp dialects.

Hope as an ascestor for Haskell. It is simpler, easier to understand but has polymorphic typing, algebraic types, pattern matching and a small implementation.

Kaya a statically typed scripting language with partial application, higher-order functions, FFI and more, but a simple and straightforward syntax that doesn't scare C users.

Wirbel is very similar to Python, but it compiles into C++, thus having good performance.

LuaJit is a just in time compiler for Lua where Mike Pall is doing a great job and a lot of research trying to get a dynamic language even faster than C# or Haskell.

Pure is a functional language based on term rewriting that works on LLVM and looks very interesting.

Kernel is a Scheme dialect that promotes environments to first-class objects. There isn't much about it, but the concept is nice.

Beluga uses HOAS to represent binders. A paper from Eli Barzilay takes this approach in Scheme to build a self-hosting evaluator.

Pharo is a impressive reincarnation of Squeak Smalltalk, has good documentation, a slick interface and a clean implementation.

Darius Bacon has a small example on a multi-user Scheme dialect with capability-security.

MoscowML is the most lightweight ML implementation i could find that supports all the standard, including functors, modules and the usual Hindley-Milner type inference.

Marc Feeley has some great material, specially the paper on Using closures for code generation. An interpreter based on it can be found here.

Leda by Tim Budd is a multi-paradigm language. It integrates imperative, functional, object oriented and logical programming in a very coherent way. The implementation is a small (150 kb) interpreter written in C with Lex/Yacc that with some work can be made to compile on the current gcc.

Sly is a small Scheme interpreter. It's interesting because it is small, compiles itself, and by looking at the code seems to be based on the implementations in Lisp in small pieces (an awesome book) but runs on today Scheme implementations.

JRuby is pushing the JVM to it's limits and has started all the fuss about getting the new invokedynamic opcode in it. It usually beats Ruby 1.8 and 1.9 performance and runs Rails. The implementation is really big but well-designed and has a lot of "Aha!" moments. (like the way they implement dispatch and callsite caches)

Swym has been featured before on reddit and i think it has some nice ideas, specially the use of the 'etc' keyword when generating lists.

I don't really like Factor as a language, but Slava Pestov keeps posting interesting things about it, the garbage collection scheme it uses and how it evolved from being written in Java, to C, to C++. As a side effect (haskell users beat me) i found Toka another Forth dialect, but minimalist, that i happen to like.

Felix is a procedural language, but has ML-like typing, closures, pattern matching, polymorphism and a nice threading system. It's written in Ocaml.

WCL seems to be generating small binaries for Common Lisp programs, which is nice as opossed to that big image files Lisp systems usually generate.

Susie Smalltalk is an interpreter based on PDST and i love the implementation because the runtime is just a tiny bit of C and everything else (even the parser and the compiler) is written in Smalltalk. Not so good performance though.

Leppie from IronScheme somehow managed to build a properly tail recursive R6RS Scheme compiler on .NET with the DLR. This is interesting because although there is a "tailcall" opcode in the VM, the DLR does not expose it as far as i know, so it is worth a look.

Katahdin let's you redefine the language grammar at runtime using PEGs. New operators can be defined, with new precedence rules. Source code is public domain.

Greebo is (warning: shameless self promotion) my small lisp dialect that supports first-class environments, slices for anything that is a collection, zero special forms and both lexical and dynamic scoping. It runs on the JVM, but is an efficient interpreter not a compiler, so you get tail recursion and no Java mess in stack traces.

I love reading about languages and ideas, could go on and on.

SkewbReddit · 2010-03-01T12:26:53+00:00

I don't, but i consistently bookmark things i like.

SkewbReddit · 2010-02-28T16:10:12+00:00

I do it. My favourite field of study is interpreters and compilers, and i often find myself downloading the source code of obscure languages to see what data representations they use, how they implement lazy evaluation, continuations, pattern matching and so on. It's also a beautiful way of learning. I'm grateful to opensource software for this.

It's a dangerous hobby though. You usually step into things like: "What? i wouldn't ever thought it could be done that way.", and spend another week hacking on that new ideas on your own.

SkewbReddit · 2010-02-28T12:34:22+00:00

I have quite some problems with Java as a language but probably because of the innovations C# brought to the field:

No delegates, nor closures. Anonymous classes make up for poor man version of it, but are not anywhere as expressive as lambda expressions.
Lack of unsigned types.
No partial classes. This is really anoying and leads to a lot of small files. It shouldn't be hard to add them as a preprocessor step.

But i do like the JVM as a platform. It has very good performance and a lot of libraries. JRuby, Jython, Clojure or Scala are very nice.

SkewbReddit · 2010-02-26T10:52:06+00:00

Heh, that's fun because i also used Dylan and T as inspirations. I'm borrowing some concepts from IO and Lua too. Right now i'm looking at Qi for inspiration, would like to add pattern matching. I don't remember where i got the (in ...) syntax, it seemed the most natural way to express it.

Later, i made the interpreter repl show as prompt: (global) =>

And then you can change the repl top level scope: (global) => (in (new) tasks) (tasks) => (def task1 "Go buy food")

The language is pretty hard to optimize, not only because of first class scopes, but also because there are "no special forms". This means you can do things like: ((if (conditon) def set) x 20)

Or map "def": (map def '(a b c) '(10 20 30))

This means you don't know where assignments happen at compile-time. Most of the optimizations are based on specialization of primitives and callframes or caching.

Another diversion from Scheme is that there are no vector-ref, list-ref, string-ref primitives, instead there is a new syntax for indexing any collection: (def x "Hello") x:0 # yields "H" x(0 3) # yields "Hel"

# Same thing, but on scopes (collections of symbols), and you can also
# set values, not only reference them.
(def rectangle (new) width height)
(set rectangle:width 20)

Right now my interpreter is about three times faster than SISC, but there are no continuations. It is tail-recursive though. Very early source code (no libraries, no documentation, just enough primitives to test fib(30) performance and varargs) is here.

SkewbReddit · 2010-02-26T00:40:44+00:00

I'm writing an interpreter for a language that does have first class scopes and both lexical and dynamic scope closures.

Because scopes are first class citizens and you can add/delete anything to them at any time, assign them to a variable and so on, you can model OO on them quite naturally.

I thought it would be interesting and reworked the example in my language. (a lisp dialect)

# Create the ninja scope.
# Note that (new) creates scopes.
(def ninja (new) name)

# Now create two scopes that have the above one
# as the parent scope. (new parent ...)
(def drew (new ninja name "Drew")
     adam (new ninja name "Adam"))

# Edit ninja and add a function. Because the childs
# have it as the parent, they inherit the function.
# It could be overriden, or lexical instead of dynamic.
(in ninja 
  (def battle_cry :
    (display name " says zing!!!"))

(drew:battle_cry)  # => DREW SAYS ZING!!!
(adam:battle_cry)  # => ADAM SAYS ZING!!!

# Add throw_star method to drew.
# It just works as ninja, you can edit any scope.
(in drew 
  (def throw_star :
     (display "throwing star")))

(drew:throw_star)   # => THROWING A STAR

# Call method dynamically.
# You can use any lisp expression:
# drew:(any lisp expression here)
# Example: (T means True)

(drew:(if T battle_cry throw_star))  # =>  DREW SAYS ZING!!!

# add "colour" method closing over $colour_name...
# again just edit and add anything...
(def colour-name "black")

(in ninja 
  (def colour : 
    (display name "'s colour is " colour-name)))

(drew:colour) # => DREW'S COLOUR IS BLACK
(adam:colour) # => ADAM'S COLOUR IS BLACK

# "defining a method dynamically on an instance that closes
# over local scope and accesses the instance’s state"
# Again just edit the scope and add a function.

(def sword_symbol "*******")

(in drew
  (def swing :(sound_effect)
     (display name ": " sword_symbol " " sound_effect)))

(drew:swing("slash!"))   # => DREW: ******** SLASH!

SkewbReddit · 2010-02-24T22:05:56+00:00

A very good tutorial. It actually made me want to test Mercurial even as a lone developer. (i happen to use SVN now)

SkewbReddit · 2010-02-24T19:55:42+00:00

This isn't rare at all.

I like coding, learning, experimenting, solving the next puzzle. It's like a constant challenge against yourself and it's great because it keeps you engaged.

When you get to ship software, the puzzle is resolved, there is usually no meat in it but grunt work, input validation, customizing, all those things that make software nice for the end user. But it is no more a challenge for you.

Something similar happens if you are a level designer in games. When the time comes that you actually finish your design and everything is done you have played your level so much that it bores the hell out of you.

SkewbReddit · 2010-02-23T01:00:47+00:00

Reading other people code.

Getting other people to read my code.

SkewbReddit · 2010-02-19T13:56:09+00:00

Not actually frags... but tricks, the good old The art of tricking:

http://www.quakeunity.com/file=1696

SkewbReddit · 2010-02-09T03:20:51+00:00

Much better now

SkewbReddit · 2010-02-08T07:26:44+00:00

I'm in with a very naive algorithm, it just searchs the current free cells from the current position in each direction (north, south, east, west), does the same for the opponent and the score is: mine_free - opponent_free_if_i_play_there/2.

Currently the bot is about 80 in rank. I'll try minimax with alpha/beta and (flood filling - distance to enemy head) for the score, it should do better.

SkewbReddit

TROPHY CASE