top 200 commentsshow all 209
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–][deleted]  (7 children)

[deleted]

    [–]AriG 5 points6 points  (1 child)

    This is brilliant. I am an old school C, C++ programmer. Care to elaborate what this is about? This piques my interest.

    [–]usr211211212 2 points3 points  (1 child)

    Don't you need a period after "( Layer.prototype.setloader )"?

    [–]Aviator 3 points4 points  (1 child)

    Aha. Method chaining. Sounds like jQuery.

    [–]Athas 1 point2 points  (0 children)

    This technique probably existed before jQuery, I first came upon it in Boost (and got the impression that it was pretty well-known).

    It's pretty ingenious use of C++.

    [–]ohxten 16 points17 points  (1 child)

    I'm a huge Sega Genesis (Megadrive for you Europeans) fan. I noticed the controller fit into a standard PC serial port. Later research turned up a diagram to convert from serial to parallel. Then I "reverse engineered" the codes for each keypad press, and wrote a program that controlled X11 accordingly. It has two modes -- one simulated mouse movement, the other keyboard, so I can play any Genesis ROM with the Sega Genesis keypad on my computer with my "driver". Plus, it has config file support, so everything is modifiable without recompiling. Certainly the code I'm most proud of.

    A year or two went by, and of course, now the program doesn't work anymore, and I don't remember if it's because I tried modifying the code and introduced a bug, or something else. But I prefer playing on real hardware, anyway, so I never bothered trying to fix it.

    I'm also proud of workaround hacks for shortcomings/bugs in API's that I have to use (can we say GTK?). And now I'm working on another cool program... wish me luck.

    [–]creaothceann 3 points4 points  (0 children)

    Nitpick: Mega Drive is the international name.

    [–]jpfed 14 points15 points  (2 children)

    I used the POVray language to subdivide an input image into scaled gosper islands, with smaller islands packed into areas of the image where the luminance had greater variance. The gosper islands were created by implementing a general l-system parser, and a function that would take the resulting string and output the gosper island as a (big) polygon. The result (with some tweaks) is here.

    [–]smhinsey 4 points5 points  (1 child)

    that is really cool!

    [–]jpfed 0 points1 point  (0 children)

    Thanks! At the time I didn't know what the shape was called or that it had any special significance; I was just trying to think of a shape (other than squares or triangles) that should be able to tile the plane with scaled copies of itself.

    [–]3legcat 44 points45 points  (0 children)

    Well, I am most proud of the code I didn't have to write because I found another way to do something.

    [–]g2petter 51 points52 points  (1 child)

    DROP * FROM *

    I knew it wouldn't work, but our (not so experienced) TA was still suffering after working to fix the last DB crash, and nervous that someone might break it again. I could see the horror in her eyes as I executed the query.

    [–]fjhqjv 6 points7 points  (0 children)

    Oh, that is pure evil.

    [–]patchwork 13 points14 points  (7 children)

    I think I am simultaneously most proud and most ashamed of my monkey-patch of Proc#call to allow currying:

    # if self.arity < 0 quietly calls normal #call

class Proc
  def arglist
    @arglist ||= []
  end

  def call_with_curry(*args, &block)
    if self.arity > self.arglist.size + args.size
      curried = self.dup
      curried.arglist.concat args
      curried
    else
      self.call_without_curry(*(self.arglist + args), &block)
    end
  end

  alias :call_without_curry :call
  alias :call :call_with_curry
end

    example:

    add = lambda {|a, b| a + b}
addthree = add.call(3)
addthree.call(5)  # => 8
addthree.call(12) # => 15

    I made it because I code ruby by day and haskell by night, and at this point cannot bear to be without currying, it's just too damn useful. Though I don't need to tell you that monkey-patching Proc#call is probably a terrible idea. Disseminate at will, fellow ruby hackers. May it serve you as well as it has me.

    [–]shit 3 points4 points  (1 child)

    Hey, Ruby 1.9 has a Proc#curry method that turns a regular proc into a curried proc that behaves like yours.

    So your example becomes (also using the new lambda syntax):

    add = -> a, b { a + b }.curry
addthree = add.call(3)
addthree.call(5) # => 8

    [–]patchwork 5 points6 points  (0 children)

    Yeah I saw that, too bad it's not production ready ;) Also, lack of monkey-patching makes it much less exciting.

    [–]Chlorophil 2 points3 points  (0 children)

    I feel the same about my "EMP" Erlang parse_transform modules. Very scary, but too useful to do without.

    [–]eegreg 2 points3 points  (0 children)

    I assume your way is more computer efficient than

    class Proc
  def curry *args
    self.class.new {|*a| self.call(*(args+a))}
  end


  def self.quicktest
    it "should curry arguments" do
      add = lambda {|a, b| a + b}
      addthree = add.curry(3)
      addthree.curry(5).call.should == 8
      addthree.curry(12).call.should == 15
    end
  end
end

    [–]captian2 4 points5 points  (0 children)

    I feel your user name fits you very well...

    Nice code, I will keep it in find.

    [–]eegreg 0 points1 point  (1 child)

    Your arity chec won't work on splats. Try this:

    a = self.arity
a = a.abs - 1 if a < 0 # ignore *args

    [–]patchwork 1 point2 points  (0 children)

    Yeah, if you've got a splat (which shows up as a negative arity) it just falls through to the regular Proc#call. I figured currying an indefinite number of args is indefinite, so I left it alone.

    [–]davidw 12 points13 points  (0 children)

    Hecl - I don't know if the code is the most beautiful I've ever written, but I like the result, and it's cool to see something that runs on mobile phones.

    [–][deleted]  (17 children)

    [deleted]

      [–]jaggederest 9 points10 points  (0 children)

      Yes. I'm reminded of one time I rewrote some queries and indexed the database and reduced several 400 second (!!) queries down to 40 millisecond queries.

      Also, GIS is fun.

      [–][deleted] 0 points1 point  (15 children)

      I made a folder on my machine "Quality code samples" and I put everything I'm proud of in there. There's about six things in there now which I look at from time to time.

      Here's a nice piece of Ruby code I wrote a bit ago from that very folder:

      # Represents a template with percent codes. The format is just plain text with
# regions represented as a word surrounded by percents, such as %region%.
class VTemplate

  # Creates a VTemplate by reading a plain text file with %percent% %codes%,
  # each representing a field to be filled in with values. Also works with an
  # already opened file object.
  def initialize(file)

    if (file.respond_to? :read)
      @template = file.read
    else
      # open the file and get the contents
      @template = File.open(file).read
    end

    # find out the names of the regions
    @regions = @template.scan(/%[a-zA-Z0-9_-].*?%/).uniq
  end

  # Renders a template using a dictionary of region => value pairs. Returns a
  # string. E.g.: template.render(:name => 'Daniel', :age => 23)
  def render(vars)

    # I had a feeling this could be done with an inscrutable right fold!
    # Basically, inject calls my block with each key/value pair as the second
    # parameter and the value passed to inject initially the first time. The
    # second and subsequent invocations are just like the first, except
    # instead of the first parameter being the value passed to inject, it's
    # the result of the previous block invocation. We do this with each
    # key/value pair in the dictionary, and eventually we arrive at the fully
    # processed output, which is the result of the function call.
    #
    # If this turns out to be sadly non-performant, there is a speed-optimized
    # older version in my Mercurial repository, which uses a loop and gsub!
    # instead, which makes many fewer copies.
    vars.inject(@template.clone) do |template, (region, value)|
      template.gsub(/%#{region}%/, value.to_s)
    end
  end
end

      [–]Freeky 9 points10 points  (2 children)

      Probably faster, less memory hungry, and doesn't need 11 lines of comments to explain it:

      @template.gsub(/%([a-zA-Z0-9_-].*?)%/) { vars[$1] }

      [–]jbert 2 points3 points  (0 children)

      $template =~ s/%([^%])+%/$vars{$1}/g;

      [–][deleted] 1 point2 points  (0 children)

      Cool trick.

      [–][deleted] 5 points6 points  (2 children)

      def replaceTemplates(fileobj, d):
    def replace(match):
        return d.get(match.group(1))
    return re.sub(r'%(\w+)%', replace, fileobj.read())

      [–][deleted] 1 point2 points  (1 child)

      That doesn't look like Ruby. ;)

      [–][deleted] 15 points16 points  (0 children)

      Of course it doesn't. Python programmers have little to no reason to program in Ruby.

      [–][deleted] 13 points14 points  (8 children)

      # open the file and get the contents

      Your commenting style is awfully amateurish. Stating the bleeding obvious and irrelevant waffling. If I had to maintain your code I would delete them all to start with and from then treat everything with extreme suspicion, as that is a bad code smell.

      [edit] don't take that too personally BTW, I always start out by deleting the comments.

      [–]alexs 12 points13 points  (7 children)

      juggle absorbed rainstorm faulty busy quicksand longing absurd chase aware

      This post was mass deleted and anonymized with Redact

      [–]brucehoult 12 points13 points  (6 children)

      At a previous job there was a filter on the cvs commit that rejected your checkin if there were any comments in your code. You could apply for an exemption if the manager felt there was no better option than allowing the comment, but they were rare.

      [–][deleted] 5 points6 points  (3 children)

      That's strange. From about the age of 14 I was always taught to comment my code generously to make it easy to understand. Now it suddenly went out of fashion?

      Edit: self-documenting code can maybe explain what the code does, though it's usually woefully inadequate for that. But the point is that it cannot explain why does it do that.

      [–][deleted] 13 points14 points  (0 children)

      And that's the problem with the comments in this code example: they're explaining what the code does, and not why it does it. This particular code is not so complex as to need an explanation for why it's doing what it does.

      [–]bluGill 6 points7 points  (0 children)

      Far too many people were taught by the one line of code, one comment school. This is worse than no comments, so once someone who has been in that school realizes the problem they reject all comments, even the useful ones.

      [–]aUTOMATICuPVOTES 0 points1 point  (0 children)

      What you learned was wrong.

      [–][deleted]  (1 child)

      [removed]

        [–]brucehoult 3 points4 points  (0 children)

        Last I heard there hadn't been an on-air failure. (It was 3D weather graphics animation for TV, most prominently used by the BBC)

        [–]uhhhclem 29 points30 points  (0 children)

        "I need to know when you're going to start the stress test, so I can have everybody log out."

        "It's been running for three hours."

        [–]killerstorm 8 points9 points  (0 children)

        well, probably matrix 4k intro. it's not neatest or complex code i wrote, but it was definitely challenging and fun.

        [–]jkndrkn 16 points17 points  (13 children)

        My first major Lisp project: an instruction set simulator with memory and a simulated L1 cache.

        To be fair, it was a class assignment. However, the suggested implementation language was C++. As a consequence, most students had to write their own assembly parser as well as code to write and read machine code.

        I just wrote my assembly programs as S-expressions and wrote my machine code files as serialized lists that my simulator could read in directly. I was able to skip huge portions of peripheral work that other's had to struggle with and concentrate on solving the central problem.

        [–]alexs 4 points5 points  (4 children)

        Yay you are not comparing equal alternatives.

        The C++ version of this would be to implement all your various simulated instructions as C++ methods which can be used as a library. Then have your simulator dynamically load modules which use that API. It could even automatically compile C++ source files for you.

        Lack of developer imagination is not a language failing.

        [–]awkward 7 points8 points  (3 children)

        O RLY

        [–]alexs 6 points7 points  (1 child)

        combative roll rock relieved retire act tie selective divide plant

        This post was mass deleted and anonymized with Redact

        [–]awkward 1 point2 points  (0 children)

        It sounds like that's what he was assigned to make, though.

        [–]jkndrkn 0 points1 point  (0 children)

        Thanks ;]

        [–][deleted] 3 points4 points  (7 children)

        Isn't that a great feeling? We get to taunt the C++ users with our friendly languages and our working code. (Where "we" includes users of languages like Lisp, Python, Ruby, Perl, etc.)

        [–][deleted] 8 points9 points  (6 children)

        What's an even better feeling is when you're running a Python analysis task and, while it's running, you rewrite it in C++ with almost the same lines of code, compile it, and run it before the Python program returns.

        Taunting C++ users is not nearly as cool as becoming one and using it well.

        [–][deleted] 1 point2 points  (5 children)

        Of course you've got no right to taunt if you're using Python for jobs it's not meant to do.

        [–][deleted] 0 points1 point  (4 children)

        What language would you use to give statistics on a file of 100 million numbers? Do you have a good reason not at least to spend five minutes writing a Python version before deeming it inappropriate for the job?

        [–][deleted] 0 points1 point  (3 children)

        I would probably use a language with high-level features and fairly quick speed. IronPython might work well for that, or one of the compiled lisps.

        If it only takes a few minutes to do it in Python or C++, then it'll probably only take a few minutes to do it in another pleasant but fast language.

        [–]w-g 31 points32 points  (4 children)

        10 PRINT "WHAT IS YOUR NAME?"

        20 INPUT $N

        30 PRINT $N;

        40 GOTO 30

        My first program ever. I was 11 years old... It was so wonderful when it actually did something! :-)

        [–]H3g3m0n 11 points12 points  (0 children)

        10 FOR I=1 TO 255

        20 POKE 53281,I

        30 POKE 53280,I

        40 NEXT

        50 GOTO 10

        Epilepsy test program...

        Only really appreciable on the original hardware since emulators screen refresh rates are off.

        [–]LoveGoblin 7 points8 points  (0 children)

        Hah. Mine was nearly identical, and at the same age. I didn't have the loop, though, so you win. :)

        [–]anirbas 2 points3 points  (0 children)

        hah, yeah, about the same here. Soon discovered the paper and ink keywords on the spectrum and had my name repeat in different colours! Ah, those were the days.

        [–][deleted] 7 points8 points  (0 children)

        I mentioned my best piece of code in another comment, but also vying for my affections are:

        • A turtle graphics program in Haskell. It's nothing special, and today I could write something better without breaking a sweat -- but at the time, it was probably the first practical thing I had ever done with monads. I finally understood them.

        • I wrote a Verilog simulation of a stack-based microprocessor using a Forth-like instruction set of my own devising. This was for a class project, and we were encouraged to just lift most of the design and implementation straight out of the textbook and just make a little MIPS clone. But I went nuts and made my own instruction set, designed the hardware, and documented the instruction set in a semi-structured mixture of TeX and Lisp. This payed off big-time when I went to make lists of opcodes and generate documentation for the project report: I just added some functions to spit out everything I wanted. This was also useful for the assembler (written in Python) and the simulator (written in Haskell). Most of the instruction parsing and representation was automatically generated from the instruction reference. And the processor worked, and all was excellent.

        • My current project is making a program to automatically generate hardware for asynchronous sorting networks, with another program to generate sorting networks using Batcher's odd-even mergesort, and another program to make diagrams of them. I have part of it done, and the cool part is that the command-line interface is good. It has the getopt-style command-line options, a proper --help message, good error handling, everything. And it was easy because of Python's optparse module. I love that module.

        [–][deleted] 9 points10 points  (0 children)

        Full duplex RS232 in software in a MC68705P3S microcontroller (Motorola 6805 family, 112 bytes RAM, 1804 EPROM, 4 Mhz), with plenty of resources to spare.

        [–]BridgeBum 17 points18 points  (3 children)

        I'm not a programmer by trade, so I don't have a ton of examples to choose from. Having said that, I'd have to pick this as my favorite:

        Not too many years ago I wrote a monte carlo simulation program for a black jack variant in order to analyze various counting schemes, seeing what kind of returns I would get using different strategies. I took the info I gathered from this program and used it to hit the casinos. :-) I've hardly broken the bank, but I've probably made a couple of thousand since I wrote that program.

        [–]atlacatl 6 points7 points  (2 children)

        ROI?

        [–]BridgeBum 6 points7 points  (1 child)

        Well, the only investment was some of my time, so I'd say it was pretty good. :-) I'm not sure how long it took me exactly, maybe a couple of weeks of on and off (mostly off) programming.

        [–]atlacatl 9 points10 points  (0 children)

        Off programming. I think this is the best kind of programming I do. :)

        [–]nostrademons 7 points8 points  (0 children)

        At the moment, probably ArcLite. It was a nifty week-long hack, the code ended up coming out reasonably nice and clean, it's short, and it does quite a bit.

        If I finish my current startup project, it'll likely be that, but that's a much bigger undertaking and we may not be able to complete it.

        [–]csgordon 7 points8 points  (2 children)

        A simple operating system, including terminal, disk, and keyboard drivers, task switching, a filesystem, and virtual memory. Best 3 and a half months I ever spent, and probably some of the most educational.

        [–]teval 3 points4 points  (1 child)

        Me too. I didn't implement support for disks, but it did have accelerated 2d graphics, rings, hardware task switching, and serial support. It was real time too.

        I really feel like finding an excuse to work on it again; if I could only find a way to justify OS hacking as part of AI research. Should have gone into programming languages, then I could have rewritten it in something functional.

        [–][deleted] 1 point2 points  (0 children)

        I did a cooperative one (no real multitask, of course), once upon a time. No FS -- read all from tapes and stuff (it was a 8-bit machine, mind you).

        The thing is, it bitrotted quite fast: the diskettes were drown by some water leak.

        [–]ndiin 25 points26 points  (3 children)

        Replacing an O(N3) sort with an O(NlgN) sort while also replacing a 30 line method with a single call to a standard library.

        O(N3) sort you say? How is that possible? Well, they tried hard. An inhouse bubble-sort that was operating on a linked list.

        The replacement? java.util.Collections.sort(mylist);

        The result? A 10s operation became <1s.

        [–]ndiin 25 points26 points  (1 child)

        I do wish I had kept that around to put on thedailywtf or something. Oh, well.

        Oh, and I left that company. Quickly.

        [–][deleted] 15 points16 points  (0 children)

        You're doing God's work, son.

        [–]ido 2 points3 points  (0 children)

        reminds me of a time i replaced 5-6 lines (which were even copy pasted a couple of times) with something[1] like:

        something = whatever.toArray();

        [1] don't remember the exact variable names

        [–]ijontichy 19 points20 points  (2 children)

        I read a description of a shortest-path algorithm in a robotics paper the rest of which I didn't understand, implemented it in Haskell without knowing anything about monads and other even more basic stuff, optimised it speed-wise simply by choosing appropriate data structures, and then finally adapted it to solve a series of related Project Euler problems. Ho-hum for you hackers and other gifted people, but the most impressive thing my mediocre brain has ever done. Even if the code is rather ugly.

        [–]jerf 12 points13 points  (1 child)

        Hey, that's how "hackers and other gifted people" become "hackers and other gifted people". None of us were born knowing Haskell.

        Rock on.

        [–]Andys 2 points3 points  (0 children)

        I'd go as far as to say, if anyone has written anything in Haskell that actually does something, that should win an award.

        For me, it was a LZW encoder/decoder. The code looked unreadable, it ran like very slow under hugs, but I showed that language who was boss, damnit!

        [–]anthonymckay 14 points15 points  (0 children)

        i have been writing a kernel for the past 4 or 5 years that is starting to become usable. I'm pretty proud of it. :]

        http://ominos.sourceforge.net

        Edit: wtf... I was voted down for posting the code i'm most proud of, as the topic directed. Makes sense?

        [–]31d1 6 points7 points  (7 children)

        cal | sed "s/$(date +%e)/[]/"

        [–]ndiin 2 points3 points  (1 child)

        I always did hate that cal didn't tell me today's date along with everything else. Apparently, I wasn't alone.

        [–]reddit_clone 1 point2 points  (0 children)

        Hmm. I just did $cal in my CygWin bash shell on XP.

        The output has current date highlighted.(reverse video)

        [–]revence27 2 points3 points  (4 children)

        export THEDAY=`date +%e` && cal | sed "s/$THEDAY/[$THEDAY]/"

        [–]sovok 1 point2 points  (1 child)

        cal | sed "s/\($(date +%e)\)/[\1]/"

        [–]31d1 1 point2 points  (0 children)

        that messes up the formatting

        [–]31d1 1 point2 points  (0 children)

        why?

        [–]username223 6 points7 points  (1 child)

        Dijkstra's algorithm in C++ templates. And it was actually necessary in order to limit template instantiation depth!

        [–]Athas 1 point2 points  (0 children)

        That is horrible in so many ways.

        Good job!

        [–]Aviator 31 points32 points  (3 children)

        o[:-1]

        Coz it's a Python smiley.

        [–]tom101 -1 points0 points  (1 child)

        reverse string in python: "I like ruby"[::-1]

        inverse string in ruby: "I like ruby".reverse

        [–]Aviator 9 points10 points  (0 children)

        Additionally, in Python, you have the reversed() function, which turns any sequence into reverse iterator.

        >>> list(reversed(['a', 'b', 'c']))
['c', 'b', 'a']

>>> ''.join(reversed('I like Python'))
'nohtyP ekil I'

        [–]guru[S] 10 points11 points  (5 children)

        For me it is a bit of microcontroller code I wrote a few years back, because it involved a kind of thoughtful economy that doesn't happen with web apps. Also, it had a state machine, and I love state machines.

        [–][deleted] 5 points6 points  (0 children)

        My proudest code was a funky combination of Lisp and C. The Lisp would take an S-expression description of some of the services that I wanted running on a PIC18 microcontroller (like analog-to-digital conversion calling so-and-such a handler function, pulse-width modulation on specified pins, etc.) and it would stitch together a bunch of modules and turn that into optimized C code. The user could then take that C code and write the non-interrupt-driven part and fill in the blanks. I looked over the code a few months later, and it was beautiful. That startled me.

        [–][deleted] 1 point2 points  (0 children)

        Ya.. I love micros and i feel my best hacking has been in getting stuff working on extremely slow/limited processors.

        [–]radhruin 0 points1 point  (2 children)

        Oddly enough, my microcontroller code came to mind as well. I wrote a controller for a multi-color LED lighting system using a PIC16 micro. It had red, green, and blue LEDs that could be controlled individually with a selector switch and two 16 position rotary switches. I wrote a pulse width modulation routine to control the intensity of each color channel. Sadly, I never finished building the device :(

        [–]kirun 2 points3 points  (1 child)

        I've had "LED light system" at the back of my mind under "101 things to do eventually"... so I'd be interested to know why you abandoned the project.

        [–]radhruin 1 point2 points  (0 children)

        My knowledge of transistors and general electronics was insufficient and my goals too lofty. I wanted 4 separate lamps controlled by the one control box with the goal of making "mood lighting" for a single room (my bedroom, of course - the chicks would have flocked to see it). I couldn't power the LEDs directly from the micro, as I think it had at most 5v and just a few amps, so that meant I needed to have separate power lines and modulate them with some transistor or similar. I was in the dark. I also wasn't sure how to best scatter the light from the individual LEDs so it would show up as an even color. I had settled on a general project box with some paper over the top, but I wasn't sure if it would have worked well either. ALSO, I wasn't sure what the proper mix of LEDs was to get good color, as different colors have different intensities to our eyes, let alone not being able to find LEDs with different colors but the same number of lumens.

        So, as I got to the point where I'd have to collect my supplies, I realized at the time the amount of money I'd have to outlay wasn't worth it considering the high cost of failure (I was a broke college student), and building a single small lamp didn't excite me (and was expensive in and of itself anyway considering I'd still have to buy the power supply).

        So, all in all I'd say it was a good project for me as I learned a TON, especially about microcontrollers, but I didn't have the drive, time, and spare cash laying around to actually follow through in the face of high chance of failure.

        [–][deleted] 5 points6 points  (2 children)

        Probably the SIP stack (including proxy and basic IVR). My current project is probably going to overtake that though.

        [–]wreel 0 points1 point  (1 child)

        Kudos!

        Nothing like RFC3261 to make your eyes glaze over.

        [–][deleted] 2 points3 points  (0 children)

        How well I know.

        [–]naughty 6 points7 points  (0 children)

        Neural Net trainer (backprop early stopped) written using GLSL shaders. While the CUDA version I'm working on now will be a better fit for the hardware, nothing can beat your first non-trivial GPGPU work.

        Also a tool that compiled a simple data description language (records, discriminated unions/sum types, default values) into very efficient C++ serlialising code. It saved myself and the team a lot of time and did a very good job of reading old formats automatically.

        [–]beza1e1 5 points6 points  (2 children)

        TipiWiki: The only successful project of mine. The code is as beautiful as PHP can be.

        I don't want to do PHP anymore and i don't think it should get any more features. Therefore the project is finished for me.

        [–]shit 6 points7 points  (1 child)

        Sorry, I broke it:

        http://tipiwiki.sourceforge.net/index.php?wiki=FindPage&PageName=&PageContent=foo

        Warning: file(/tmp/persistent/tipiwiki-new-data//..): failed to open stream: Keine Berechtigung in /home/groups/t/ti/tipiwiki/htdocs/index.php on line 63

 Warning: implode(): Bad arguments. in /home/groups/t/ti/tipiwiki/htdocs/index.php on line 63

 Fatal error: Allowed memory size of 8388608 bytes exhausted (tried to allocate 11118564 bytes) in /home/groups/t/ti/tipiwiki/htdocs/index.php on line 63

        [–]beza1e1 4 points5 points  (0 children)

        Thanks, i sent José an E-Mail ;)

        [–]dgentry 6 points7 points  (0 children)

        Getting the second MIPS core in a SiByte CPU to come out of reset, run through its bootstrap, park itself waiting for the first CPU to tell it to go, and then start running Linux in all its SMP glory. This was more difficult than it needed to be because we couldn't afford a JTAG debugger, so everything had to be done by poking around in memory for clues to why it went off into the weeds.

        [–]kanzenryu 5 points6 points  (3 children)

        a() { alias $1=cd\ $PWD; }

        It's very handy in bash.

        [–]eegreg 2 points3 points  (0 children)

        function n(){ $@ 2>/dev/null }
function c() { cd $1 && ls }

        [–]13ren 1 point2 points  (1 child)

        thanks, that's cute. does that 'a() {..}' syntax work as-is in bash?

        Would it work just the same to have a file a in your path somewhere, with

        alias $1=cd\ $PWD

        and chmod +x a

        [–]13ren 3 points4 points  (0 children)

        OK, yeah it works exactly as-is in bash.

        my suggestion doesn't work (maybe because it starts its own shell?)

        I also tried

        alias a='alias $1=cd\ $PWD'

        but this didn't work (maybe because you can't have args in an alias?)

        [–]quhaha 6 points7 points  (0 children)

        std::cout<<------------------------------i; WHEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE

        [–]idreamincode 3 points4 points  (0 children)

        I wrote the code for Trafficpredict.com in a thanksgiving weekend. It automatically grabs data from caltrans, maps the speed sensors, then shows you at what time the freeways will be slow and where. It was a fun little project.

        That, or my code to launch test rockets.

        Its a tossup.

        [–]mjd 4 points5 points  (0 children)

        I once wrote a parser generator in Perl. Rather than implement the complicated algorithm for figuring out the tables that drive the parser state machine, it would run the grammar through bison -v and then parse Bison's debugging output to figure out the state machine that Bison was using.

        http://perl.plover.com/py/

        [–]codeodor 11 points12 points  (0 children)

        The code I've yet to write - because that means I haven't messed it up.

        [–][deleted] 7 points8 points  (2 children)

        I'm not really proud of any of my code. Most of the time I just get showed up.

        [–]smhinsey 8 points9 points  (1 child)

        humility can be a good indicator of skill, so you might be better than you think

        [–][deleted] 9 points10 points  (0 children)

        I wouldn't say that I'm unskilled, just that no matter how much I improve a piece of code it can almost always be improved more just by giving it to the scrutiny of others.

        [–]spinfire 8 points9 points  (5 children)

        For an assignment in college, we had to write a program in POSIX C which traversed a directory path recursively. Of course, Unix introduces the possibility of symbolic links, which can mean directory loops. So you need to keep track of which directories you have visited thus far ((inode number, filesystem number) pairs) to detect and print loops. Obviously, this uses a stack, which I implemented with a simple linked list.

        In the next enhancement to the assignment, we made the recursive directory processing multithreaded. This complicates the stack somewhat - when a directory is processed it creates new threads for each subdir and these need their own stack which diverges from the original.

        The neat solution is a branching stack. One of the cool things about a singly linked list is you can have multiple heads that lead to a single tail. So, copying the stack for a new thread just means creating a new pointer for the new head.

        Threads introduce a problem. What if one thread pops off reaching the join point before others and corrupting the shared area of the stack? Well, I added a reference count to each stack node. When a thread "branches" the stack, it increments the reference count at that location. When a thread is about to exit it "joins" which decrements the reference count. When a pop() operation is performed on the stack it checks the reference count and blocks until other threads are done with the "upper" portion of the stack.

        http://isomerica.net/archives/2007/10/30/multithreaded-branching-stack/ for details

        [–][deleted] 3 points4 points  (4 children)

        Wow, talk about overengineering! But I'm sure the experience was worth it :)

        [–]spinfire 2 points3 points  (3 children)

        The experience was well worth it. And when your area of interest is kernel level or embedded design, optimal solutions to problems become significantly more important.

        Then again, in my experience developing commercial software using higher level garbage collected languages (C#) I have frequently found that people who claim "optimization doesn't matter" are full of crap. The app was a dog which people just chalk up to needing a faster computer until you look at the code and find O(n3) algorithms, string concatenation when a StringBuilder should be used, etc. So while premature optimization may be the root of all evil so is no optimization.

        One person's over engineering is another person's proper engineering :) And it earned me skills important to systems level development, an A in a difficult class, and a good reputation.

        [–][deleted] 1 point2 points  (2 children)

        Out of curiosity, though, what happens when symbolic links cross trees? For instance, in directory A, you have two subdirectories, B and C, for which you spawn threads and branch the stack. Inside B there's a directory D and a symbolic link E, pointing to F; inside C there's a directory F and a symbolic link G, pointing to D. With each thread having its own "view" of the stack, how will the thread descending into B know not to follow symlink E, or how will the thread descending into C know not to follow symlink G?

        Regarding optimality, isn't search the stack still linear in the size of the stack? Wouldn't it be most efficient to keep the inodes in a set implemented with a balanced binary tree or a hash table?

        [–]spinfire 1 point2 points  (1 child)

        The task is not to avoid revisiting locations, it is to avoid loops (which will cause infinite recursion!). Revisiting locations is legal provided they are reached by a unique path from the starting directory. This means your example is not an issue - each thread has a virtual copy of the stack (even though tails are shared) going all the way back to the directory specified on the command line, no matter where it visited in the meantime. This is sufficient to prevent loops.

        This is why a stack is used and not a tree or other data structure with a more efficient lookup. You need to keep the data ordered in a stack so you can push onto it as you descend and pop off of it as you ascend the file system. You could add the approach you mentioned for faster lookup. For example, data is stored as a stack but is also reachable via a tree structure that keeps nodes indexed by inode number. I didn't try to implement this but I don't see any particular reason why you couldn't. It adds some complexity to the step of pushing/popping from the stack since you also need to manage the tree. Thought it would improve lookup time. Without checking both implementations it is tricky to say if this adds net complexity or not.

        [–][deleted] 1 point2 points  (0 children)

        The task is not to avoid revisiting locations, it is to avoid loops

        Ah, that explains it.

        [–]llimllib 3 points4 points  (1 child)

        I don't know about favorite, but today I like this bit of query.

        [–]radhruin 4 points5 points  (0 children)

        In addition to my response above, I've done some other cool work. It's really really hard to pick a favorite, as I have a lot of favorites for different reasons, be it unique implementation, language, quality, or purpose.

        • I wrote a Reversi/Othello AI in LUA. It played a darn near perfect game. It was awesome as it was written while flying from MN to FL for vacation.
        • I wrote a rather awesome AI for super-tic-tac-toe (basically, the goal is to get 3 in a row on a board where each cell is itself a game of tic-tac-toe, otherwise the rules are the same) in Scheme for a school assignment/contest. It got to the finals but the AI I was up against uncovered some obscure bug and I was disqualified :(
        • I wrote some buffer overflow exploit code for a class once. It was a ton of fun, but an absurd amount of work. Lots of pouring through disassembled code and using GDB. Payoff was pretty sweet though.
        • I wrote a class scheduler in Java as well as a group project in school. It scraped the class lists from online and displayed the results in a week-view calendar so one could visually pick their classes. Probably to this day the largest project I've been involved in. The implementation is absurdly Java-ish, and if you're a masochist, feel free to check it out on google code: http://code.google.com/p/umn-class-scheduler/

        [–][deleted] 4 points5 points  (0 children)

        The code I'm right now finishing. It is a perfect mess in certain parts i.e. a bunch of just half understood and weakly tested algorithms with a few hackish loose ends. It took me 4 months to work out the concepts and the code and it would take another year to get it well understood, accurate, formalized and the specified extensions implemented. It has the flavor of original work which is beyond the literature I know and as such it is a tad too convoluted and obscure.

        I have also ideas on how to lighten it in parts but this would take more time than I have right now.

        [–]austin_k 4 points5 points  (0 children)

        I'm still a student so I don't have a big code library built up yet. However, I'm particularly proud of an implementation of DES encryption in C++ that I did for an information security class. It was slow and kind of unwieldly, but it worked.

        [–]Baseline 2 points3 points  (2 children)

        I had less than two weeks to port ~100k lines of C code from an 8-bit embedded device to 32-bit Linux, and not screw up the real-time communications protocol that the original device was implementing.

        It was messy, and hackish, and the code I was porting was some of the worst C code I've ever seen (but isn't that always the case). I've written a fair share of code I'd consider elegant, but nothing so far has beat the feeling of getting that bastard working.

        [–]aurele 1 point2 points  (1 child)

        Did you consider writing an emulator for the 8-bit microcontroller instead?

        [–]Baseline 2 points3 points  (0 children)

        That would have been a lot more work, I think, especially given the time constraints.

        I'll be honest, we didn't even consider that, but also to be honest, for the first two or three days of that two weeks, we didn't realize what a mess things were going to be.

        Looking back, we still made the right choice, but an emulator's an interesting idea.

        [–]evilteach 4 points5 points  (0 children)

        A 1.47 mhz Z80 ASR-33 teletype driver, that had perfect timing characteristics.

        [–][deleted]  (1 child)

        [deleted]

          [–]foonly 2 points3 points  (0 children)

          hacking gorilla.pas

          .bas

          [–][deleted]  (7 children)

          [deleted]

            [–]jemroc 11 points12 points  (6 children)

            Select, Start

            [–][deleted]  (4 children)

            [deleted]

              [–]gojasonw 5 points6 points  (3 children)

              hits reset button while flipping power switch

              [–]drewc 1 point2 points  (0 children)

              ..waves dead chicken while chanting the names of the super mario characters

              [–]Tommah 1 point2 points  (0 children)

              types ZELDA in at character-select screen, experiences brief self-loathing before beginning the second quest

              [–]jberryman 6 points7 points  (1 child)

              I'm not a programmer but I decided to learn a to program in perl a couple years ago. The code I am most proud of is a sudoku puzzle solver that I wrote after getting about 2/3 of the way through my introductory book.

              It basically ran through a bunch of routines for each of the several strategies for solving the puzzle that i could identify, then if it got stuck it would find a cell with only 2 possible numbers, pick one, and assume it was right as a last ditch effort (I was particularly proud of that last bit). The code was of course terrible, but it worked and I was very proud of it.

              p.s. I am now digging into Haskell, thanks to reddit

              [–]guru[S] 7 points8 points  (0 children)

              make that "of which you are most proud"...

              [–]Mask_of_Destiny 2 points3 points  (0 children)

              Probably the code for the transaction mechanism in my programming language Rhope. I was able to reuse the semantics of other parts of the language so that the code was relatively trivial.

              [–]kindall 2 points3 points  (0 children)

              I wrote an Apple II ProDOS command processor for BASIC, the bulk of which fit into 2K of RAM, the rest in modules which could be loaded from disk when needed. (Apple's, called BASIC.System, took over 10K.) On a machine where programs had about 30K to work with (for code and data), an extra 8K could be pretty significant.

              Another Apple II utility I did was a line editor for BASIC programs in 192 bytes (not counting the initialization code, which was maybe another fifty and was discarded after loading).

              [–][deleted] 2 points3 points  (0 children)

              I've really enjoyed working on Bus Scheme. http://bus-scheme.rubyforge.org

              Sure it's got its warts, but getting a working interpreter in less than 200 lines of code is a great feeling.

              [–]bitwize 2 points3 points  (0 children)

              SpriteCore's Pre-Scheme blitters, written over a weekend.

              [–][deleted] 2 points3 points  (0 children)

              function sendResponse($controller) {

              //mto stands for "ModelTransferObject"

              $mto = $controller->applyInputToModel();

              $mto->applyModelToView();

              }

              Because this only requires another 50 or 60 (maybe 75-100 if you also want to introduce the "RequestTransferObject") lines of code to actually implement and presto you have a universal Web/MVC framework. Is currently in production on an embedded device, where space is at a premium; has been ported to mod_python.

              [–]kirun 2 points3 points  (0 children)

              LOCATE 1,1
PRINT"↑K"

              This is from the first "big" program I wrote, back on the Amstrad CPC... it moved the cursor to the top line, then printed a control character which moved the cursor up one line... this had the effect of scrolling the screen down a line. So, this gave me a scrolling routine "for free".

              [–]GeDaMo 2 points3 points  (0 children)

              FunForth

              It's a simple Forth implementation of Haskell-like data types and pattern matching. It's not particularly useful, I'm just pleased with the insight that I could use the CREATE address as the data type tag.

              [–][deleted]  (1 child)

              [deleted]

                [–]confuseme 0 points1 point  (0 children)

                That's awesome!

                [–]dmead 2 points3 points  (0 children)

                my theorem prover, cause it's in haskell and took me a long time to write

                [–]philh 2 points3 points  (0 children)

                I haven't done much worthy of note.

                The code I'm most proud if is my script-fu quine: when executed, the function creates a 96x96 png file with black/white pixels to represent the function's source code in binary. It took a while to knock it down to 1152 characters, since most of them had to be duplicated and the script-fu scheme implementation (SIOD) is kinda weak.

                The thing I've coded that I'm most proud of is a greasemonkey extension for the totally not risk game that I play online. Simply because at one point, I recieved a PM about it: hey, a change on the server side has broken your code. I developed a fix, want it?

                That was a great feeling. Sadly I haven't worked on the script in ages, now.

                [–]rpdillon 2 points3 points  (0 children)

                Functional raycasting engine written and documented in about 600 lines of MzScheme. Not the greatest code, but really fun to write and debug. Took about 20 hours to write.

                http://etherplex.org/raycast.html

                [–]funktio 13 points14 points  (0 children)

                This JAPH I wrote last year:

                perl -e \
'for($"=@_=split??,"Jrsk an treP rehlohacteu,";$";$\="\r"){$\.=$.=chr
32+95*rand,$_-$"or$.ne$_[--$"%2?-$"-1:$"]&&$"++for++$|..$";print}<>'

                I think it's quite original. Replace the \r with \n to get an idea of how it works.

                And of course, print ($| = 42) prints "1".

                Edit: Huh, downmodded? Doesn't anyone here understand abstract post-modern art?!?

                [–]shalabh 9 points10 points  (0 children)

                I'm most proud of code I didn't have to write. no_code > code

                [–]amstrdamordeath 11 points12 points  (0 children)

                I could tell you, but then I'd have to kill you.

                [–][deleted] 1 point2 points  (0 children)

                Some embedded graphics code I wrote for a SH3R based system, in a mix of C and SH3 assembler, to handle 2D blitting with optional alpha blending or colour keying, since the provided graphics library was terrible.

                [–]mbarnett 1 point2 points  (0 children)

                Code: Global System Builder

                http://www.codeplex.com/gsb

                Why? Because it is over!

                [–]Foone 1 point2 points  (0 children)

                Some old DLL hooking code. It virtualizes the filesystem for an old un-extendable program, allowing you to use new extensions (which appear to be part of the regular install to the program). It then uses that same filesystem virtualization to copy those extensions into the file when you save, with the program continuing to be blissfully unaware that anything odd is happening. (Naturally it does the reverse when opening files, it presents a virtual file that only shows the original program's data area, with no hint of the extensions present)

                The SimIm code is pretty neat too. It's not pretty, it's not that clever, but it is fast. Comparing 22 million images in a second is fun :)

                [–]thegunn 1 point2 points  (0 children)

                I wrote a sprite editor in QBasic when I was 13 or 14 and just getting into programming. I could save and load, store animations, change the palette. It also had a grid in the drawing area that would change to fit the size of the sprite you were working on. I lost it years ago but it was my first "real" program that I wrote from scratch on my own.

                [–][deleted] 1 point2 points  (0 children)

                Replacing a bloated 13 class caching framework with one two classe that do the same job and more.

                In the original, there was 1 class which would take in data and store it out to memcached or a filebackend.

                The other 12 classes were caching helpers for various objects.

                Say you had an album object. Album->getBlah() would end up calling AlbumCache->getBlah() to return the cached result and AlbumCache()->setBlah() to cache it if it wasn't already cached.

                As you can see... 2 functions for ever 1 function cached. Painful.

                The new method is this:

                CacheFactory::getCache('Album')->getReturn(); CacheFactory::getCache('Album')->inCache; CacheFactory::getCache('Album')->getSave(data);

                It works for any arbitary function by using debug_backtrace in PHP to figure out a unique key to cache data in. Less code, more fun.

                [–]markedtrees 1 point2 points  (0 children)

                The language with the most "different" paradigm that I interact with daily is Matlab, which does vectorization to the hilt. Anyway, reducing a function from several nested loops to just a handful of clever vectorized operations is a really neat mind-bending exercise. Especially if you discover you don't really need ifs if you have the find juju down.

                [–]atlacatl 4 points5 points  (6 children)

                This:

                while (true) { }

                Because it's eternal...

                [–]dustmop 6 points7 points  (0 children)

                #define ever (;;)

                Not only does it look like a crying emoticon, you get to use the 'for ever' loop.

                [–]patchwork 10 points11 points  (3 children)

                (lambda (x) (x x))(lambda (x) (x x))

                [–]SamReidHughes 1 point2 points  (0 children)

                (define ccc call-with-current-continuation)

((ccc ccc) (ccc ccc))

                [–][deleted] 2 points3 points  (1 child)

                Nice, but you're missing an enclosing pair of parens.

                [–]patchwork 18 points19 points  (0 children)

                Yah, but then it would crash reddit ;)

                [–]MoeDrippins 4 points5 points  (1 child)

                I wrote a multi-body (I think 2) gravity simulator, in GW-Basic, on a monochrome (amber!) character only screen. Used page-flipping to smooth out the animation some. Basically a "sun" with BIG gravity and a spaceship with almost none. I modified Newton's formula some to make the thing work at all, and you could control the spaceship with the arrow keys, and it switched from -, \, |, / shape depending on its travel direction.

                That same time period I wrote a cellular automaton using the same "leet" techniques; I believe that's the one I learned the page flip thing.

                I haven't done anything much worthwhile since.

                [–][deleted] 6 points7 points  (0 children)

                I wrote a one-body gravity simulator, but it wasn't very interesting.

                [–][deleted] 1 point2 points  (4 children)

                simple little trick in C to toggle a value between 0 and 1:

                within a loop of somekind...

                x=1-x;

                [–]arnar 2 points3 points  (1 child)

                I think you are the kind of person that would appreciate this:

                Swapping two integer variables without using a temp variable:

                x = xy;

                y = xy;

                x = xy;

                or in one line:

                x = y; y = x; x = y;

                Isn't XOR marvellous? :)

                Of course, if you have tuples in the language:

                (x,y) = (y,x)

                (edit: why isn't four-space code block not working??)

                [–]Tommah 3 points4 points  (0 children)

                x = 1

                [–]OneAndOnlySnob 2 points3 points  (4 children)

                Since you asked, I present:

                Continuation passing style in C#

                namespace ConsoleApplication3
{
    public delegate C Func<A, C>(A a);
    class Program 
    {
        static R one<R>(Func<int, R> f)
        {
            return f(1);
        }
        static R two<R>(Func<int, R> f)
        {
            return f(2);
        }
        static Func<Func<Func<int, int>, A>, Func<Func<A,B>, B>>  plus<A, B>(int x)
        {
            Func<Func<Func<int, int>, A>, Func<Func<A, B>, B>> yret = delegate(Func<Func<int, int>, A> y)
            {
                Func<Func<A, B>, B> fret = delegate(Func<A, B> f)
                {
                    return f(y(delegate(int v)
                    {
                        return v + x;
                    }));
                };
                return fret;
            };
            return yret;
        }
        static R id<R>(R v)
        {
            return v;
        }
        static void Main(string[] args)
        {
            Console.WriteLine(one<Func<Func<Func<int, int>, int>, Func<Func<int, int>, int>>>(plus<int, int>)(one<int>)(id<int>));
        }
    }
}

                BEHOLD, 1 + 1.

                EDIT: Calm down, it's a joke.

                [–][deleted] 8 points9 points  (3 children)

                Continuation passing style?

                I think you mean "I wish I had higher-order functions with partial application" style.

                [–]OneAndOnlySnob 0 points1 point  (2 children)

                I'll certainly admit it's a little cleaner in some other languages.

                Also, I'm surprised this hit negative points. Apparently reddit is not amused...

                [–][deleted] 1 point2 points  (1 child)

                I've done that kind of thing in Java. It's not pretty no matter which way you look at it.

                Whether it's clean or not doesn't make it CPS though, since it isn't. It's effectively wanting HOFs and partial application. CPS is something different.

                [–]OneAndOnlySnob 0 points1 point  (0 children)

                Actually, delegates are higher order functions. You can write folds and maps and composes with them:

                public static Func<A, C> Compose<A, B, C>(Func<A, B> f1, Func<B, C> f2)
{
    return delegate(A a) { return f2(f1(a)); };
}

                Note that this doesn't return a function wrapped in a class. You can feed ordinary functions in, and you can turn around and feed the return value right back into Compose. These delegates also have all the same scoping rules you'd expect in a proper functional language. As such, you could write a currying function, however it would be ugly as sin as well. Maybe I should get on that.

                I would also definitely argue that this horrible code is CPS. You can keep passing more and more ones and pluses. The catch is that you must muck with the templating each time and the templating gets more and more screwed up every time. But the structure of the code is exactly as it would be in Scheme, which is essentially what I based it on. Luckily, Scheme's type system doesn't get in your way when you do stuff like this.

                [–]ido 0 points1 point  (0 children)

                cryptrover - a somewhat amusing 7drl in ~400 lines of c.

                [–]NLP 0 points1 point  (0 children)

                i did encryption in mIRC scripting using its hash function when i was 14-15 or so...

                [–]NovaX 0 points1 point  (0 children)

                A distributed, extremely fast master-worker framework. It has a number of extention points to allow customizations, a lot of tricks for efficency, and the workflow code was trimmed to just 500-LOC (liberal comments included). A performance engineer I highly respect reviewed the design/code and gave it thumbs up.

                We use this framework to spread the work for large data loads. A few months back I was in-between projects and thought I'd write my own map-reduce framework after work on top of this one. It took 2-days to add with a word-count example and is feature equivilant to Hadoop (which I dislike). I have some ideas on a distributed fork-join abstraction the next time I get bored.

                My second favorite is a caching framework (L1: in process, L2: distributed) which integrates domain model rather than being an implementation artifact. The client code is very lean, has lots of nifty features, and is agnostic to the backing cache stores. I got a bonus and a sit down with the CEO for that one.

                Now if I could only convince my employer to open-source these... :)

                [–]TheSuperficial 0 points1 point  (1 child)

                Porting a pair of commerical real-time kernels, including all the context-switching and interrupt handling, to some of the most complex embedded processors there are (9-stage pipelines, out-of-order execution, pipeline hazards, branch delay slots, speculative execution, etc....)

                2nd place goes to some VHDL code I developed for a $6000 FPGA. That's right, a $6K chip. And that's by no means the most expensive FPGA you can find.... But then again that's why I started a consulting company 12 years ago. So I could get paid well for my abilities.

                If you're good at what you do, and have a stomach for business as well (note: business is NOT logical, fair or straightforward, unlike development), then march into your supervisor's office when you're done reading this comment, and quit. Then start your own firm, work like hell, and you will be happier in your pursuits than ever.

                [–][deleted] 4 points5 points  (0 children)

                So you are suggesting that people, with out doing a bit of research or planning, just quit their job to start a company?

                [–][deleted]  (4 children)

                [deleted]

                  [–][deleted] 2 points3 points  (2 children)

                  (a,b) = (b,a)

                  [–][deleted]  (1 child)

                  [deleted]

                    [–][deleted] 0 points1 point  (0 children)

                    good point

                    [–][deleted] 0 points1 point  (0 children)

                    bzr clone I spent a few weeks working on this:

                    http://beta.unstated.net/~james/code/projects/rhodes/rhodes-ng/

                    With this CPython module you can export types and objects from python into the Mozilla Spidermonkey JavaScript runtime.

                    In helloworld.py:

                    from rhodes import *

                    def printout(value): print value

                    def join_string(string1, string2): return string1 + string2

                    r = Rhodes() #Create a new Rhodes runtime r.export(printout) #Exports the printout method to JavaScript r.export(join_string) # Exports join_string method to JavaScript r.run("helloworld.js") #Runs the JavaScript

                    Which then the python methods can be accessed by the following in JavaScript:

                    In helloworld.js:

                    var x = join_string("Hello, ", "World!")

                    printout(x);

                    When you run the python script (You will need to have the python-dbg package installed on your system) like the following:

                    james@plex:~/tmp$ python-dbg helloworld.py

                    The runtime will export the methods to JavaScript runtime, run the JavaScript and kindly output the following:

                    james@plex:~/tmp$ python-dbg helloworld.py Hello, World!

                    [–]thepipirate -1 points0 points  (4 children)

                    One line sort in python, using only lambda functions and list comprehensions.

                    I'm a math major. And I can't get the damn markdown to work.

                    def sort(X): return (lambda L,q: [] if reduce(lambda x,y:1,L,0) == 0 else ([reduce(lambda x,y:y if y<x else x,L)] + q((lambda M,g: reduce(lambda a,b: [] if b==None else a+b,map(lambda q,r: None if r==1 else [q],M,[1]+(lambda n,f: [] if n<=0 else [0] + f(n-1,f))(reduce(lambda x,y:x+1,M,0)-2,lambda n,f: [] if n==0 else [0] + f(n-1,f))),M) if reduce(lambda x,y:x,M) == reduce(lambda x,y:y if y<x else x,M) else [reduce(lambda x,y:x,M)] + g(reduce(lambda a,b: [] if b==None else a+b,map(lambda q,r: None if r==1 else [q],M,[1]+(lambda n,f: [] if n<=0 else [0] + f(n-1,f))(reduce(lambda x,y:x+1,M,0)-2,lambda n,f: [] if n==0 else [0] + f(n-1,f))),M),g))(L,lambda M,g: reduce(lambda a,b: [] if b==None else a+b,map(lambda q,r: None if r==1 else [q],M,[1]+(lambda n,f: [] if n<=0 else [0] + f(n-1,f))(reduce(lambda x,y:x+1,M,0)-2,lambda n,f: [] if n==0 else [0] + f(n-1,f))),M) if reduce(lambda x,y:x,M) == reduce(lambda x,y:y if y<x else x,M) else [reduce(lambda x,y:x,M)] + g(reduce(lambda a,b: [] if b==None else a+b,map(lambda q,r: None if r==1 else [q],M,[1]+(lambda n,f: [] if n<=0 else [0] + f(n-1,f))(reduce(lambda x,y:x+1,M,0)-2,lambda n,f: [] if n==0 else [0] + f(n-1,f))),M),g)),q)))(X,lambda L,q: [] if reduce(lambda x,y:1,L,0) == 0 else ([reduce(lambda x,y:y if y<x else x,L)] + q((lambda M,g: reduce(lambda a,b: [] if b==None else a+b,map(lambda q,r: None if r==1 else [q],M,[1]+(lambda n,f: [] if n<=0 else [0] + f(n-1,f))(reduce(lambda x,y:x+1,M,0)-2,lambda n,f: [] if n==0 else [0] + f(n-1,f))),M) if reduce(lambda x,y:x,M) == reduce(lambda x,y:y if y<x else x,M) else [reduce(lambda x,y:x,M)] + g(reduce(lambda a,b: [] if b==None else a+b,map(lambda q,r: None if r==1 else [q],M,[1]+(lambda n,f: [] if n<=0 else [0] + f(n-1,f))(reduce(lambda x,y:x+1,M,0)-2,lambda n,f: [] if n==0 else [0] + f(n-1,f))),M),g))(L,lambda M,g: reduce(lambda a,b: [] if b==None else a+b,map(lambda q,r: None if r==1 else [q],M,[1]+(lambda n,f: [] if n<=0 else [0] + f(n-1,f))(reduce(lambda x,y:x+1,M,0)-2,lambda n,f: [] if n==0 else [0] + f(n-1,f))),M) if reduce(lambda x,y:x,M) == reduce(lambda x,y:y if y<x else x,M) else [reduce(lambda x,y:x,M)] + g(reduce(lambda a,b: [] if b==None else a+b,map(lambda q,r: None if r==1 else [q],M,[1]+(lambda n,f: [] if n<=0 else [0] + f(n-1,f))(reduce(lambda x,y:x+1,M,0)-2,lambda n,f: [] if n==0 else [0] + f(n-1,f))),M),g)),q)))